702 files changed, 19994 insertions, 160439 deletions

diff --git a/sources/pyside6/.cmake.conf b/sources/pyside6/.cmake.conf
index 7ed64b147..201688f47 100644
--- a/sources/pyside6/.cmake.conf
+++ b/sources/pyside6/.cmake.conf
@@ -1,5 +1,5 @@
 set(pyside_MAJOR_VERSION "6")
-set(pyside_MINOR_VERSION "4")
+set(pyside_MINOR_VERSION "7")
 set(pyside_MICRO_VERSION "0")
 set(pyside_PRE_RELEASE_VERSION_TYPE "a")
 set(pyside_PRE_RELEASE_VERSION "1")
diff --git a/sources/pyside6/CMakeLists.txt b/sources/pyside6/CMakeLists.txt
index f73133fa1..f45c07114 100644
--- a/sources/pyside6/CMakeLists.txt
+++ b/sources/pyside6/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 include(cmake/Macros/icecc.cmake) # this must be the first line!
 
 cmake_minimum_required(VERSION 3.18)
@@ -8,6 +11,14 @@ project(pysidebindings)
 
 include(cmake/PySideSetup.cmake)
 
+get_rpath_base_token(base)
+
+if (${STANDALONE})
+    set(CMAKE_INSTALL_RPATH ${base}/ ${base}/Qt/lib ${base}/../shiboken6/)
+else()
+    set(CMAKE_INSTALL_RPATH ${base}/ ${QT6_INSTALL_PREFIX}/${QT6_INSTALL_LIBS} ${base}/../shiboken6/)
+endif()
+
 add_subdirectory(libpyside)
 
 if(Qt${QT_MAJOR_VERSION}Qml_FOUND)
@@ -30,3 +41,5 @@ if(BUILD_TESTS)
 endif()
 
 add_subdirectory(doc)
+
+add_subdirectory(qtexampleicons)
diff --git a/sources/pyside6/PySide6/CMakeLists.txt b/sources/pyside6/PySide6/CMakeLists.txt
index 95693ff67..37b7a6c9c 100644
--- a/sources/pyside6/PySide6/CMakeLists.txt
+++ b/sources/pyside6/PySide6/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(pyside6)
 
 # Configure include based on platform
@@ -90,6 +93,8 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_config.py"
         DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside6_SUFFIX}")
 install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_git_pyside_version.py"
         DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside6_SUFFIX}")
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/support"
+        DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside6_SUFFIX}")
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/templates/common.xml
         DESTINATION share/PySide6${pyside_SUFFIX}/typesystems)
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/templates/core_common.xml
@@ -104,3 +109,6 @@ install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/templates/opengl_common.xml
         DESTINATION share/PySide6${pyside_SUFFIX}/typesystems)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pyside6_global.h
         DESTINATION include/${BINDING_NAME}${pyside6_SUFFIX})
+
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/QtAsyncio"
+        DESTINATION "${PYTHON_SITE_PACKAGES}/${BINDING_NAME}${pyside6_SUFFIX}")
diff --git a/sources/pyside6/PySide6/Qt3DAnimation/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DAnimation/CMakeLists.txt
index e81882e79..d9169924e 100644
--- a/sources/pyside6/PySide6/Qt3DAnimation/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DAnimation/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DAnimation)
 
 set(Qt3DAnimation_SRC
@@ -16,6 +19,7 @@ ${Qt3DAnimation_GEN_DIR}/qt3danimation_qanimationcliploader_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qanimationcontroller_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qanimationgroup_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qblendedclipanimator_wrapper.cpp
+${Qt3DAnimation_GEN_DIR}/qt3danimation_qcallbackmapping_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qchannel_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qchannelcomponent_wrapper.cpp
 ${Qt3DAnimation_GEN_DIR}/qt3danimation_qchannelmapper_wrapper.cpp
@@ -39,12 +43,14 @@ set(Qt3DAnimation_include_dirs
                      ${pyside6_SOURCE_DIR}
                      ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIR}
+                     ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DCore_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DRender_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DAnimation_INCLUDE_DIRS}
                      ${libpyside_SOURCE_DIR}
                      ${QtCore_GEN_DIR}
                      ${QtGui_GEN_DIR}
+                     ${QtOpenGL_GEN_DIR}
                      ${Qt3DCore_GEN_DIR}
                      ${Qt3DRender_GEN_DIR}
                      ${Qt3DAnimation_GEN_DIR})
diff --git a/sources/pyside6/PySide6/Qt3DAnimation/typesystem_3danimation.xml b/sources/pyside6/PySide6/Qt3DAnimation/typesystem_3danimation.xml
index f93a51b59..61af82d6d 100644
--- a/sources/pyside6/PySide6/Qt3DAnimation/typesystem_3danimation.xml
+++ b/sources/pyside6/PySide6/Qt3DAnimation/typesystem_3danimation.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DAnimation">
+<typesystem package="PySide6.Qt3DAnimation"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="Qt3DRender/typesystem_3drender.xml" generate="no"/>
     <namespace-type name="Qt3DAnimation">
         <object-type name="QAbstractAnimation">
@@ -36,6 +37,7 @@
         <object-type name="QBlendedClipAnimator"/>
         <value-type name="QChannel"/>
         <value-type name="QChannelComponent"/>
+        <object-type name="QCallbackMapping"/>
         <object-type name="QChannelMapper" since="6.1"/>
         <object-type name="QChannelMapping"/>
         <object-type name="QClipAnimator"/>
diff --git a/sources/pyside6/PySide6/Qt3DCore/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DCore/CMakeLists.txt
index b2a4ddc4b..cd2699f11 100644
--- a/sources/pyside6/PySide6/Qt3DCore/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DCore/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DCore)
 
 set(Qt3DCore_SRC
@@ -16,6 +19,7 @@ ${Qt3DCore_GEN_DIR}/qt3dcore_qbackendnodemapper_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qboundingvolume_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qbuffer_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qcomponent_wrapper.cpp
+${Qt3DCore_GEN_DIR}/qt3dcore_qcoreaspect_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qcoresettings_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qentity_wrapper.cpp
 ${Qt3DCore_GEN_DIR}/qt3dcore_qgeometry_wrapper.cpp
diff --git a/sources/pyside6/PySide6/Qt3DCore/typesystem_3dcore.xml b/sources/pyside6/PySide6/Qt3DCore/typesystem_3dcore.xml
index 28a11bdeb..985c459b6 100644
--- a/sources/pyside6/PySide6/Qt3DCore/typesystem_3dcore.xml
+++ b/sources/pyside6/PySide6/Qt3DCore/typesystem_3dcore.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DCore">
+<typesystem package="PySide6.Qt3DCore"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <smart-pointer-type name="QSharedPointer" type="shared" getter="data"
                         reset-method="reset"
@@ -49,6 +50,7 @@
             </modify-argument>
           </modify-function>
         </object-type>
+        <object-type name="QCoreAspect"/>
         <object-type name="QCoreSettings"/>
         <object-type name="QGeometry"/>
         <object-type name="QGeometryView">
@@ -74,6 +76,7 @@
         </object-type>
     </namespace-type>
 
-    <!-- reject Qt enum helper functions in Qt3D namespaces -->
-    <rejection class="^Qt3D.*$" function-name="^qt_getEnum.*$"/>
+    <!-- QtNetwork is pulled in via QtBluetoothDepends. -->
+    <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/Qt3DExtras/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DExtras/CMakeLists.txt
index 181672c34..6f6f637fe 100644
--- a/sources/pyside6/PySide6/Qt3DExtras/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DExtras/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DExtras)
 
 set(Qt3DExtras_SRC
@@ -57,12 +60,14 @@ set(Qt3DExtras_include_dirs
                      ${pyside6_SOURCE_DIR}
                      ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
+                     ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DCore_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DRender_INCLUDE_DIRS}
                      ${Qt${QT_MAJOR_VERSION}3DExtras_INCLUDE_DIRS}
                      ${libpyside_SOURCE_DIR}
                      ${QtCore_GEN_DIR}
                      ${QtGui_GEN_DIR}
+                     ${QtOpenGL_GEN_DIR}
                      ${Qt3DCore_GEN_DIR}
                      ${Qt3DRender_GEN_DIR})
 
diff --git a/sources/pyside6/PySide6/Qt3DExtras/typesystem_3dextras.xml b/sources/pyside6/PySide6/Qt3DExtras/typesystem_3dextras.xml
index 009dbdc9e..d281ae15f 100644
--- a/sources/pyside6/PySide6/Qt3DExtras/typesystem_3dextras.xml
+++ b/sources/pyside6/PySide6/Qt3DExtras/typesystem_3dextras.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DExtras">
+<typesystem package="PySide6.Qt3DExtras"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="Qt3DRender/typesystem_3drender.xml" generate="no"/>
     <namespace-type name="Qt3DExtras">
         <object-type name="QAbstractCameraController">
diff --git a/sources/pyside6/PySide6/Qt3DInput/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DInput/CMakeLists.txt
index 6a58dc881..c27c27718 100644
--- a/sources/pyside6/PySide6/Qt3DInput/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DInput/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DInput)
 
 set(Qt3DInput_SRC
diff --git a/sources/pyside6/PySide6/Qt3DInput/typesystem_3dinput.xml b/sources/pyside6/PySide6/Qt3DInput/typesystem_3dinput.xml
index 96160aeef..fbdfc5961 100644
--- a/sources/pyside6/PySide6/Qt3DInput/typesystem_3dinput.xml
+++ b/sources/pyside6/PySide6/Qt3DInput/typesystem_3dinput.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DInput">
+<typesystem package="PySide6.Qt3DInput"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="Qt3DCore/typesystem_3dcore.xml" generate="no"/>
     <namespace-type name="Qt3DInput">
         <object-type name="QAbstractActionInput"/>
diff --git a/sources/pyside6/PySide6/Qt3DLogic/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DLogic/CMakeLists.txt
index 2f4105dfa..b9da0cceb 100644
--- a/sources/pyside6/PySide6/Qt3DLogic/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DLogic/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DLogic)
 
 set(Qt3DLogic_SRC
diff --git a/sources/pyside6/PySide6/Qt3DLogic/typesystem_3dlogic.xml b/sources/pyside6/PySide6/Qt3DLogic/typesystem_3dlogic.xml
index eef763e83..60f362534 100644
--- a/sources/pyside6/PySide6/Qt3DLogic/typesystem_3dlogic.xml
+++ b/sources/pyside6/PySide6/Qt3DLogic/typesystem_3dlogic.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DLogic">
+<typesystem package="PySide6.Qt3DLogic"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="Qt3DCore/typesystem_3dcore.xml" generate="no"/>
     <namespace-type name="Qt3DLogic">
         <object-type name="QFrameAction"/>
diff --git a/sources/pyside6/PySide6/Qt3DRender/CMakeLists.txt b/sources/pyside6/PySide6/Qt3DRender/CMakeLists.txt
index 2bfd5a4db..72f859305 100644
--- a/sources/pyside6/PySide6/Qt3DRender/CMakeLists.txt
+++ b/sources/pyside6/PySide6/Qt3DRender/CMakeLists.txt
@@ -1,5 +1,10 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(Qt3DRender)
 
+set(Qt3DRender_DROPPED_ENTRIES)
+
 set(Qt3DRender_SRC
 ${Qt3DRender_GEN_DIR}/qsharedpointer_propertyreaderinterface_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qsharedpointer_qtextureimagedata_wrapper.cpp
@@ -23,6 +28,7 @@ ${Qt3DRender_GEN_DIR}/qt3drender_qclipplane_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qcolormask_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qcomputecommand_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qcullface_wrapper.cpp
+${Qt3DRender_GEN_DIR}/qt3drender_qdebugoverlay_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qdepthrange_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qdepthtest_wrapper.cpp
 ${Qt3DRender_GEN_DIR}/qt3drender_qdirectionallight_wrapper.cpp
@@ -131,13 +137,16 @@ set(Qt3DRender_include_dirs
                      ${libpyside_SOURCE_DIR}
                      ${QtCore_GEN_DIR}
                      ${QtGui_GEN_DIR}
-                     ${QtOpenGL_GEN_DIR}
+
                      ${Qt3DCore_GEN_DIR})
 
 set(Qt3DRender_libraries pyside6
                      ${Qt${QT_MAJOR_VERSION}3DRender_LIBRARIES})
 
-set(Qt3DRender_deps Qt3DCore QtOpenGL)
+set(Qt3DRender_deps Qt3DCore)
+
+check_qt_opengl("3DRender" Qt3DRender_include_dirs Qt3DRender_deps
+                Qt3DRender_DROPPED_ENTRIES)
 
 create_pyside_module(NAME Qt3DRender
                      INCLUDE_DIRS Qt3DRender_include_dirs
@@ -145,4 +154,5 @@ create_pyside_module(NAME Qt3DRender
                      DEPS Qt3DRender_deps
                      TYPESYSTEM_PATH Qt3DRender_SOURCE_DIR
                      SOURCES Qt3DRender_SRC
-                     TYPESYSTEM_NAME ${Qt3DRender_BINARY_DIR}/typesystem_3drender.xml)
+                     TYPESYSTEM_NAME ${Qt3DRender_BINARY_DIR}/typesystem_3drender.xml
+                     DROPPED_ENTRIES Qt3DRender_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/Qt3DRender/typesystem_3drender.xml b/sources/pyside6/PySide6/Qt3DRender/typesystem_3drender.xml
index 3ebb09369..66fd70927 100644
--- a/sources/pyside6/PySide6/Qt3DRender/typesystem_3drender.xml
+++ b/sources/pyside6/PySide6/Qt3DRender/typesystem_3drender.xml
@@ -4,8 +4,14 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.Qt3DRender">
+<typesystem package="PySide6.Qt3DRender"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="Qt3DCore/typesystem_3dcore.xml" generate="no"/>
+    <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
+    <!-- PYSIDE-2610: QOpenGLTexture's enums are used -->
+    <?if !no_QtOpenGL?>
+    <load-typesystem name="QtOpenGL/typesystem_opengl.xml" generate="no"/>
+    <?endif?>
     <smart-pointer-type name="QSharedPointer" type="shared" getter="data"
                         reset-method="reset"
                         instantiations="Qt3DRender::PropertyReaderInterface=Qt3DRender::PropertyReaderInterfacePtr,Qt3DRender::QTextureImageData=Qt3DRender::QTextureImageDataPtr,Qt3DRender::QTextureImageDataGenerator=Qt3DRender::QTextureImageDataGeneratorPtr"/>
@@ -29,9 +35,7 @@
             <enum-type name="Target"/>
             <enum-type name="TextureFormat"/>
         </object-type>
-        <object-type name="QAbstractTextureImage">
-            <modify-function signature="QAbstractTextureImage(Qt3DCore::QNode*)" remove="all"/>
-        </object-type>
+        <object-type name="QAbstractTextureImage"/>
         <object-type name="QAlphaCoverage"/>
         <object-type name="QAlphaTest">
             <enum-type name="AlphaFunction"/>
@@ -64,6 +68,7 @@
         <object-type name="QCullFace">
             <enum-type name="CullingMode"/>
         </object-type>
+        <object-type name="QDebugOverlay"/>
         <object-type name="QDepthRange"/>
         <object-type name="QDepthTest">
             <enum-type name="DepthFunction"/>
@@ -222,9 +227,7 @@
             <enum-type name="Status"/>
         </object-type>
         <object-type name="QTextureImageData"/>
-        <object-type name="QTextureImageDataGenerator">
-            <modify-function signature="QTextureImageDataGenerator()" remove="all"/>
-        </object-type>
+        <object-type name="QTextureImageDataGenerator"/>
         <object-type name="QTextureLoader"/>
         <object-type name="QTextureRectangle"/>
         <object-type name="QTextureWrapMode">
diff --git a/sources/pyside6/PySide6/QtAsyncio/__init__.py b/sources/pyside6/PySide6/QtAsyncio/__init__.py
new file mode 100644
index 000000000..60d1846d1
--- /dev/null
+++ b/sources/pyside6/PySide6/QtAsyncio/__init__.py
@@ -0,0 +1,60 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+from .events import (
+    QAsyncioEventLoopPolicy, QAsyncioEventLoop, QAsyncioHandle, QAsyncioTimerHandle
+)
+from .futures import QAsyncioFuture
+from .tasks import QAsyncioTask
+
+import asyncio
+import typing
+
+__all__ = [
+    "QAsyncioEventLoopPolicy", "QAsyncioEventLoop",
+    "QAsyncioHandle", "QAsyncioTimerHandle",
+    "QAsyncioFuture", "QAsyncioTask"
+]
+
+
+def run(coro: typing.Optional[typing.Coroutine] = None,
+        keep_running: bool = True,
+        quit_qapp: bool = True, *,
+        handle_sigint: bool = False,
+        debug: typing.Optional[bool] = None) -> typing.Any:
+    """Run the QtAsyncio event loop."""
+
+    # Event loop policies are expected to be deprecated with Python 3.13, with
+    # subsequent removal in Python 3.15. At that point, part of the current
+    # logic of the QAsyncioEventLoopPolicy constructor will have to be moved
+    # here and/or to a loop factory class (to be provided as an argument to
+    # asyncio.run()). In particular, this concerns the logic of setting up the
+    # QCoreApplication and the SIGINT handler.
+    #
+    # More details:
+    # https://discuss.python.org/t/removing-the-asyncio-policy-system-asyncio-set-event-loop-policy-in-python-3-15/37553  # noqa: E501
+    default_policy = asyncio.get_event_loop_policy()
+    asyncio.set_event_loop_policy(
+        QAsyncioEventLoopPolicy(quit_qapp=quit_qapp, handle_sigint=handle_sigint))
+
+    ret = None
+    exc = None
+
+    if keep_running:
+        if coro:
+            asyncio.ensure_future(coro)
+        asyncio.get_event_loop().run_forever()
+    else:
+        if coro:
+            ret = asyncio.run(coro, debug=debug)
+        else:
+            exc = RuntimeError(
+                "QtAsyncio was set to keep running after the coroutine "
+                "finished, but no coroutine was provided.")
+
+    asyncio.set_event_loop_policy(default_policy)
+
+    if ret:
+        return ret
+    if exc:
+        raise exc
diff --git a/sources/pyside6/PySide6/QtAsyncio/events.py b/sources/pyside6/PySide6/QtAsyncio/events.py
new file mode 100644
index 000000000..86b89014a
--- /dev/null
+++ b/sources/pyside6/PySide6/QtAsyncio/events.py
@@ -0,0 +1,725 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+from PySide6.QtCore import (QCoreApplication, QDateTime, QDeadlineTimer,
+                            QEventLoop, QObject, QTimer, QThread, Slot)
+
+from . import futures
+from . import tasks
+
+import asyncio
+import collections.abc
+import concurrent.futures
+import contextvars
+import enum
+import os
+import signal
+import socket
+import subprocess
+import typing
+import warnings
+
+__all__ = [
+    "QAsyncioEventLoopPolicy", "QAsyncioEventLoop",
+    "QAsyncioHandle", "QAsyncioTimerHandle",
+]
+
+
+class QAsyncioExecutorWrapper(QObject):
+    """
+    Executors in asyncio allow running synchronous code in a separate thread or
+    process without blocking the event loop or interrupting the asynchronous
+    program flow. Callables are scheduled for execution by calling submit() or
+    map() on an executor object.
+
+    Executors require a bit of extra work for QtAsyncio, as we can't use
+    naked Python threads; instead, we must make sure that the thread created
+    by executor.submit() has an event loop. This is achieved by not submitting
+    the callable directly, but a small wrapper that attaches a QEventLoop to
+    the executor thread, and then creates a zero-delay singleshot timer to push
+    the actual callable for the executor into this new event loop.
+    """
+
+    def __init__(self, func: typing.Callable, *args: typing.Tuple) -> None:
+        super().__init__()
+        self._loop: QEventLoop
+        self._func = func
+        self._args = args
+        self._result = None
+        self._exception = None
+
+    def _cb(self):
+        try:
+            # Call the synchronous callable that we submitted with submit() or
+            # map().
+            self._result = self._func(*self._args)
+        except BaseException as e:
+            self._exception = e
+        self._loop.exit()
+
+    def do(self):
+        # This creates a new event loop and dispatcher for the thread, if not
+        # already created.
+        self._loop = QEventLoop()
+        asyncio.events._set_running_loop(self._loop)
+
+        QTimer.singleShot(0, self._loop, lambda: self._cb())
+
+        self._loop.exec()
+        if self._exception is not None:
+            raise self._exception
+        return self._result
+
+    def exit(self):
+        self._loop.exit()
+
+
+class QAsyncioEventLoopPolicy(asyncio.AbstractEventLoopPolicy):
+    """
+    Event loop policies are expected to be deprecated with Python 3.13, with
+    subsequent removal in Python 3.15. At that point, part of the current
+    logic of the QAsyncioEventLoopPolicy constructor will have to be moved
+    to QtAsyncio.run() and/or to a loop factory class (to be provided as an
+    argument to asyncio.run()). In particular, this concerns the logic of
+    setting up the QCoreApplication and the SIGINT handler.
+
+    More details:
+    https://discuss.python.org/t/removing-the-asyncio-policy-system-asyncio-set-event-loop-policy-in-python-3-15/37553
+    """
+    def __init__(self,
+                 application: typing.Optional[QCoreApplication] = None,
+                 quit_qapp: bool = True,
+                 handle_sigint: bool = False) -> None:
+        super().__init__()
+        if application is None:
+            if QCoreApplication.instance() is None:
+                application = QCoreApplication()
+            else:
+                application = QCoreApplication.instance()
+        self._application: QCoreApplication = application  # type: ignore[assignment]
+
+        # Configure whether the QCoreApplication at the core of QtAsyncio
+        # should be shut down when asyncio finishes. A special case where one
+        # would want to disable this is test suites that want to reuse a single
+        # QCoreApplication instance across all unit tests, which would fail if
+        # this instance is shut down every time.
+        self._quit_qapp = quit_qapp
+
+        self._event_loop: typing.Optional[asyncio.AbstractEventLoop] = None
+
+        if handle_sigint:
+            signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+    def get_event_loop(self) -> asyncio.AbstractEventLoop:
+        if self._event_loop is None:
+            self._event_loop = QAsyncioEventLoop(self._application, quit_qapp=self._quit_qapp)
+        return self._event_loop
+
+    def set_event_loop(self, loop: typing.Optional[asyncio.AbstractEventLoop]) -> None:
+        self._event_loop = loop
+
+    def new_event_loop(self) -> asyncio.AbstractEventLoop:
+        return QAsyncioEventLoop(self._application, quit_qapp=self._quit_qapp)
+
+    def get_child_watcher(self) -> "asyncio.AbstractChildWatcher":
+        raise DeprecationWarning("Child watchers are deprecated since Python 3.12")
+
+    def set_child_watcher(self, watcher: "asyncio.AbstractChildWatcher") -> None:
+        raise DeprecationWarning("Child watchers are deprecated since Python 3.12")
+
+
+class QAsyncioEventLoop(asyncio.BaseEventLoop, QObject):
+    """
+    Implements the asyncio API:
+    https://docs.python.org/3/library/asyncio-eventloop.html
+    """
+
+    class ShutDownThread(QThread):
+        """
+        Used to shut down the default executor when calling
+        shutdown_default_executor(). As the executor is a ThreadPoolExecutor,
+        it must be shut down in a separate thread as all the threads from the
+        thread pool must join, which we want to do without blocking the event
+        loop.
+        """
+
+        def __init__(self, future: futures.QAsyncioFuture, loop: "QAsyncioEventLoop") -> None:
+            super().__init__()
+            self._future = future
+            self._loop = loop
+            self.started.connect(self.shutdown)
+
+        def run(self) -> None:
+            pass
+
+        def shutdown(self) -> None:
+            try:
+                self._loop._default_executor.shutdown(wait=True)
+                if not self._loop.is_closed():
+                    self._loop.call_soon_threadsafe(self._future.set_result, None)
+            except Exception as e:
+                if not self._loop.is_closed():
+                    self._loop.call_soon_threadsafe(self._future.set_exception, e)
+
+    def __init__(self,
+                 application: QCoreApplication, quit_qapp: bool = True) -> None:
+        asyncio.BaseEventLoop.__init__(self)
+        QObject.__init__(self)
+
+        self._application: QCoreApplication = application
+
+        # Configure whether the QCoreApplication at the core of QtAsyncio
+        # should be shut down when asyncio finishes. A special case where one
+        # would want to disable this is test suites that want to reuse a single
+        # QCoreApplication instance across all unit tests, which would fail if
+        # this instance is shut down every time.
+        self._quit_qapp = quit_qapp
+
+        self._thread = QThread.currentThread()
+
+        self._closed = False
+
+        # These two flags are used to determine whether the loop was stopped
+        # from inside the loop (i.e., coroutine or callback called stop()) or
+        # from outside the loop (i.e., the QApplication is being shut down, for
+        # example, by the user closing the window or by calling
+        # QApplication.quit()). The different cases can trigger slightly
+        # different behaviors (see the comments where the flags are used).
+        # There are two variables for this as in a third case the loop is still
+        # running and both flags are False.
+        self._quit_from_inside = False
+        self._quit_from_outside = False
+
+        # A set of all asynchronous generators that are currently running.
+        self._asyncgens: typing.Set[collections.abc.AsyncGenerator] = set()
+
+        # Starting with Python 3.11, this must be an instance of
+        # ThreadPoolExecutor.
+        self._default_executor = concurrent.futures.ThreadPoolExecutor()
+
+        # The exception handler, if set with set_exception_handler(). The
+        # exception handler is currently called in two places: One, if an
+        # asynchonrous generator raises an exception when closed, and two, if
+        # an exception is raised during the execution of a task. Currently, the
+        # default exception handler just prints the exception to the console.
+        self._exception_handler: typing.Optional[typing.Callable] = self.default_exception_handler
+
+        # The task factory, if set with set_task_factory(). Otherwise, a new
+        # task is created with the QAsyncioTask constructor.
+        self._task_factory: typing.Optional[typing.Callable] = None
+
+        # The future that is currently being awaited with run_until_complete().
+        self._future_to_complete: typing.Optional[futures.QAsyncioFuture] = None
+
+        self._debug = bool(os.getenv("PYTHONASYNCIODEBUG", False))
+
+        self._application.aboutToQuit.connect(self._about_to_quit_cb)
+
+    # Running and stopping the loop
+
+    def _run_until_complete_cb(self, future: futures.QAsyncioFuture) -> None:
+        """
+        A callback that stops the loop when the future is done, used when
+        running the loop with run_until_complete().
+        """
+        if not future.cancelled():
+            if isinstance(future.exception(), (SystemExit, KeyboardInterrupt)):
+                return
+        future.get_loop().stop()
+
+    def run_until_complete(self,
+                           future: futures.QAsyncioFuture) -> typing.Any:  # type: ignore[override]
+        if self.is_closed():
+            raise RuntimeError("Event loop is closed")
+        if self.is_running():
+            raise RuntimeError("Event loop is already running")
+
+        arg_was_coro = not asyncio.futures.isfuture(future)
+        future = asyncio.tasks.ensure_future(future, loop=self)  # type: ignore[assignment]
+        future.add_done_callback(self._run_until_complete_cb)
+        self._future_to_complete = future
+
+        try:
+            self.run_forever()
+        except Exception as e:
+            if arg_was_coro and future.done() and not future.cancelled():
+                future.exception()
+            raise e
+        finally:
+            future.remove_done_callback(self._run_until_complete_cb)
+        if not future.done():
+            raise RuntimeError("Event loop stopped before Future completed")
+
+        return future.result()
+
+    def run_forever(self) -> None:
+        if self.is_closed():
+            raise RuntimeError("Event loop is closed")
+        if self.is_running():
+            raise RuntimeError("Event loop is already running")
+        asyncio.events._set_running_loop(self)
+        self._application.exec()
+        asyncio.events._set_running_loop(None)
+
+    def _about_to_quit_cb(self):
+        """ A callback for the aboutToQuit signal of the QCoreApplication. """
+        if not self._quit_from_inside:
+            # If the aboutToQuit signal is emitted, the user is closing the
+            # application window or calling QApplication.quit(). In this case,
+            # we want to close the event loop, and we consider this a quit from
+            # outside the loop.
+            self._quit_from_outside = True
+            self.close()
+
+    def stop(self) -> None:
+        if self._future_to_complete is not None:
+            if self._future_to_complete.done():
+                self._future_to_complete = None
+            else:
+                # Do not stop the loop if there is a future still being awaited
+                # with run_until_complete().
+                return
+
+        self._quit_from_inside = True
+
+        # The user might want to keep the QApplication running after the event
+        # event loop finishes, which they can control with the quit_qapp
+        # argument.
+        if self._quit_qapp:
+            self._application.quit()
+
+    def is_running(self) -> bool:
+        return self._thread.loopLevel() > 0
+
+    def is_closed(self) -> bool:
+        return self._closed
+
+    def close(self) -> None:
+        if self.is_running() and not self._quit_from_outside:
+            raise RuntimeError("Cannot close a running event loop")
+        if self.is_closed():
+            return
+        if self._default_executor is not None:
+            self._default_executor.shutdown(wait=False)
+        self._closed = True
+
+    async def shutdown_asyncgens(self) -> None:
+        if not len(self._asyncgens):
+            return
+
+        results = await asyncio.tasks.gather(
+            *[asyncgen.aclose() for asyncgen in self._asyncgens],
+            return_exceptions=True)
+
+        for result, asyncgen in zip(results, self._asyncgens):
+            if isinstance(result, Exception):
+                self.call_exception_handler({
+                    "message": f"Closing asynchronous generator {asyncgen}"
+                               f"raised an exception",
+                    "exception": result,
+                    "asyncgen": asyncgen})
+
+        self._asyncgens.clear()
+
+    async def shutdown_default_executor(self,  # type: ignore[override]
+                                        timeout: typing.Union[int, float, None] = None) -> None:
+        shutdown_successful = False
+        if timeout is not None:
+            deadline_timer = QDeadlineTimer(int(timeout * 1000))
+        else:
+            deadline_timer = QDeadlineTimer(QDeadlineTimer.Forever)
+
+        if self._default_executor is None:
+            return
+        future = self.create_future()
+        thread = QAsyncioEventLoop.ShutDownThread(future, self)
+        thread.start()
+        try:
+            await future
+        finally:
+            shutdown_successful = thread.wait(deadline_timer)
+
+        if timeout is not None and not shutdown_successful:
+            warnings.warn(
+                f"Could not shutdown the default executor within {timeout} seconds",
+                RuntimeWarning, stacklevel=2)
+            self._default_executor.shutdown(wait=False)
+
+    # Scheduling callbacks
+
+    def _call_soon_impl(self, callback: typing.Callable, *args: typing.Any,
+                        context: typing.Optional[contextvars.Context] = None,
+                        is_threadsafe: typing.Optional[bool] = False) -> asyncio.Handle:
+        return self._call_later_impl(0, callback, *args, context=context,
+                                     is_threadsafe=is_threadsafe)
+
+    def call_soon(self, callback: typing.Callable, *args: typing.Any,
+                  context: typing.Optional[contextvars.Context] = None) -> asyncio.Handle:
+        return self._call_soon_impl(callback, *args, context=context, is_threadsafe=False)
+
+    def call_soon_threadsafe(self, callback: typing.Callable, *args: typing.Any,
+                             context:
+                             typing.Optional[contextvars.Context] = None) -> asyncio.Handle:
+        if self.is_closed():
+            raise RuntimeError("Event loop is closed")
+        if context is None:
+            context = contextvars.copy_context()
+        return self._call_soon_impl(callback, *args, context=context, is_threadsafe=True)
+
+    def _call_later_impl(self, delay: typing.Union[int, float],
+                         callback: typing.Callable, *args: typing.Any,
+                         context: typing.Optional[contextvars.Context] = None,
+                         is_threadsafe: typing.Optional[bool] = False) -> asyncio.TimerHandle:
+        if not isinstance(delay, (int, float)):
+            raise TypeError("delay must be an int or float")
+        return self._call_at_impl(self.time() + delay, callback, *args, context=context,
+                                  is_threadsafe=is_threadsafe)
+
+    def call_later(self, delay: typing.Union[int, float],
+                   callback: typing.Callable, *args: typing.Any,
+                   context: typing.Optional[contextvars.Context] = None) -> asyncio.TimerHandle:
+        return self._call_later_impl(delay, callback, *args, context=context, is_threadsafe=False)
+
+    def _call_at_impl(self, when: typing.Union[int, float],
+                      callback: typing.Callable, *args: typing.Any,
+                      context: typing.Optional[contextvars.Context] = None,
+                      is_threadsafe: typing.Optional[bool] = False) -> asyncio.TimerHandle:
+        """ All call_at() and call_later() methods map to this method. """
+        if not isinstance(when, (int, float)):
+            raise TypeError("when must be an int or float")
+        return QAsyncioTimerHandle(when, callback, args, self, context, is_threadsafe=is_threadsafe)
+
+    def call_at(self, when: typing.Union[int, float],
+                callback: typing.Callable, *args: typing.Any,
+                context: typing.Optional[contextvars.Context] = None) -> asyncio.TimerHandle:
+        return self._call_at_impl(when, callback, *args, context=context, is_threadsafe=False)
+
+    def time(self) -> float:
+        return QDateTime.currentMSecsSinceEpoch() / 1000
+
+    # Creating Futures and Tasks
+
+    def create_future(self) -> futures.QAsyncioFuture:  # type: ignore[override]
+        return futures.QAsyncioFuture(loop=self)
+
+    def create_task(self,  # type: ignore[override]
+                    coro: typing.Union[collections.abc.Generator, collections.abc.Coroutine],
+                    *, name: typing.Optional[str] = None,
+                    context: typing.Optional[contextvars.Context] = None) -> tasks.QAsyncioTask:
+        if self._task_factory is None:
+            task = tasks.QAsyncioTask(coro, loop=self, name=name, context=context)
+        else:
+            task = self._task_factory(self, coro, context=context)
+            task.set_name(name)
+
+        return task
+
+    def set_task_factory(self, factory: typing.Optional[typing.Callable]) -> None:
+        if factory is not None and not callable(factory):
+            raise TypeError("The task factory must be a callable or None")
+        self._task_factory = factory
+
+    def get_task_factory(self) -> typing.Optional[typing.Callable]:
+        return self._task_factory
+
+    # Opening network connections
+
+    async def create_connection(
+            self, protocol_factory, host=None, port=None,
+            *, ssl=None, family=0, proto=0,
+            flags=0, sock=None, local_addr=None,
+            server_hostname=None,
+            ssl_handshake_timeout=None,
+            ssl_shutdown_timeout=None,
+            happy_eyeballs_delay=None, interleave=None):
+        raise NotImplementedError
+
+    async def create_datagram_endpoint(self, protocol_factory,
+                                       local_addr=None, remote_addr=None, *,
+                                       family=0, proto=0, flags=0,
+                                       reuse_address=None, reuse_port=None,
+                                       allow_broadcast=None, sock=None):
+        raise NotImplementedError
+
+    async def create_unix_connection(
+            self, protocol_factory, path=None, *,
+            ssl=None, sock=None,
+            server_hostname=None,
+            ssl_handshake_timeout=None,
+            ssl_shutdown_timeout=None):
+        raise NotImplementedError
+
+    # Creating network servers
+
+    async def create_server(
+            self, protocol_factory, host=None, port=None,
+            *, family=socket.AF_UNSPEC,
+            flags=socket.AI_PASSIVE, sock=None, backlog=100,
+            ssl=None, reuse_address=None, reuse_port=None,
+            ssl_handshake_timeout=None,
+            ssl_shutdown_timeout=None,
+            start_serving=True):
+        raise NotImplementedError
+
+    async def create_unix_server(
+            self, protocol_factory, path=None, *,
+            sock=None, backlog=100, ssl=None,
+            ssl_handshake_timeout=None,
+            ssl_shutdown_timeout=None,
+            start_serving=True):
+        raise NotImplementedError
+
+    async def connect_accepted_socket(
+            self, protocol_factory, sock,
+            *, ssl=None,
+            ssl_handshake_timeout=None,
+            ssl_shutdown_timeout=None):
+        raise NotImplementedError
+
+    # Transferring files
+
+    async def sendfile(self, transport, file, offset=0, count=None,
+                       *, fallback=True):
+        raise NotImplementedError
+
+    # TLS Upgrade
+
+    async def start_tls(self, transport, protocol, sslcontext, *,
+                        server_side=False,
+                        server_hostname=None,
+                        ssl_handshake_timeout=None,
+                        ssl_shutdown_timeout=None):
+        raise NotImplementedError
+
+    # Watching file descriptors
+
+    def add_reader(self, fd, callback, *args):
+        raise NotImplementedError
+
+    def remove_reader(self, fd):
+        raise NotImplementedError
+
+    def add_writer(self, fd, callback, *args):
+        raise NotImplementedError
+
+    def remove_writer(self, fd):
+        raise NotImplementedError
+
+    # Working with socket objects directly
+
+    async def sock_recv(self, sock, nbytes):
+        raise NotImplementedError
+
+    async def sock_recv_into(self, sock, buf):
+        raise NotImplementedError
+
+    async def sock_recvfrom(self, sock, bufsize):
+        raise NotImplementedError
+
+    async def sock_recvfrom_into(self, sock, buf, nbytes=0):
+        raise NotImplementedError
+
+    async def sock_sendall(self, sock, data):
+        raise NotImplementedError
+
+    async def sock_sendto(self, sock, data, address):
+        raise NotImplementedError
+
+    async def sock_connect(self, sock, address):
+        raise NotImplementedError
+
+    async def sock_accept(self, sock):
+        raise NotImplementedError
+
+    async def sock_sendfile(self, sock, file, offset=0, count=None, *,
+                            fallback=None):
+        raise NotImplementedError
+
+    # DNS
+
+    async def getaddrinfo(self, host, port, *,
+                          family=0, type=0, proto=0, flags=0):
+        raise NotImplementedError
+
+    async def getnameinfo(self, sockaddr, flags=0):
+        raise NotImplementedError
+
+    # Working with pipes
+
+    async def connect_read_pipe(self, protocol_factory, pipe):
+        raise NotImplementedError
+
+    async def connect_write_pipe(self, protocol_factory, pipe):
+        raise NotImplementedError
+
+    # Unix signals
+
+    def add_signal_handler(self, sig, callback, *args):
+        raise NotImplementedError
+
+    def remove_signal_handler(self, sig):
+        raise NotImplementedError
+
+    # Executing code in thread or process pools
+
+    def run_in_executor(self,
+                        executor: typing.Optional[concurrent.futures.ThreadPoolExecutor],
+                        func: typing.Callable, *args: typing.Tuple) -> asyncio.futures.Future:
+        if self.is_closed():
+            raise RuntimeError("Event loop is closed")
+        if executor is None:
+            executor = self._default_executor
+
+        # Executors require a bit of extra work for QtAsyncio, as we can't use
+        # naked Python threads; instead, we must make sure that the thread
+        # created by executor.submit() has an event loop. This is achieved by
+        # not submitting the callable directly, but a small wrapper that
+        # attaches a QEventLoop to the executor thread, and then pushes the
+        # actual callable for the executor into this new event loop.
+        wrapper = QAsyncioExecutorWrapper(func, *args)
+        return asyncio.futures.wrap_future(
+            executor.submit(wrapper.do), loop=self
+        )
+
+    def set_default_executor(self,
+                             executor: typing.Optional[
+                                 concurrent.futures.ThreadPoolExecutor]) -> None:
+        if not isinstance(executor, concurrent.futures.ThreadPoolExecutor):
+            raise TypeError("The executor must be a ThreadPoolExecutor")
+        self._default_executor = executor
+
+    # Error Handling API
+
+    def set_exception_handler(self, handler: typing.Optional[typing.Callable]) -> None:
+        if handler is not None and not callable(handler):
+            raise TypeError("The handler must be a callable or None")
+        self._exception_handler = handler
+
+    def get_exception_handler(self) -> typing.Optional[typing.Callable]:
+        return self._exception_handler
+
+    def default_exception_handler(self, context: typing.Dict[str, typing.Any]) -> None:
+        # TODO
+        if context["message"]:
+            print(context["message"])
+
+    def call_exception_handler(self, context: typing.Dict[str, typing.Any]) -> None:
+        if self._exception_handler is not None:
+            self._exception_handler(context)
+
+    # Enabling debug mode
+
+    def get_debug(self) -> bool:
+        # TODO: Part of the asyncio API but currently unused. More details:
+        # https://docs.python.org/3/library/asyncio-dev.html#asyncio-debug-mode
+        return self._debug
+
+    def set_debug(self, enabled: bool) -> None:
+        self._debug = enabled
+
+    # Running subprocesses
+
+    async def subprocess_exec(self, protocol_factory, *args,
+                              stdin=subprocess.PIPE,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              **kwargs):
+        raise NotImplementedError
+
+    async def subprocess_shell(self, protocol_factory, cmd, *,
+                               stdin=subprocess.PIPE,
+                               stdout=subprocess.PIPE,
+                               stderr=subprocess.PIPE,
+                               **kwargs):
+        raise NotImplementedError
+
+
+class QAsyncioHandle():
+    """
+    The handle enqueues a callback to be executed by the event loop, and allows
+    for this callback to be cancelled before it is executed. This callback will
+    typically execute the step function for a task. This makes the handle one
+    of the main components of asyncio.
+    """
+    class HandleState(enum.Enum):
+        PENDING = enum.auto()
+        CANCELLED = enum.auto()
+        DONE = enum.auto()
+
+    def __init__(self, callback: typing.Callable, args: typing.Tuple,
+                 loop: QAsyncioEventLoop, context: typing.Optional[contextvars.Context],
+                 is_threadsafe: typing.Optional[bool] = False) -> None:
+        self._callback = callback
+        self._args = args
+        self._loop = loop
+        self._context = context
+        self._is_threadsafe = is_threadsafe
+
+        self._timeout = 0
+
+        self._state = QAsyncioHandle.HandleState.PENDING
+        self._start()
+
+    def _start(self) -> None:
+        self._schedule_event(self._timeout, lambda: self._cb())
+
+    def _schedule_event(self, timeout: int, func: typing.Callable) -> None:
+        # Do not schedule events from asyncio when the app is quit from outside
+        # the event loop, as this would cause events to be enqueued after the
+        # event loop was destroyed.
+        if not self._loop.is_closed() and not self._loop._quit_from_outside:
+            if self._is_threadsafe:
+                # This singleShot overload will push func into self._loop
+                # instead of the current thread's loop. This allows scheduling
+                # a callback from a different thread, which is necessary for
+                # thread-safety.
+                # https://docs.python.org/3/library/asyncio-dev.html#asyncio-multithreading
+                QTimer.singleShot(timeout, self._loop, func)
+            else:
+                QTimer.singleShot(timeout, func)
+
+    @Slot()
+    def _cb(self) -> None:
+        """
+        A slot, enqueued into the event loop, that wraps around the actual
+        callback, typically the step function of a task.
+        """
+        if self._state == QAsyncioHandle.HandleState.PENDING:
+            if self._context is not None:
+                self._context.run(self._callback, *self._args)
+            else:
+                self._callback(*self._args)
+            self._state = QAsyncioHandle.HandleState.DONE
+
+    def cancel(self) -> None:
+        if self._state == QAsyncioHandle.HandleState.PENDING:
+            # The old timer that was created in _start will still trigger but
+            # _cb won't do anything, therefore the callback is effectively
+            # cancelled.
+            self._state = QAsyncioHandle.HandleState.CANCELLED
+
+    def cancelled(self) -> bool:
+        return self._state == QAsyncioHandle.HandleState.CANCELLED
+
+
+class QAsyncioTimerHandle(QAsyncioHandle, asyncio.TimerHandle):
+    def __init__(self, when: float, callback: typing.Callable, args: typing.Tuple,
+                 loop: QAsyncioEventLoop, context: typing.Optional[contextvars.Context],
+                 is_threadsafe: typing.Optional[bool] = False) -> None:
+        QAsyncioHandle.__init__(self, callback, args, loop, context, is_threadsafe)
+
+        self._when = when
+        time = self._loop.time()
+        self._timeout = round(max(self._when - time, 0) * 1000)
+
+        QAsyncioHandle._start(self)
+
+    def _start(self) -> None:
+        """
+        Overridden so that timer.start() is only called once at the end of the
+        constructor for both QtHandle and QtTimerHandle.
+        """
+        pass
+
+    def when(self) -> float:
+        return self._when
diff --git a/sources/pyside6/PySide6/QtAsyncio/futures.py b/sources/pyside6/PySide6/QtAsyncio/futures.py
new file mode 100644
index 000000000..cbb005fc9
--- /dev/null
+++ b/sources/pyside6/PySide6/QtAsyncio/futures.py
@@ -0,0 +1,117 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+from . import events
+
+import asyncio
+import contextvars
+import enum
+import typing
+
+
+class QAsyncioFuture():
+    """ https://docs.python.org/3/library/asyncio-future.html """
+
+    # Declare that this class implements the Future protocol. The field must
+    # exist and be boolean - True indicates 'await' or 'yield from', False
+    # indicates 'yield'.
+    _asyncio_future_blocking = False
+
+    class FutureState(enum.Enum):
+        PENDING = enum.auto()
+        CANCELLED = enum.auto()
+        DONE_WITH_RESULT = enum.auto()
+        DONE_WITH_EXCEPTION = enum.auto()
+
+    def __init__(self, *, loop: typing.Optional["events.QAsyncioEventLoop"] = None,
+                 context: typing.Optional[contextvars.Context] = None) -> None:
+        self._loop: "events.QAsyncioEventLoop"
+        if loop is None:
+            self._loop = asyncio.events.get_event_loop()  # type: ignore[assignment]
+        else:
+            self._loop = loop
+        self._context = context
+
+        self._state = QAsyncioFuture.FutureState.PENDING
+        self._result: typing.Any = None
+        self._exception: typing.Optional[BaseException] = None
+
+        self._cancel_message: typing.Optional[str] = None
+
+        # List of callbacks that are called when the future is done.
+        self._callbacks: typing.List[typing.Callable] = list()
+
+    def __await__(self):
+        if not self.done():
+            self._asyncio_future_blocking = True
+            yield self
+            if not self.done():
+                raise RuntimeError("await was not used with a Future or Future-like object")
+        return self.result()
+
+    __iter__ = __await__
+
+    def _schedule_callbacks(self, context: typing.Optional[contextvars.Context] = None):
+        """ A future can optionally have callbacks that are called when the future is done. """
+        for cb in self._callbacks:
+            self._loop.call_soon(
+                cb, self, context=context if context else self._context)
+
+    def result(self) -> typing.Union[typing.Any, Exception]:
+        if self._state == QAsyncioFuture.FutureState.DONE_WITH_RESULT:
+            return self._result
+        if self._state == QAsyncioFuture.FutureState.DONE_WITH_EXCEPTION and self._exception:
+            raise self._exception
+        if self._state == QAsyncioFuture.FutureState.CANCELLED:
+            if self._cancel_message:
+                raise asyncio.CancelledError(self._cancel_message)
+            else:
+                raise asyncio.CancelledError
+        raise asyncio.InvalidStateError
+
+    def set_result(self, result: typing.Any) -> None:
+        self._result = result
+        self._state = QAsyncioFuture.FutureState.DONE_WITH_RESULT
+        self._schedule_callbacks()
+
+    def set_exception(self, exception: Exception) -> None:
+        self._exception = exception
+        self._state = QAsyncioFuture.FutureState.DONE_WITH_EXCEPTION
+        self._schedule_callbacks()
+
+    def done(self) -> bool:
+        return self._state != QAsyncioFuture.FutureState.PENDING
+
+    def cancelled(self) -> bool:
+        return self._state == QAsyncioFuture.FutureState.CANCELLED
+
+    def add_done_callback(self, cb: typing.Callable, *,
+                          context: typing.Optional[contextvars.Context] = None) -> None:
+        if self.done():
+            self._loop.call_soon(
+                cb, self, context=context if context else self._context)
+        else:
+            self._callbacks.append(cb)
+
+    def remove_done_callback(self, cb: typing.Callable) -> int:
+        original_len = len(self._callbacks)
+        self._callbacks = [_cb for _cb in self._callbacks if _cb != cb]
+        return original_len - len(self._callbacks)
+
+    def cancel(self, msg: typing.Optional[str] = None) -> bool:
+        if self.done():
+            return False
+        self._state = QAsyncioFuture.FutureState.CANCELLED
+        self._cancel_message = msg
+        self._schedule_callbacks()
+        return True
+
+    def exception(self) -> typing.Optional[BaseException]:
+        if self._state == QAsyncioFuture.FutureState.CANCELLED:
+            raise asyncio.CancelledError
+        if self.done():
+            return self._exception
+        raise asyncio.InvalidStateError
+
+    def get_loop(self) -> asyncio.AbstractEventLoop:
+        return self._loop
diff --git a/sources/pyside6/PySide6/QtAsyncio/tasks.py b/sources/pyside6/PySide6/QtAsyncio/tasks.py
new file mode 100644
index 000000000..7edc15093
--- /dev/null
+++ b/sources/pyside6/PySide6/QtAsyncio/tasks.py
@@ -0,0 +1,190 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+from . import events
+from . import futures
+
+import asyncio
+import collections.abc
+import concurrent.futures
+import contextvars
+import typing
+
+
+class QAsyncioTask(futures.QAsyncioFuture):
+    """ https://docs.python.org/3/library/asyncio-task.html """
+
+    def __init__(self, coro: typing.Union[collections.abc.Generator, collections.abc.Coroutine], *,
+                 loop: typing.Optional["events.QAsyncioEventLoop"] = None,
+                 name: typing.Optional[str] = None,
+                 context: typing.Optional[contextvars.Context] = None) -> None:
+        super().__init__(loop=loop, context=context)
+
+        self._coro = coro  # The coroutine for which this task was created.
+        self._name = name if name else "QtTask"
+
+        # The task creates a handle for its coroutine. The handle enqueues the
+        # task's step function as its callback in the event loop.
+        self._handle = self._loop.call_soon(self._step, context=self._context)
+
+        # The task step function executes the coroutine until it finishes,
+        # raises an exception or returns a future. If a future was returned,
+        # the task will await its completion (or exception).
+        self._future_to_await: typing.Optional[asyncio.Future] = None
+
+        self._cancelled = False
+        self._cancel_message: typing.Optional[str] = None
+
+        # https://docs.python.org/3/library/asyncio-extending.html#task-lifetime-support
+        asyncio._register_task(self)  # type: ignore[arg-type]
+
+    def __repr__(self) -> str:
+        if self._state == futures.QAsyncioFuture.FutureState.PENDING:
+            state = "Pending"
+        elif self._state == futures.QAsyncioFuture.FutureState.DONE_WITH_RESULT:
+            state = "Done"
+        elif self._state == futures.QAsyncioFuture.FutureState.DONE_WITH_EXCEPTION:
+            state = f"Done with exception ({repr(self._exception)})"
+        elif self._state == futures.QAsyncioFuture.FutureState.CANCELLED:
+            state = "Cancelled"
+
+        return f"Task '{self.get_name()}' with state: {state}"
+
+    class QtTaskApiMisuseError(Exception):
+        pass
+
+    def set_result(self, result: typing.Any) -> None:  # type: ignore[override]
+        # This function is not inherited from the Future APIs.
+        raise QAsyncioTask.QtTaskApiMisuseError("Tasks cannot set results")
+
+    def set_exception(self, exception: typing.Any) -> None:  # type: ignore[override]
+        # This function is not inherited from the Future APIs.
+        raise QAsyncioTask.QtTaskApiMisuseError("Tasks cannot set exceptions")
+
+    def _step(self,
+              exception_or_future: typing.Union[
+                  BaseException, futures.QAsyncioFuture, None] = None) -> None:
+        """
+        The step function is the heart of a task. It is scheduled in the event
+        loop repeatedly, executing the coroutine "step" by "step" (i.e.,
+        iterating through the asynchronous generator) until it finishes with an
+        exception or successfully. Each step can optionally receive an
+        exception or a future as a result from a previous step to handle.
+        """
+
+        if self.done():
+            return
+        result = None
+        self._future_to_await = None
+
+        if asyncio.futures.isfuture(exception_or_future):
+            try:
+                exception_or_future.result()
+            except BaseException as e:
+                exception_or_future = e
+
+        try:
+            asyncio._enter_task(self._loop, self)  # type: ignore[arg-type]
+
+            # It is at this point that the coroutine is resumed for the current
+            # step (i.e. asynchronous generator iteration). It will now be
+            # executed until it yields (and potentially returns a future),
+            # raises an exception, is cancelled, or finishes successfully.
+
+            if isinstance(exception_or_future, BaseException):
+                # If the coroutine doesn't handle this exception, it propagates
+                # to the caller.
+                result = self._coro.throw(exception_or_future)
+            else:
+                result = self._coro.send(None)
+        except StopIteration as e:
+            self._state = futures.QAsyncioFuture.FutureState.DONE_WITH_RESULT
+            self._result = e.value
+        except (concurrent.futures.CancelledError, asyncio.exceptions.CancelledError) as e:
+            self._state = futures.QAsyncioFuture.FutureState.CANCELLED
+            self._exception = e
+        except BaseException as e:
+            self._state = futures.QAsyncioFuture.FutureState.DONE_WITH_EXCEPTION
+            self._exception = e
+        else:
+            if asyncio.futures.isfuture(result):
+                # If the coroutine yields a future, the task will await its
+                # completion, and at that point the step function will be
+                # called again.
+                result.add_done_callback(
+                    self._step, context=self._context)  # type: ignore[arg-type]
+                self._future_to_await = result
+                if self._cancelled:
+                    # If the task was cancelled, then a new future should be
+                    # cancelled as well. Otherwise, in some scenarios like
+                    # a loop inside the task and with bad timing, if the new
+                    # future is not cancelled, the task would continue running
+                    # in this loop despite having been cancelled. This bad
+                    # timing can occur especially if the first future finishes
+                    # very quickly.
+                    self._future_to_await.cancel(self._cancel_message)
+            elif result is None:
+                # If no future was yielded, we schedule the step function again
+                # without any arguments.
+                self._loop.call_soon(self._step, context=self._context)
+            else:
+                # This is not supposed to happen.
+                exception = RuntimeError(f"Bad task result: {result}")
+                self._loop.call_soon(self._step, exception, context=self._context)
+        finally:
+            asyncio._leave_task(self._loop, self)  # type: ignore[arg-type]
+
+            if self._exception:
+                self._loop.call_exception_handler({
+                    "message": (str(self._exception) if self._exception
+                                else "An exception occurred during task "
+                                "execution"),
+                    "exception": self._exception,
+                    "task": self,
+                    "future": (exception_or_future
+                               if asyncio.futures.isfuture(exception_or_future)
+                               else None)
+                })
+
+            if self.done():
+                self._schedule_callbacks()
+
+                # https://docs.python.org/3/library/asyncio-extending.html#task-lifetime-support
+                asyncio._unregister_task(self)  # type: ignore[arg-type]
+
+    def get_stack(self, *, limit=None) -> typing.List[typing.Any]:
+        # TODO
+        raise NotImplementedError("QtTask.get_stack is not implemented")
+
+    def print_stack(self, *, limit=None, file=None) -> None:
+        # TODO
+        raise NotImplementedError("QtTask.print_stack is not implemented")
+
+    def get_coro(self) -> typing.Union[collections.abc.Generator, collections.abc.Coroutine]:
+        return self._coro
+
+    def get_name(self) -> str:
+        return self._name
+
+    def set_name(self, value) -> None:
+        self._name = str(value)
+
+    def cancel(self, msg: typing.Optional[str] = None) -> bool:
+        if self.done():
+            return False
+        self._cancel_message = msg
+        self._handle.cancel()
+        if self._future_to_await is not None:
+            # A task that is awaiting a future must also cancel this future in
+            # order for the cancellation to be successful.
+            self._future_to_await.cancel(msg)
+        self._cancelled = True
+        return True
+
+    def uncancel(self) -> None:
+        # TODO
+        raise NotImplementedError("QtTask.uncancel is not implemented")
+
+    def cancelling(self) -> bool:
+        # TODO
+        raise NotImplementedError("QtTask.cancelling is not implemented")
diff --git a/sources/pyside6/PySide6/QtAxContainer/CMakeLists.txt b/sources/pyside6/PySide6/QtAxContainer/CMakeLists.txt
index 7b804385c..3857d8ddb 100644
--- a/sources/pyside6/PySide6/QtAxContainer/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtAxContainer/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtAxContainer)
 
 set(QtAxContainer_SRC
diff --git a/sources/pyside6/PySide6/QtAxContainer/typesystem_axcontainer.xml b/sources/pyside6/PySide6/QtAxContainer/typesystem_axcontainer.xml
index 4c570f87a..4d1cbe91c 100644
--- a/sources/pyside6/PySide6/QtAxContainer/typesystem_axcontainer.xml
+++ b/sources/pyside6/PySide6/QtAxContainer/typesystem_axcontainer.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.QtAxContainer">
+<typesystem package="PySide6.QtAxContainer"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
     <rejection class="*" function-name="connectNotify"/>
     <rejection class="*" function-name="queryInterface"/>
diff --git a/sources/pyside6/PySide6/QtBluetooth/CMakeLists.txt b/sources/pyside6/PySide6/QtBluetooth/CMakeLists.txt
index 495ec16a5..e063a4546 100644
--- a/sources/pyside6/PySide6/QtBluetooth/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtBluetooth/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtBluetooth)
 
 set(QtBluetooth_OPTIONAL_SRC )
diff --git a/sources/pyside6/PySide6/QtBluetooth/typesystem_bluetooth.xml b/sources/pyside6/PySide6/QtBluetooth/typesystem_bluetooth.xml
index ada93b7f7..a3687b6b0 100644
--- a/sources/pyside6/PySide6/QtBluetooth/typesystem_bluetooth.xml
+++ b/sources/pyside6/PySide6/QtBluetooth/typesystem_bluetooth.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtBluetooth">
+<typesystem package="PySide6.QtBluetooth"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <namespace-type name="QBluetooth">
         <enum-type name="AttAccessConstraint" flags="AttAccessConstraints"/>
@@ -58,6 +59,28 @@
         <enum-type name="DescriptorType"/>
         <enum-type name="ProtocolUuid"/>
         <enum-type name="ServiceClassUuid"/>
+        <modify-function signature="toUInt16(bool*)const">
+            <modify-argument index="1">
+              <remove-argument/>
+            </modify-argument>
+            <modify-argument index="return" pyi-type="Tuple[int, bool]">
+              <replace-type modified-type="PyTuple"/>
+            </modify-argument>
+            <inject-code class="target" position="beginning">
+              <insert-template name="fix_bool*"/>
+            </inject-code>
+        </modify-function>
+        <modify-function signature="toUInt32(bool*)const">
+            <modify-argument index="1">
+              <remove-argument/>
+            </modify-argument>
+            <modify-argument index="return" pyi-type="Tuple[int, bool]">
+              <replace-type modified-type="PyTuple"/>
+            </modify-argument>
+            <inject-code class="target" position="beginning">
+              <insert-template name="fix_bool*"/>
+            </inject-code>
+        </modify-function>
     </value-type>
     <value-type name="QLowEnergyAdvertisingData">
         <enum-type name="Discoverability"/>
@@ -90,4 +113,8 @@
     <value-type name="QLowEnergyServiceData">
         <enum-type name="ServiceType"/>
     </value-type>
+
+    <!-- QtNetwork is pulled in via QtBluetoothDepends. -->
+    <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtCharts/CMakeLists.txt b/sources/pyside6/PySide6/QtCharts/CMakeLists.txt
index 94c39f656..20126fdee 100644
--- a/sources/pyside6/PySide6/QtCharts/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtCharts/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtCharts)
 
 set(QtCharts_SRC
@@ -22,6 +25,7 @@ ${QtCharts_GEN_DIR}/qcandlestickset_wrapper.cpp
 ${QtCharts_GEN_DIR}/qcategoryaxis_wrapper.cpp
 ${QtCharts_GEN_DIR}/qchart_wrapper.cpp
 ${QtCharts_GEN_DIR}/qchartview_wrapper.cpp
+${QtCharts_GEN_DIR}/qcoloraxis_wrapper.cpp
 ${QtCharts_GEN_DIR}/qdatetimeaxis_wrapper.cpp
 ${QtCharts_GEN_DIR}/qhbarmodelmapper_wrapper.cpp
 ${QtCharts_GEN_DIR}/qhboxplotmodelmapper_wrapper.cpp
@@ -69,10 +73,7 @@ set(QtCharts_include_dirs ${QtCharts_SOURCE_DIR}
                           ${QtWidgets_GEN_DIR})
 
 set(QtCharts_libraries    pyside6
-                          ${Qt${QT_MAJOR_VERSION}Charts_LIBRARIES}
-                          ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                          ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                          ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES})
+                          ${Qt${QT_MAJOR_VERSION}Charts_LIBRARIES})
 
 set(QtCharts_deps QtCore QtGui QtWidgets)
 
diff --git a/sources/pyside6/PySide6/QtCharts/typesystem_charts.xml b/sources/pyside6/PySide6/QtCharts/typesystem_charts.xml
index f271b7767..d4337df8e 100644
--- a/sources/pyside6/PySide6/QtCharts/typesystem_charts.xml
+++ b/sources/pyside6/PySide6/QtCharts/typesystem_charts.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtCharts">
+<typesystem package="PySide6.QtCharts"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
   <!-- PYSIDE-1101 Removing inherited method to avoid argument conflict
   on the QChart::scroll overload -->
@@ -160,6 +161,7 @@
           </modify-argument>
       </modify-function>
   </object-type>
+  <object-type name="QColorAxis"/>
   <object-type name="QDateTimeAxis"/>
   <object-type name="QHBarModelMapper"/>
   <object-type name="QHBoxPlotModelMapper"/>
diff --git a/sources/pyside6/PySide6/QtConcurrent/CMakeLists.txt b/sources/pyside6/PySide6/QtConcurrent/CMakeLists.txt
index b38849a75..134e44ed9 100644
--- a/sources/pyside6/PySide6/QtConcurrent/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtConcurrent/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtConcurrent)
 
 set(QtConcurrent_SRC
@@ -15,12 +18,11 @@ set(QtConcurrent_include_dirs   ${QtConcurrent_SOURCE_DIR}
                                 ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                                 ${Qt${QT_MAJOR_VERSION}Concurrent_INCLUDE_DIRS}
                                 ${libpyside_SOURCE_DIR}
-                                ${QtCore_GEN_DIR}
-                                )
-set(QtConcurrent_libraries  pyside6
-                            ${QtConcurrent_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            )
+                                ${QtCore_GEN_DIR})
+
+set(QtConcurrent_libraries pyside6
+                           ${Qt${QT_MAJOR_VERSION}Concurrent_LIBRARIES})
+
 set(QtConcurrent_deps QtCore)
 
 create_pyside_module(NAME QtConcurrent
diff --git a/sources/pyside6/PySide6/QtConcurrent/typesystem_concurrent.xml b/sources/pyside6/PySide6/QtConcurrent/typesystem_concurrent.xml
index c1e6cafad..1892793b9 100644
--- a/sources/pyside6/PySide6/QtConcurrent/typesystem_concurrent.xml
+++ b/sources/pyside6/PySide6/QtConcurrent/typesystem_concurrent.xml
@@ -3,13 +3,14 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtConcurrent">
+<typesystem package="PySide6.QtConcurrent"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 
   <!-- Qt5: this is currently the minimum possible QtConcurrent support, by just extracting
         the name space from QtCore -->
   <namespace-type name="QtConcurrent" target-type="class">
-    <rejection class="QtConcurrent" enum-name="enum_1"/>
+    <enum-type name="FutureResult"/>
     <enum-type name="ReduceOption" flags="ReduceOptions"/>
     <enum-type name="ThreadFunctionResult"/>
     <extra-includes>
@@ -20,7 +21,6 @@
 
   <typedef-type name="QFutureVoid" source="QFuture&lt;void&gt;" disable-wrapper="yes">
       <include file-name="QtCore/qfuture.h" location="global"/>
-      <modify-function signature="isResultReadyAt(int) const" remove="all"/>
   </typedef-type>
   <typedef-type name="QFutureQString" source="QFuture&lt;QString&gt;" disable-wrapper="yes">
       <include file-name="QtCore/qfuture.h" location="global"/>
diff --git a/sources/pyside6/PySide6/QtCore/CMakeLists.txt b/sources/pyside6/PySide6/QtCore/CMakeLists.txt
index 5cb3a0ad5..f3e4be0f9 100644
--- a/sources/pyside6/PySide6/QtCore/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtCore/CMakeLists.txt
@@ -1,9 +1,18 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtCore)
 
+set(CMAKE_AUTOMOC ON)
+
+set(QtCore_DROPPED_ENTRIES )
+
 set(QtCore_static_sources
     "${QtCore_SOURCE_DIR}/glue/qeasingcurve_glue.cpp"
     "${QtCore_SOURCE_DIR}/glue/core_snippets.cpp"
     "${QtCore_SOURCE_DIR}/glue/qtcorehelper.cpp"
+    "${QtCore_SOURCE_DIR}/glue/qiopipe.cpp"
+    "${pyside6_SOURCE_DIR}/qiopipe.h"
 )
 
 if(ENABLE_WIN)
@@ -11,7 +20,8 @@ if(ENABLE_WIN)
       ${QtCore_GEN_DIR}/qwineventnotifier_wrapper.cpp
     )
 else()
-    set(SPECIFIC_OS_FILES "")
+    set(SPECIFIC_OS_FILES
+      ${QtCore_GEN_DIR}/qprocess_unixprocessparameters_wrapper.cpp)
 endif()
 
 set(QtCore_SRC
@@ -31,8 +41,8 @@ ${QtCore_GEN_DIR}/qbuffer_wrapper.cpp
 ${QtCore_GEN_DIR}/qbytearray_frombase64result_wrapper.cpp
 ${QtCore_GEN_DIR}/qbytearray_wrapper.cpp
 ${QtCore_GEN_DIR}/qbytearraymatcher_wrapper.cpp
-${QtCore_GEN_DIR}/qcalendar_wrapper.cpp
 ${QtCore_GEN_DIR}/qcalendar_systemid_wrapper.cpp
+${QtCore_GEN_DIR}/qcalendar_wrapper.cpp
 ${QtCore_GEN_DIR}/qcalendar_yearmonthday_wrapper.cpp
 ${QtCore_GEN_DIR}/qcborarray_wrapper.cpp
 ${QtCore_GEN_DIR}/qcborerror_wrapper.cpp
@@ -71,6 +81,7 @@ ${QtCore_GEN_DIR}/qfilesystemwatcher_wrapper.cpp
 ${QtCore_GEN_DIR}/qfutureinterfacebase_wrapper.cpp
 ${QtCore_GEN_DIR}/qgenericargument_wrapper.cpp
 ${QtCore_GEN_DIR}/qgenericreturnargument_wrapper.cpp
+${QtCore_GEN_DIR}/qhashseed_wrapper.cpp
 ${QtCore_GEN_DIR}/qidentityproxymodel_wrapper.cpp
 ${QtCore_GEN_DIR}/qiodevice_wrapper.cpp
 ${QtCore_GEN_DIR}/qiodevicebase_wrapper.cpp
@@ -88,6 +99,7 @@ ${QtCore_GEN_DIR}/qline_wrapper.cpp
 ${QtCore_GEN_DIR}/qlinef_wrapper.cpp
 ${QtCore_GEN_DIR}/qlocale_wrapper.cpp
 ${QtCore_GEN_DIR}/qlockfile_wrapper.cpp
+${QtCore_GEN_DIR}/qloggingcategory_wrapper.cpp
 ${QtCore_GEN_DIR}/qmargins_wrapper.cpp
 ${QtCore_GEN_DIR}/qmarginsf_wrapper.cpp
 ${QtCore_GEN_DIR}/qmessageauthenticationcode_wrapper.cpp
@@ -105,8 +117,10 @@ ${QtCore_GEN_DIR}/qmimetype_wrapper.cpp
 ${QtCore_GEN_DIR}/qmodelindex_wrapper.cpp
 ${QtCore_GEN_DIR}/qmodelroledata_wrapper.cpp
 ${QtCore_GEN_DIR}/qmutex_wrapper.cpp
+${QtCore_GEN_DIR}/qnativeipckey_wrapper.cpp
 ${QtCore_GEN_DIR}/qobject_wrapper.cpp
 ${QtCore_GEN_DIR}/qoperatingsystemversion_wrapper.cpp
+${QtCore_GEN_DIR}/qoperatingsystemversionbase_wrapper.cpp
 ${QtCore_GEN_DIR}/qparallelanimationgroup_wrapper.cpp
 ${QtCore_GEN_DIR}/qpauseanimation_wrapper.cpp
 ${QtCore_GEN_DIR}/qpersistentmodelindex_wrapper.cpp
@@ -133,7 +147,6 @@ ${QtCore_GEN_DIR}/qsemaphore_wrapper.cpp
 ${QtCore_GEN_DIR}/qsemaphorereleaser_wrapper.cpp
 ${QtCore_GEN_DIR}/qsequentialanimationgroup_wrapper.cpp
 ${QtCore_GEN_DIR}/qsettings_wrapper.cpp
-${QtCore_GEN_DIR}/qsharedmemory_wrapper.cpp
 ${QtCore_GEN_DIR}/qsignalblocker_wrapper.cpp
 ${QtCore_GEN_DIR}/qsignalmapper_wrapper.cpp
 ${QtCore_GEN_DIR}/qsize_wrapper.cpp
@@ -143,17 +156,18 @@ ${QtCore_GEN_DIR}/qsocketnotifier_wrapper.cpp
 ${QtCore_GEN_DIR}/qsortfilterproxymodel_wrapper.cpp
 ${QtCore_GEN_DIR}/qstandardpaths_wrapper.cpp
 ${QtCore_GEN_DIR}/qstorageinfo_wrapper.cpp
-${QtCore_GEN_DIR}/qstringconverterbase_wrapper.cpp
-${QtCore_GEN_DIR}/qstringconverterbase_state_wrapper.cpp
 ${QtCore_GEN_DIR}/qstringconverter_wrapper.cpp
-${QtCore_GEN_DIR}/qstringencoder_wrapper.cpp
+${QtCore_GEN_DIR}/qstringconverterbase_state_wrapper.cpp
+${QtCore_GEN_DIR}/qstringconverterbase_wrapper.cpp
 ${QtCore_GEN_DIR}/qstringdecoder_wrapper.cpp
+${QtCore_GEN_DIR}/qstringencoder_wrapper.cpp
 ${QtCore_GEN_DIR}/qstringlistmodel_wrapper.cpp
 ${QtCore_GEN_DIR}/qsysinfo_wrapper.cpp
 ${QtCore_GEN_DIR}/qsystemsemaphore_wrapper.cpp
 ${QtCore_GEN_DIR}/qt_wrapper.cpp
 ${QtCore_GEN_DIR}/qtcorehelper_qgenericargumentholder_wrapper.cpp
 ${QtCore_GEN_DIR}/qtcorehelper_qgenericreturnargumentholder_wrapper.cpp
+${QtCore_GEN_DIR}/qtcorehelper_qiopipe_wrapper.cpp
 ${QtCore_GEN_DIR}/qtcorehelper_qmutexlocker_wrapper.cpp
 ${QtCore_GEN_DIR}/qtemporarydir_wrapper.cpp
 ${QtCore_GEN_DIR}/qtemporaryfile_wrapper.cpp
@@ -185,16 +199,36 @@ ${QtCore_GEN_DIR}/qxmlstreamnamespacedeclaration_wrapper.cpp
 ${QtCore_GEN_DIR}/qxmlstreamnotationdeclaration_wrapper.cpp
 ${QtCore_GEN_DIR}/qxmlstreamreader_wrapper.cpp
 ${QtCore_GEN_DIR}/qxmlstreamwriter_wrapper.cpp
-${QtCore_GEN_DIR}/qloggingcategory_wrapper.cpp
 
 ${SPECIFIC_OS_FILES}
 # module is always needed
 ${QtCore_GEN_DIR}/qtcore_module_wrapper.cpp
 )
 
-if (Qt${QT_MAJOR_VERSION}Core_VERSION VERSION_EQUAL 6.3.0 OR Qt${QT_MAJOR_VERSION}Core_VERSION VERSION_GREATER 6.3.0)
+get_property(QtCore_disabled_features TARGET Qt${QT_MAJOR_VERSION}::Core
+             PROPERTY QT_DISABLED_PUBLIC_FEATURES)
+
+if("permissions" IN_LIST QtCore_disabled_features)
+    list(APPEND QtCore_DROPPED_ENTRIES QPermission
+         QBluetoothPermission QCalendarPermission QCameraPermission
+         QContactsPermission QLocationPermission QMicrophonePermission)
+    message(STATUS "Qt${QT_MAJOR_VERSION}Core: Dropping Permissions classes")
+else()
     list(APPEND QtCore_SRC
-         ${QtCore_GEN_DIR}/qoperatingsystemversionbase_wrapper.cpp)
+         ${QtCore_GEN_DIR}/qbluetoothpermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qcalendarpermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qcamerapermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qcontactspermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qlocationpermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qmicrophonepermission_wrapper.cpp
+         ${QtCore_GEN_DIR}/qpermission_wrapper.cpp)
+endif()
+
+if("sharedmemory" IN_LIST QtCore_disabled_features)
+    list(APPEND QtCore_DROPPED_ENTRIES QSharedMemory)
+    message(STATUS "Qt${QT_MAJOR_VERSION}Core: Dropping QSharedMemory")
+else()
+    list(APPEND QtCore_SRC ${QtCore_GEN_DIR}/qsharedmemory_wrapper.cpp)
 endif()
 
 configure_file("${QtCore_SOURCE_DIR}/QtCore_global.post.h.in"
@@ -213,6 +247,7 @@ set(QtCore_include_dirs ${QtCore_SOURCE_DIR}
                         )
 set(QtCore_libraries  pyside6
                       ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
+                      Qt::CorePrivate
                       )
 
 create_pyside_module(NAME QtCore
@@ -223,6 +258,34 @@ create_pyside_module(NAME QtCore
                      STATIC_SOURCES QtCore_static_sources
                      TYPESYSTEM_NAME ${QtCore_BINARY_DIR}/typesystem_core.xml
                      GLUE_SOURCES QtCore_glue_sources
+                     DROPPED_ENTRIES QtCore_DROPPED_ENTRIES
                      )
 
-install(FILES ${pyside6_SOURCE_DIR}/qtcorehelper.h DESTINATION include/PySide6/QtCore/)
+# Note: The permission API for Apple platforms only works if the Python application is packaged
+# with pyside6-deploy (uses Nuitka). Read "Notes for Developers" in Qt for Python documentation
+# for more information
+#
+# For Apple platforms, the Qt permission API implementations are in small static libraries.
+# In Qt C++, the application is linked directly to these static libraries during the build when
+# linking to the QtCore module as a post processing CMake step.
+# Being static plugins makes it difficult to add these plugins during Nuitka packaging step.
+# Thus, we link the static plugins to QtCore.abi3.so. However, to request the permissions
+# it is still required to have the necessary Information Property keys eg: NSCameraUsageDescription
+# in the Info.plist of the application bundle which Nuitka creates.
+if (APPLE)
+    set(permissions Camera Microphone Bluetooth Contacts Calendar)
+    foreach(permission IN LISTS permissions)
+        set(permission_plugin_name "QDarwin${permission}PermissionPlugin")
+        set(permission_plugin "${QT_CMAKE_EXPORT_NAMESPACE}::${permission_plugin_name}")
+        # Setting this property is necessary for Camera and Microphone. Otherwise it won't append
+        # the linker flags like -Wl,-u,_QDarwinMicrophonePermissionRequest which are required to
+        # link to qdarwinpermissionplugin_microphone_request.mm.o and find symbols like
+        # QDarwinMicrosphonePermissionHandler which handles requesting the actual permission
+        set_target_properties(QtCore PROPERTIES "_qt_has_${permission_plugin_name}_usage_description" TRUE)
+        # importing the plugin
+        qt6_import_plugins(QtCore INCLUDE ${permission_plugin})
+    endforeach()
+endif()
+
+install(FILES ${pyside6_SOURCE_DIR}/qtcorehelper.h ${pyside6_SOURCE_DIR}/qiopipe.h
+        DESTINATION include/PySide6/QtCore/)
diff --git a/sources/pyside6/PySide6/QtCore/QtCore_global.post.h.in b/sources/pyside6/PySide6/QtCore/QtCore_global.post.h.in
index 55a49bb88..8383b9ae4 100644
--- a/sources/pyside6/PySide6/QtCore/QtCore_global.post.h.in
+++ b/sources/pyside6/PySide6/QtCore/QtCore_global.post.h.in
@@ -1 +1,2 @@
 #include <qtcorehelper.h>
+#include <qiopipe.h>
diff --git a/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
index 4978387ff..f6acf9d60 100644
--- a/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
+++ b/sources/pyside6/PySide6/QtCore/glue/core_snippets.cpp
@@ -2,11 +2,16 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "core_snippets_p.h"
+#include "qtcorehelper.h"
 #include "pysideqobject.h"
 
 #include "shiboken.h"
+#ifndef Py_LIMITED_API
+#  include <datetime.h>
+#endif
 #include "basewrapper.h"
 #include "autodecref.h"
+#include "pysideutils.h"
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QDebug>
@@ -62,7 +67,8 @@ QVariant QVariant_convertToValueList(PyObject *list)
 
     Shiboken::AutoDecRef element(PySequence_GetItem(list, 0));
 
-    QMetaType metaType = QVariant_resolveMetaType(element.cast<PyTypeObject *>());
+    auto *type = reinterpret_cast<PyTypeObject *>(element.object());
+    QMetaType metaType = QVariant_resolveMetaType(type);
     if (!metaType.isValid())
         return {};
 
@@ -237,3 +243,104 @@ QString qObjectTr(PyTypeObject *type, const char *sourceText, const char *disamb
     }
     return result;
 }
+
+bool PyDate_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyDate_Check(pyIn);
+}
+
+bool PyDateTime_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyDateTime_Check(pyIn);
+}
+
+bool PyTime_ImportAndCheck(PyObject *pyIn)
+{
+    if (!PyDateTimeAPI)
+        PyDateTime_IMPORT;
+    return PyTime_Check(pyIn);
+}
+
+PyObject *invokeMetaMethod(const InvokeMetaMethodFunc &f,
+                           const QtCoreHelper::QGenericArgumentHolder &a0,
+                           const QtCoreHelper::QGenericArgumentHolder &a1,
+                           const QtCoreHelper::QGenericArgumentHolder &a2,
+                           const QtCoreHelper::QGenericArgumentHolder &a3,
+                           const QtCoreHelper::QGenericArgumentHolder &a4,
+                           const QtCoreHelper::QGenericArgumentHolder &a5,
+                           const QtCoreHelper::QGenericArgumentHolder &a6,
+                           const QtCoreHelper::QGenericArgumentHolder &a7,
+                           const QtCoreHelper::QGenericArgumentHolder &a8,
+                           const QtCoreHelper::QGenericArgumentHolder &a9)
+{
+    PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
+    const bool resultB = f(a0.toGenericArgument(), a1.toGenericArgument(), a2.toGenericArgument(),
+                           a3.toGenericArgument(), a4.toGenericArgument(), a5.toGenericArgument(),
+                           a6.toGenericArgument(), a7.toGenericArgument(), a8.toGenericArgument(),
+                           a9.toGenericArgument());
+    PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
+    PyObject *result = resultB ? Py_True : Py_False;
+    Py_INCREF(result);
+    return result;
+}
+
+// Convert a QGenericReturnArgument to Python for QMetaObject::invokeMethod
+static PyObject *convertGenericReturnArgument(const void *retData, QMetaType metaType)
+{
+    PyObject *result = nullptr;
+    switch (metaType.id()) {
+    case QMetaType::Bool:
+        result = *reinterpret_cast<const bool *>(retData) ? Py_True : Py_False;
+        Py_INCREF(result);
+        break;
+    case QMetaType::Int:
+        result = PyLong_FromLong(*reinterpret_cast<const int *>(retData));
+        break;
+    case QMetaType::Double:
+        result = PyFloat_FromDouble(*reinterpret_cast<const double *>(retData));
+        break;
+    case QMetaType::QString:
+        result = PySide::qStringToPyUnicode(*reinterpret_cast<const QString *>(retData));
+        break;
+    default: {
+        Shiboken::Conversions::SpecificConverter converter(metaType.name());
+        const auto type = converter.conversionType();
+        if (type == Shiboken::Conversions::SpecificConverter::InvalidConversion) {
+            PyErr_Format(PyExc_RuntimeError, "%s: Unable to find converter for \"%s\".",
+                         __FUNCTION__, metaType.name());
+            return nullptr;
+        }
+        result = converter.toPython(retData);
+    }
+    }
+    return result;
+}
+
+PyObject *invokeMetaMethodWithReturn(const InvokeMetaMethodFuncWithReturn &f,
+                                     const QtCoreHelper::QGenericReturnArgumentHolder &r,
+                                     const QtCoreHelper::QGenericArgumentHolder &a0,
+                                     const QtCoreHelper::QGenericArgumentHolder &a1,
+                                     const QtCoreHelper::QGenericArgumentHolder &a2,
+                                     const QtCoreHelper::QGenericArgumentHolder &a3,
+                                     const QtCoreHelper::QGenericArgumentHolder &a4,
+                                     const QtCoreHelper::QGenericArgumentHolder &a5,
+                                     const QtCoreHelper::QGenericArgumentHolder &a6,
+                                     const QtCoreHelper::QGenericArgumentHolder &a7,
+                                     const QtCoreHelper::QGenericArgumentHolder &a8,
+                                     const QtCoreHelper::QGenericArgumentHolder &a9)
+{
+    PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
+    const bool callResult = f(r.toGenericReturnArgument(),
+                              a0.toGenericArgument(), a1.toGenericArgument(), a2.toGenericArgument(),
+                              a3.toGenericArgument(), a4.toGenericArgument(), a5.toGenericArgument(),
+                              a6.toGenericArgument(), a7.toGenericArgument(), a8.toGenericArgument(),
+                              a9.toGenericArgument());
+    PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
+    if (!callResult)
+        return PyErr_Format(PyExc_RuntimeError, "QMetaMethod invocation failed.");
+    return convertGenericReturnArgument(r.data(), r.metaType());
+}
diff --git a/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h b/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h
index 9a0a8c0ab..11e84b291 100644
--- a/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h
+++ b/sources/pyside6/PySide6/QtCore/glue/core_snippets_p.h
@@ -12,11 +12,20 @@
 
 #include <functional>
 
+QT_FORWARD_DECLARE_CLASS(QGenericArgument)
+QT_FORWARD_DECLARE_CLASS(QGenericReturnArgument)
 QT_FORWARD_DECLARE_CLASS(QMetaType)
 QT_FORWARD_DECLARE_CLASS(QObject)
 QT_FORWARD_DECLARE_CLASS(QRegularExpression)
 QT_FORWARD_DECLARE_CLASS(QVariant);
 
+QT_BEGIN_NAMESPACE
+namespace QtCoreHelper {
+class QGenericArgumentHolder;
+class QGenericReturnArgumentHolder;
+}
+QT_END_NAMESPACE
+
 // Helpers for QVariant conversion
 
 QMetaType QVariant_resolveMetaType(PyTypeObject *type);
@@ -48,4 +57,49 @@ void qObjectFindChildren(const QObject *parent, const QRegularExpression &patter
 // Helpers for translation
 QString qObjectTr(PyTypeObject *type, const char *sourceText, const char *disambiguation, int n);
 
+bool PyDate_ImportAndCheck(PyObject *pyIn);
+bool PyDateTime_ImportAndCheck(PyObject *pyIn);
+bool PyTime_ImportAndCheck(PyObject *pyIn);
+
+// Helpers for QMetaObject::invokeMethod(), QMetaMethod::invoke(). The std::function
+// serves to abstract from QMetaObject/QMetaMethod invocation parameters.
+using InvokeMetaMethodFunc =
+    std::function<bool(QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument)>;
+
+using InvokeMetaMethodFuncWithReturn =
+    std::function<bool(QGenericReturnArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument,QGenericArgument,QGenericArgument,
+                       QGenericArgument,QGenericArgument)>;
+
+// Call a void meta method from Python passing the argument holder helpers.
+PyObject *invokeMetaMethod(const InvokeMetaMethodFunc &f,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &,
+                           const QtCoreHelper::QGenericArgumentHolder &);
+
+// Call a meta method with a return value from Python passing the argument holder
+// helpers.
+PyObject *invokeMetaMethodWithReturn(const InvokeMetaMethodFuncWithReturn &f,
+                                     const QtCoreHelper::QGenericReturnArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &,
+                                     const QtCoreHelper::QGenericArgumentHolder &);
+
 #endif // CORE_SNIPPETS_P_H
diff --git a/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp b/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp
new file mode 100644
index 000000000..6799c0f32
--- /dev/null
+++ b/sources/pyside6/PySide6/QtCore/glue/qiopipe.cpp
@@ -0,0 +1,142 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qiopipe.h"
+
+#include <QtCore/private/qobject_p.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qpointer.h>
+
+#include <memory>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtCoreHelper
+{
+
+class QPipeEndPoint : public QIODevice
+{
+    Q_OBJECT
+
+public:
+    bool isSequential() const override;
+    qint64 bytesAvailable() const override;
+
+    void setRemoteEndPoint(QPipeEndPoint *other);
+
+protected:
+    qint64 readData(char *data, qint64 maxlen) override;
+    qint64 writeData(const char *data, qint64 len) override;
+
+private:
+    QByteArray m_buffer;
+    QPointer<QPipeEndPoint> m_remoteEndPoint;
+};
+
+class QIOPipePrivate final : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QIOPipe)
+public:
+    QIOPipePrivate();
+    ~QIOPipePrivate() {};
+
+    std::unique_ptr<QPipeEndPoint> end1;
+    std::unique_ptr<QPipeEndPoint> end2;
+};
+
+QIOPipe::QIOPipe(QObject *parent) : QObject(*(new QIOPipePrivate()), parent) { }
+
+bool QIOPipe::open(QIODevice::OpenMode mode)
+{
+    Q_D(QIOPipe);
+
+    if (!d->end1->open(mode))
+        return false;
+    switch (mode & QIODevice::ReadWrite) {
+    case QIODevice::WriteOnly:
+    case QIODevice::ReadOnly:
+        return d->end2->open(mode ^ QIODevice::ReadWrite);
+    default:
+        return d->end2->open(mode);
+    }
+}
+
+QIODevice *QIOPipe::end1() const
+{
+    Q_D(const QIOPipe);
+    return d->end1.get();
+}
+
+QIODevice *QIOPipe::end2() const
+{
+    Q_D(const QIOPipe);
+    return d->end2.get();
+}
+
+QIOPipePrivate::QIOPipePrivate() : end1(std::make_unique<QPipeEndPoint>()),
+                                   end2(std::make_unique<QPipeEndPoint>())
+{
+    end1->setRemoteEndPoint(end2.get());
+    end2->setRemoteEndPoint(end1.get());
+}
+
+bool QPipeEndPoint::isSequential() const
+{
+    return true;
+}
+
+qint64 QPipeEndPoint::bytesAvailable() const
+{
+    return m_buffer.size() + QIODevice::bytesAvailable();
+}
+
+void QPipeEndPoint::setRemoteEndPoint(QPipeEndPoint *other)
+{
+    m_remoteEndPoint = other;
+}
+
+qint64 QPipeEndPoint::readData(char *data, qint64 maxlen)
+{
+    maxlen = qMin(maxlen, static_cast<qint64>(m_buffer.size()));
+    if (maxlen <= 0)
+        return 0;
+
+    Q_ASSERT(maxlen > 0);
+    memcpy(data, m_buffer.data(), static_cast<size_t>(maxlen));
+    m_buffer = m_buffer.mid(maxlen);
+    return maxlen;
+}
+
+qint64 QPipeEndPoint::writeData(const char *data, qint64 len)
+{
+    if (!m_remoteEndPoint)
+        return -1;
+
+    if (len <= 0)
+        return 0;
+
+    QByteArray &buffer = m_remoteEndPoint->m_buffer;
+    const qint64 prevLen = buffer.size();
+    Q_ASSERT(prevLen >= 0);
+    len = qMin(len, std::numeric_limits<int>::max() - prevLen);
+
+    if (len == 0)
+        return 0;
+
+    Q_ASSERT(len > 0);
+    Q_ASSERT(prevLen + len > 0);
+    Q_ASSERT(prevLen + len <= std::numeric_limits<int>::max());
+
+    buffer.resize(prevLen + len);
+    memcpy(buffer.data() + prevLen, data, static_cast<size_t>(len));
+    Q_EMIT bytesWritten(len);
+    Q_EMIT m_remoteEndPoint->readyRead();
+    return len;
+}
+
+} // namespace QtCoreHelper
+
+QT_END_NAMESPACE
+
+#include "qiopipe.moc"
diff --git a/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp b/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp
index 0ce4ce922..948c0ce5c 100644
--- a/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp
+++ b/sources/pyside6/PySide6/QtCore/glue/qtcorehelper.cpp
@@ -5,6 +5,8 @@
 
 #include <QtCore/qdebug.h>
 
+QT_BEGIN_NAMESPACE
+
 namespace QtCoreHelper {
 
 // Data classes for the generic argument data classes. The argument is freed
@@ -50,7 +52,7 @@ QGenericArgumentHolder::QGenericArgumentHolder()
 }
 
 QGenericArgumentHolder::QGenericArgumentHolder(const QMetaType &type, const void *aData) :
-    d(new QGenericArgumentData(type, aData))
+    d(std::make_shared<QGenericArgumentData>(type, aData))
 {
 }
 
@@ -60,23 +62,23 @@ QGenericArgumentHolder &QGenericArgumentHolder::operator=(const QGenericArgument
 QGenericArgumentHolder &QGenericArgumentHolder::operator=(QGenericArgumentHolder &&) = default;
 QGenericArgumentHolder::~QGenericArgumentHolder() = default;
 
-QGenericArgumentHolder::operator QGenericArgument() const
+QGenericArgument QGenericArgumentHolder::toGenericArgument() const
 {
-    return d.isNull() ? QGenericArgument{} : d->m_argument;
+    return d ? d->m_argument : QGenericArgument{};
 }
 
 QMetaType QGenericArgumentHolder::metaType() const
 {
-    return d.isNull() ? QMetaType{} : d->m_type;
+    return d ? d->m_type : QMetaType{};
 }
 
 const void *QGenericArgumentHolder::data() const
 {
-    return d.isNull() ? nullptr : d->m_argument.data();
+    return d ? d->m_argument.data() : nullptr;
 }
 
 QGenericReturnArgumentHolder::QGenericReturnArgumentHolder(const QMetaType &type, void *aData) :
-      d(new QGenericReturnArgumentData(type, aData))
+      d(std::make_shared<QGenericReturnArgumentData>(type, aData))
 {
 }
 
@@ -86,7 +88,7 @@ QGenericReturnArgumentHolder &QGenericReturnArgumentHolder::operator=(const QGen
 QGenericReturnArgumentHolder &QGenericReturnArgumentHolder::operator=(QGenericReturnArgumentHolder &&) = default;
 QGenericReturnArgumentHolder::~QGenericReturnArgumentHolder() = default;
 
-QGenericReturnArgumentHolder::operator QGenericReturnArgument() const
+QGenericReturnArgument QGenericReturnArgumentHolder::toGenericReturnArgument() const
 {
     return d->m_argument;
 }
@@ -102,3 +104,5 @@ const void *QGenericReturnArgumentHolder::data() const
 }
 
 } // namespace QtCoreHelper
+
+QT_END_NAMESPACE
diff --git a/sources/pyside6/PySide6/QtCore/typesystem_core.xml b/sources/pyside6/PySide6/QtCore/typesystem_core.xml
index 7dd664294..885b53874 100644
--- a/sources/pyside6/PySide6/QtCore/typesystem_core.xml
+++ b/sources/pyside6/PySide6/QtCore/typesystem_core.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtCore">
+<typesystem package="PySide6.QtCore"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <?if windows?>
     <load-typesystem name="QtCore/typesystem_core_win.xml" generate="yes"/>
     <?endif?>
diff --git a/sources/pyside6/PySide6/QtCore/typesystem_core_common.xml b/sources/pyside6/PySide6/QtCore/typesystem_core_common.xml
index d9a6c8435..110f86f25 100644
--- a/sources/pyside6/PySide6/QtCore/typesystem_core_common.xml
+++ b/sources/pyside6/PySide6/QtCore/typesystem_core_common.xml
@@ -31,29 +31,56 @@
     <function signature="qIsNull(double)"/>
     <!-- Qt5: gone <function signature="qRound(qreal)"/> -->
     <function signature="qtTrId(const char*,int)" since="4.6"/>
-    <function signature="qVersion()"/>
-    <function signature="qCompress(const uchar*,qsizetype,int)"/>
-    <function signature="qCompress(const QByteArray&amp;,int)"/>
-    <function signature="qUncompress(const uchar*,qsizetype)"/>
-    <function signature="qUncompress(const QByteArray&amp;)"/>
-    <function signature="qFormatLogMessage(QtMsgType,const QMessageLogContext&amp;,const QString&amp;)"/>
-    <function signature="qSetMessagePattern(const QString&amp;)"/>
+    <function signature="qVersion()">
+        <modify-function>
+            <modify-argument index="return" pyi-type="str"/>
+        </modify-function>
+    </function>
+    <!-- Move PyBuffer overload to front to avoid conversion PyBuffer->QByteArray -->
+    <function signature="qCompress(const uchar*,qsizetype,int)" overload-number="0">
+        <modify-function>
+            <modify-argument index="1">
+                <replace-type modified-type="PyBuffer"/>
+            </modify-argument>
+            <inject-code file="../glue/qtcore.cpp" snippet="qcompress-buffer"/>
+        </modify-function>
+    </function>
+    <function signature="qCompress(const QByteArray&amp;,int)" overload-number="1"/>
+    <!-- Move PyBuffer overload to front to avoid conversion PyBuffer->QByteArray -->
+    <function signature="qUncompress(const uchar*,qsizetype)" overload-number="0">
+        <modify-function>
+            <modify-argument index="1">
+                <replace-type modified-type="PyBuffer"/>
+            </modify-argument>
+            <inject-code file="../glue/qtcore.cpp" snippet="quncompress-buffer"/>
+        </modify-function>
+    </function>
+    <function signature="qUncompress(const QByteArray&amp;)"  overload-number="1"/>
+    <function signature="qFormatLogMessage(QtMsgType,const QMessageLogContext&amp;,const QString&amp;)"
+              doc-file="qtlogging"/>
+    <function signature="qSetMessagePattern(const QString&amp;)" doc-file="qtlogging"/>
 
     <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="include-pyside"/>
     <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
                  snippet="qarg_helper"/>
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="darwin_permission_plugin"/>
 
     <add-function signature="qDebug(const char*)">
         <inject-code file="../glue/qtcore.cpp" snippet="use-stream-for-format-security"/>
+        <modify-argument index="1" pyi-type="str"/>
     </add-function>
     <add-function signature="qCritical(const char*)">
         <inject-code file="../glue/qtcore.cpp" snippet="use-stream-for-format-security"/>
+        <modify-argument index="1" pyi-type="str"/>
     </add-function>
     <add-function signature="qFatal(const char*)">
         <inject-code file="../glue/qtcore.cpp" snippet="qfatal"/>
+        <modify-argument index="1" pyi-type="str"/>
     </add-function>
     <add-function signature="qWarning(const char*)">
         <inject-code file="../glue/qtcore.cpp" snippet="use-stream-for-format-security"/>
+        <modify-argument index="1" pyi-type="str"/>
     </add-function>
 
     <add-function signature="Q_ARG(PyObject *@type@, PyObject *@value@)"
@@ -87,29 +114,34 @@
     <rejection class="QtSharedPointer"/>
     <rejection class="QtStringBuilder"/>
 
+    <rejection class="q20"/>
+    <rejection class="q23"/>
+    <rejection class="q_has_char8_t"/>
+    <rejection class="QContainerInfo"/>
+    <rejection class="QHashPrivate"/>
+    <rejection class="q_no_char8_t"/>
+    <rejection class="Qt::Literals"/>
+    <rejection class="QtLiterals"/>
+    <rejection class="QtMetaContainerPrivate"/>
+    <rejection class="QtTsan"/>
+    <rejection class="QTypeTraits"/>
+    <rejection class="qxp"/>
+
   <rejection class="QChildEvent" field-name="c"/>
   <rejection class="QTimerEvent" field-name="id"/>
   <rejection class="QEvent" field-name="t"/>
   <rejection class="*" function-name="tr"/>
-  <rejection class="*" function-name="qt_metacast"/>
   <!-- From Qt4.6 -->
   <rejection class="*" field-name="d_ptr"/>
-  <rejection class="*" field-name="staticQtMetaObject"/>
-  <rejection class="*" function-name="qobject_interface_iid"/>
-  <rejection class="*" function-name="qGetPtrHelper"/>
-  <rejection class="*" function-name="q_check_ptr"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QTextCodecFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qRegisterAnimationInterpolator"/>
-  <rejection class="*" function-name="qvariant_cast&lt;QVariant&gt;"/>
-  <rejection class="*" function-name="qVariantSetValue&lt;QVariant&gt;"/>
-  <rejection class="*" function-name="qReallocAligned"/>
-  <rejection class="*" function-name="qMallocAligned"/>
-  <rejection class="*" function-name="qFreeAligned"/>
   <rejection class="QMetaMethod" enum-name="Attributes"/>
+  <rejection class="QMetaMethod" field-name="data"/>
+  <!-- Note: Default parameter values of Disambiguated_t as defined by
+       QT6_DECL_NEW_OVERLOAD_TAIL are not seen by the clang parser since it
+       is relying on code snippets for the values. -->
+  <rejection class="Qt" field-name="Disambiguated"/>
+  <rejection class="" enum-name="QCborNegativeInteger"/>
 
   <rejection class="*" argument-type="^qfloat16&amp;?$"/>
-  <rejection class="*" argument-type="QLatin1String"/>
   <rejection class="*" argument-type="QTSMFI"/>
   <rejection class="*" argument-type="QTSMFC"/>
   <rejection class="*" argument-type="QtPrivate::QSlotObjectBase*"/>
@@ -122,17 +154,13 @@
   <rejection class="*" argument-type="std::chrono::milliseconds"/>
   <rejection class="*" argument-type="^std::nullptr_t&amp;?$"/>
   <rejection class="*" argument-type="^std::initializer_list&lt;.*$"/>
-  <rejection class="*" argument-type="^std::list&lt;[^&gt;]&gt; const&amp;$"/>
-  <rejection class="*" argument-type="std::string const&amp;"/>
-  <rejection class="*" argument-type="^std::vector&lt;[^&gt;]&gt; const&amp;$"/>
 
   <!-- From Qt4.6 ^^^ -->
 
-
-  <enum-type name="QtMsgType"/>
-  <enum-type name="QCborSimpleType"/>
-  <enum-type name="QCborKnownTags"/>
-  <enum-type name="QCborTag"/>
+  <enum-type name="QtMsgType" doc-file="qtlogging"/>
+  <enum-type name="QCborSimpleType" doc-file="qtcborcommon"/>
+  <enum-type name="QCborKnownTags" doc-file="qtcborcommon"/>
+  <enum-type name="QCborTag" doc-file="qtcborcommon"/>
 
   <primitive-type name="qint8"/>
   <primitive-type name="qint16"/>
@@ -198,7 +226,14 @@
         </target-to-native>
     </conversion-rule>
   </primitive-type>
-
+  <primitive-type name="QFunctionPointer" target-lang-api-name="PyLong">
+    <conversion-rule>
+        <native-to-target file="../glue/qtcore.cpp" snippet="return-qfunctionpointer-pylong"/>
+        <target-to-native>
+            <add-conversion type="PyLong" file="../glue/qtcore.cpp" snippet="conversion-pylong-qfunctionpointer"/>
+        </target-to-native>
+    </conversion-rule>
+  </primitive-type>
   <primitive-type name="QString" target-lang-api-name="PyUnicode">
     <include file-name="QString" location="global"/>
     <conversion-rule>
@@ -217,6 +252,17 @@
     </conversion-rule>
   </primitive-type>
 
+  <primitive-type name="QLatin1String" target-lang-api-name="PyUnicode">
+    <include file-name="QtCore/qlatin1stringview.h" location="global"/>
+    <conversion-rule>
+        <native-to-target file="../glue/qtcore.cpp" snippet="return-pyunicode-from-qlatin1string"/>
+        <target-to-native>
+            <add-conversion type="PyString" check="qLatin1StringCheck(%in)"
+                            file="../glue/qtcore.cpp" snippet="conversion-pystring-qlatin1string"/>
+        </target-to-native>
+    </conversion-rule>
+  </primitive-type>
+
   <primitive-type name="QAnyStringView" target-lang-api-name="PyUnicode" view-on="QString">
     <include file-name="QAnyStringView" location="global"/>
     <conversion-rule>
@@ -236,6 +282,9 @@
   </primitive-type>
 
   <primitive-type name="QVariant" target-lang-api-name="PyObject">
+    <extra-includes>
+        <include file-name="optional" location="global"/>
+    </extra-includes>
     <conversion-rule>
         <native-to-target file="../glue/qtcore.cpp" snippet="return-qvariant"/>
         <target-to-native>
@@ -245,7 +294,6 @@
             <add-conversion type="QByteArray" file="../glue/qtcore.cpp" snippet="conversion-qbytearray"/>
             <add-conversion type="PyFloat" check="PyFloat_CheckExact(%in)" file="../glue/qtcore.cpp" snippet="conversion-pyfloat"/>
             <add-conversion type="PyLong" check="PyLong_CheckExact(%in)"  file="../glue/qtcore.cpp" snippet="conversion-qlonglong"/>
-            <add-conversion type="SbkEnumType" file="../glue/qtcore.cpp" snippet="conversion-sbkobject"/>
             <add-conversion type="SbkObject" file="../glue/qtcore.cpp" snippet="conversion-sbkobject"/>
             <add-conversion type="PyDict" check="PyDict_CheckExact(%in)" file="../glue/qtcore.cpp" snippet="conversion-pydict"/>
             <add-conversion type="PyList" check="PyList_Check(%in)" file="../glue/qtcore.cpp" snippet="conversion-pylist"/>
@@ -352,6 +400,10 @@
       </conversion-rule>
   </value-type>
 
+  <value-type name="QNativeIpcKey" since="6.6">
+      <enum-type name="Type"/>
+  </value-type>
+
   <container-type name="QSet" type="set">
     <include file-name="QSet" location="global"/>
     <conversion-rule>
@@ -368,7 +420,7 @@
 
   <!-- FIXME: Which one is it going to be? -->
   <container-type name="QList" type="list"
-                  opaque-containers="int:QIntList;QPoint:QPointList;QPointF:QPointFList;QVector2D:QVector2DList;QVector3D:QVector3DList;QVector4D:QVector4DList">
+                  opaque-containers="int:QIntList;QPoint:QPointList;QPointF:QPointFList">
     <include file-name="QList" location="global"/>
     <declare-function signature="append(T)" return-type="void"/>
     <declare-function signature="insert(qsizetype,T)" return-type="void"/>
@@ -421,7 +473,6 @@
   <container-type name="QHash" type="hash">
     <include file-name="QHash" location="global"/>
     <!-- Include to make enum flags work. -->
-    <include file-name="pysideqflags.h" location="global"/>
     <conversion-rule>
         <native-to-target>
             <insert-template name="shiboken_conversion_qmap_to_pydict"/>
@@ -437,7 +488,6 @@
   <container-type name="QMultiHash" type="multi-hash">
     <include file-name="QMultiHash" location="global"/>
     <!-- Include to make enum flags work. -->
-    <include file-name="pysideqflags.h" location="global"/>
     <conversion-rule>
         <native-to-target>
             <insert-template name="shiboken_conversion_qmultihash_to_pydict"/>
@@ -450,6 +500,8 @@
     </conversion-rule>
   </container-type>
 
+  <value-type name="QHashSeed" since="6.2"/>
+
   <container-type name="QMap" type="map">
     <include file-name="QMap" location="global"/>
     <conversion-rule>
@@ -499,38 +551,12 @@
   <rejection class="*" field-name="d"/>
   <rejection class="*" field-name="staticMetaObject"/>
   <!-- not support array in property -->
-  <rejection class="QTextCodec::ConverterState" field-name="state_data"/>
   <rejection class="QUuid" field-name="data1"/>
   <rejection class="QUuid" field-name="data2"/>
   <rejection class="QUuid" field-name="data3"/>
   <rejection class="QUuid" field-name="data4"/>
-  <rejection class="" enum-name="QtValidLicenseForTestModule"/>
-  <rejection class="" enum-name="QtValidLicenseForDBusModule"/>
-  <rejection class="" enum-name="QtValidLicenseForSqlModule"/>
-  <rejection class="" enum-name="QtValidLicenseForOpenGLModule"/>
-  <rejection class="" enum-name="QtValidLicenseForScriptToolsModule"/>
-  <rejection class="" enum-name="__codecvt_result"/>
-  <rejection class="" enum-name="enum_1"/>
-  <rejection class="" enum-name="enum_2"/>
-  <rejection class="" enum-name="QtValidLicenseForXmlModule"/>
-  <rejection class="" enum-name="QtValidLicenseForActiveQtModule"/>
-  <rejection class="" enum-name="QtValidLicenseForCoreModule"/>
-  <rejection class="" enum-name="QtValidLicenseForNetworkModule"/>
-  <rejection class="" enum-name="QtValidLicenseForSvgModule"/>
-  <rejection class="" enum-name="QtValidLicenseForGuiModule"/>
-  <rejection class="" enum-name="QtValidLicenseForHelpModule"/>
   <!-- Internal -->
-  <rejection class="QAbstractFileEngine"/> <!--
-  <rejection class="QAbstractFileEngine" function-name="endEntryList"/>
-  <rejection class="QAbstractFileEngine" function-name="extension"/> XXX -->
   <rejection class="QCoreApplication" function-name="compressEvent"/>
-  <rejection class="QCoreApplication" function-name="eventFilter"/>
-  <rejection class="QCoreApplication" function-name="filterEvent"/>
-  <rejection class="QCoreApplication" function-name="setEventFilter"/>
-  <rejection class="QFile" function-name="setDecodingFunction"/>
-  <rejection class="QFile" function-name="setEncodingFunction"/>
-  <rejection class="QRegion" function-name="cleanUp"/>
-  <rejection class="QSettings" function-name="registerFormat"/>
 
   <namespace-type name="Qt">
     <extra-includes>
@@ -538,6 +564,7 @@
     </extra-includes>
     <enum-type name="AlignmentFlag" python-type="IntFlag" flags="Alignment"/>
     <enum-type name="AnchorPoint" since="4.6"/>
+    <enum-type name="ColorScheme" since="6.5"/>
     <enum-type name="ApplicationAttribute"/>
     <enum-type name="ApplicationState" flags="ApplicationStates"/>
     <enum-type name="ArrowType"/>
@@ -594,6 +621,7 @@
     <enum-type name="PenCapStyle"/>
     <enum-type name="PenJoinStyle"/>
     <enum-type name="PenStyle"/>
+    <enum-type name="PermissionStatus" since="6.5"/>
     <enum-type name="ReturnByValueConstant"/>
     <enum-type name="ScreenOrientation" flags="ScreenOrientations"/>
     <enum-type name="ScrollBarPolicy"/>
@@ -625,14 +653,8 @@
     <enum-type name="WindowType" python-type="IntFlag" flags="WindowFlags"/>
     <enum-type name="CursorMoveStyle" since="4.8" revision="4800"/>
 
-    <modify-function signature="^operator.\(Qt::AlignmentFlag,Qt::TextFlag\)$"
-                     remove="all"/>
-    <modify-function signature="^operator.\(Qt::TextFlag,Qt::AlignmentFlag\)$"
-                     remove="all"/>
-    <modify-function signature="^operator.\(Qt::TextElideMode,Qt::TextFlag\)$"
-                     remove="all"/>
-    <modify-function signature="^operator.\(Qt::TextFlag,Qt::TextElideMode\)$"
-                     remove="all"/>
+    <inject-code class="target" position="end" file="../glue/qtcore.cpp"
+                 snippet="qt-modifier"/>
   </namespace-type>
 
   <add-function signature="QEnum(PyObject*)" return-type="PyObject*">
@@ -667,6 +689,8 @@
   <inject-code class="target" position="end" file="../glue/qtcore.cpp" snippet="qt-pysideinit"/>
 
   <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qt-messagehandler"/>
+  <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+               snippet="qlatin1string-check"/>
   <add-function signature="qInstallMessageHandler(PyObject)" return-type="PyObject">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qt-installmessagehandler"/>
   </add-function>
@@ -679,7 +703,8 @@
     <enum-type name="ClockType" since="4.7"/>
   </value-type>
 
-  <object-type name="QAbstractTableModel" polymorphic-id-expression="qobject_cast&lt;QAbstractTableModel*&gt;(%1)">
+  <object-type name="QAbstractTableModel"
+               polymorphic-id-expression="qobject_cast&lt;QAbstractTableModel*&gt;(%B)">
     <extra-includes>
       <include file-name="QStringList" location="global"/>
       <include file-name="QSize" location="global"/>
@@ -749,7 +774,7 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[PySide6.QtCore.QLineF.IntersectionType, PySide6.QtCore.QPointF]">
             <replace-type modified-type="(intersectType, intersectionPoint)"/>
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qlinef-intersect"/>
@@ -789,19 +814,14 @@
       <enum-type name="System"/>
       <enum-type identified-by-value="Unspecified"/>
   </value-type>
-  <value-type name="QDate" hash-function="PySide::hash" >
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
-    <inject-code class="native" position="beginning">
-        <insert-template name="pydatetime_importandcheck_function">
-            <replace from="$DATETIMETYPE" to="PyDate"/>
-        </insert-template>
-    </inject-code>
+  <value-type name="QDate">
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="core-snippets-p-h"/>
     <conversion-rule>
         <target-to-native>
             <add-conversion type="Py_None" file="../glue/qtcore.cpp" snippet="conversion-pynone"/>
-            <add-conversion type="PyDate" check="PyDateTime_ImportAndCheck(%in)" file="../glue/qtcore.cpp" snippet="conversion-qdate-pydate"/>
+            <add-conversion type="PyDate" check="PyDate_ImportAndCheck(%in)"
+                            file="../glue/qtcore.cpp" snippet="conversion-qdate-pydate"/>
         </target-to-native>
     </conversion-rule>
     <extra-includes>
@@ -837,7 +857,7 @@
         <modify-argument index="3">
             <remove-argument/>
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, int, int]">
             <replace-type modified-type="(year, month, day)"/>
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qdate-getdate"/>
@@ -846,26 +866,22 @@
         <modify-argument index="1">
             <remove-argument/>
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, int]">
             <replace-type modified-type="(week, yearNumber)"/>
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qdate-weeknumber"/>
     </modify-function>
   </value-type>
-  <value-type name="QDateTime" hash-function="PySide::hash">
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
+  <value-type name="QDateTime">
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="core-snippets-p-h"/>
     <enum-type name="YearRange"/>
-    <inject-code class="native" position="beginning">
-        <insert-template name="pydatetime_importandcheck_function">
-            <replace from="$DATETIMETYPE" to="PyDateTime"/>
-        </insert-template>
-    </inject-code>
+    <enum-type name="TransitionResolution" since="6.7"/>
     <conversion-rule>
         <target-to-native>
             <add-conversion type="Py_None" file="../glue/qtcore.cpp" snippet="conversion-pynone"/>
-            <add-conversion type="PyDateTime" check="PyDateTime_ImportAndCheck(%in)" file="../glue/qtcore.cpp" snippet="conversion-qdatetime-pydatetime"/>
+            <add-conversion type="PyDateTime" check="PyDateTime_ImportAndCheck(%in)"
+                            file="../glue/qtcore.cpp" snippet="conversion-qdatetime-pydatetime"/>
         </target-to-native>
     </conversion-rule>
     <extra-includes>
@@ -939,10 +955,34 @@
     </add-function>
   </value-type>
 
-  <value-type name="QPoint" hash-function="PySide::hash">
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
+  <value-type name="QPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+  </value-type>
+  <value-type name="QBluetoothPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+      <enum-type name="CommunicationMode" flags="CommunicationModes" since="6.6"/>
+  </value-type>
+  <value-type name="QCalendarPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+      <enum-type name="AccessMode"/>
+  </value-type>
+  <value-type name="QCameraPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+  </value-type>
+  <value-type name="QContactsPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+      <enum-type name="AccessMode"/>
+  </value-type>
+  <value-type name="QLocationPermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+      <enum-type name="Accuracy"/>
+      <enum-type name="Availability"/>
+  </value-type>
+  <value-type name="QMicrophonePermission" since="6.5">
+      <configuration condition="QT_CONFIG(permissions)"/>
+  </value-type>
+
+  <value-type name="QPoint">
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
             <insert-template name="repr_code">
@@ -960,7 +1000,6 @@
             </insert-template>
         </inject-code>
     </add-function>
-    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qpoint"/>
 
     <add-function signature="toTuple" return-type="PyObject*">
         <inject-code class="target" position="beginning">
@@ -1009,10 +1048,7 @@
     <modify-function signature="ry()" remove="all"/>
     <!--### -->
   </value-type>
-  <value-type name="QRect" hash-function="PySide::hash">
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
+  <value-type name="QRect">
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
             <insert-template name="repr_code">
@@ -1029,7 +1065,6 @@
             </insert-template>
         </inject-code>
     </add-function>
-    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qrect"/>
 
     <modify-function signature="getCoords(int*,int*,int*,int*)const">
         <modify-argument index="return">
@@ -1143,10 +1178,7 @@
         </inject-code>
     </modify-function>
   </value-type>
-  <value-type name="QSize" hash-function="PySide::hash">
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
+  <value-type name="QSize">
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
             <insert-template name="repr_code">
@@ -1164,7 +1196,6 @@
             </insert-template>
         </inject-code>
     </add-function>
-    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qsize"/>
 
     <add-function signature="toTuple" return-type="PyObject*">
         <inject-code class="target" position="beginning">
@@ -1214,19 +1245,14 @@
     <!--### -->
   </value-type>
 
-  <value-type name="QTime" hash-function="PySide::hash">
-    <extra-includes>
-      <include file-name="pysideqhash.h" location="global"/>
-    </extra-includes>
-    <inject-code class="native" position="beginning">
-        <insert-template name="pydatetime_importandcheck_function">
-            <replace from="$DATETIMETYPE" to="PyTime"/>
-        </insert-template>
-    </inject-code>
+  <value-type name="QTime">
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="core-snippets-p-h"/>
     <conversion-rule>
         <target-to-native>
             <add-conversion type="Py_None" file="../glue/qtcore.cpp" snippet="conversion-pynone"/>
-            <add-conversion type="PyTime" check="PyDateTime_ImportAndCheck(%in)" file="../glue/qtcore.cpp" snippet="conversion-qtime-pytime"/>
+            <add-conversion type="PyTime" check="PyTime_ImportAndCheck(%in)"
+                            file="../glue/qtcore.cpp" snippet="conversion-qtime-pytime"/>
         </target-to-native>
     </conversion-rule>
 
@@ -1263,6 +1289,7 @@
      qRegisterMetaType&lt;QList&lt;QPersistentModelIndex&gt; &gt;("QList_QPersistentModelIndex");
    </inject-code>
     <modify-function signature="internalPointer()const">
+        <modify-argument index="return" pyi-type="Any"/>
         <inject-code class="target" position="beginning">
             <insert-template name="return_internal_pointer" />
         </inject-code>
@@ -1275,9 +1302,13 @@
   </value-type>
 
   <value-type name="QTimeZone">
+    <configuration condition="QT_CONFIG(timezone)"/>
+    <enum-type name="Initialization" since="6.5"/>
     <enum-type name="TimeType"/>
     <enum-type name="NameType"/>
-    <value-type name="OffsetData"/>
+    <value-type name="OffsetData">
+        <configuration condition="QT_CONFIG(timezone)"/>
+    </value-type>
   </value-type>
 
   <value-type name="QUuid">
@@ -1308,6 +1339,7 @@
   </object-type>
 
   <value-type name="QLocale">
+    <enum-type name="TagSeparator" since="6.7"/>
     <enum-type name="Country"/>
     <enum-type name="DataSizeFormat" flags="DataSizeFormats"/>
     <enum-type name="FloatingPointPrecisionOption" python-type="IntEnum"/>
@@ -1323,26 +1355,60 @@
     <modify-function signature="toString(qulonglong)const" remove="all"/>
     <modify-function signature="toString(ushort)const" remove="all"/>
     <modify-function signature="toString(unsigned int)const" remove="all"/>
+    <modify-function signature="system()" remove="all"/>
     <!--### -->
     <extra-includes>
       <include file-name="QDate" location="global"/>
     </extra-includes>
+    <add-function signature="system()" return-type="QLocale" static="yes">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+         snippet="qlocale_system"/>
+        <inject-documentation mode="append" format="target">
+          Returns a QLocale object initialized to the system locale.
+
+          The system locale may use system-specific sources for locale data, where available,
+          otherwise falling back on QLocale's built-in database entry for the language, script and
+          territory the system reports.
+
+          For example, on Windows, this locale will use the decimal/grouping characters and
+          date/time formats specified in the system configuration panel.
+
+          .. note:: Qt for Python on macOS will not reflect the user's region and language
+             preferences though QLocale::system(), but will instead reflect the environment
+             variables POSIX uses to specify locale, similar to Python's locale module. If the
+             system locale cannot be determined, which can be due to none of the variables 'LC_ALL',
+             'LC_CTYPE', 'LANG' or 'LANGUAGE' being set by your environment, then the default POSIX
+             locale or 'C' locale is returned.
+
+          See also c().
+        </inject-documentation>
+    </add-function>
     <modify-function signature="toTime(QString,QLocale::FormatType)const">
         <modify-argument index="2">
             <rename to="format"/>
         </modify-argument>
     </modify-function>
-    <modify-function signature="toDate(QString,QLocale::FormatType)const">
+    <modify-function signature="toDate(QString,QLocale::FormatType,int)const">
         <modify-argument index="2">
             <rename to="format"/>
         </modify-argument>
     </modify-function>
+    <modify-function signature="^toDate(Time)?\(QString,[^,]+,int\)const$">
+        <modify-argument index="3">
+            <replace-default-expression with="1900"/> <!-- private FirstTwoDigitYear -->
+        </modify-argument>
+    </modify-function>
+    <modify-function signature="^toDate(Time)?\(QString,[^,]+,QCalendar,int\)const$">
+        <modify-argument index="4">
+            <replace-default-expression with="1900"/> <!-- private FirstTwoDigitYear -->
+        </modify-argument>
+    </modify-function>
     <modify-function signature="toUInt(QString,bool*)const">
         <modify-argument index="2">
             <remove-argument />
             <remove-default-expression />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1354,7 +1420,7 @@
             <remove-argument />
             <remove-default-expression />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1366,7 +1432,7 @@
             <remove-argument />
             <remove-default-expression />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[float, bool]">
             <replace-type modified-type="(float, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1378,7 +1444,7 @@
             <remove-argument />
             <remove-default-expression />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[float, bool]">
             <replace-type modified-type="(float, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1389,7 +1455,7 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1400,7 +1466,18 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
+            <replace-type modified-type="(int, bool ok)"/>
+        </modify-argument>
+        <inject-code class="target" position="beginning">
+            <insert-template name="fix_args,bool*"/>
+        </inject-code>
+    </modify-function>
+    <modify-function signature="toLong(QString,bool*)const">
+        <modify-argument index="2">
+            <remove-argument />
+        </modify-argument>
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1411,7 +1488,7 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1422,17 +1499,18 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[int, bool]">
             <replace-type modified-type="(int, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
             <insert-template name="fix_args,bool*"/>
         </inject-code>
     </modify-function>
-    <!-- PYSIDE-2133, remove unsigned overloads of toCurrencyString() to
+    <!-- PYSIDE-2133, 2168 remove unsigned overloads of to(Currency)?String() to
          ensure float overloads are used -->
-    <modify-function signature="^toCurrencyString\(q?u.*$" remove="all"/>
-    <modify-function signature="^toCurrencyString\(.*short.*$" remove="all"/>
+    <modify-function signature="^to(Currency)?String\(q?u.*$" remove="all"/>
+    <modify-function signature="^to(Currency)?String\(.*short.*$" remove="all"/>
+    <modify-function signature="^to.*\(.*QStringView.*$" remove="all"/>
   </value-type>
   <value-type name="QBitArray">
     <add-function signature="__len__">
@@ -1452,6 +1530,16 @@
       <modify-function signature="removeStaleLockFile()" allow-thread="yes"/>
       <modify-function signature="tryLock(int)" allow-thread="yes"/>
       <modify-function signature="unlock()" allow-thread="yes"/>
+      <modify-function signature="getLockInfo(qint64*,QString*,QString*)const">
+          <modify-argument index="return" pyi-type="Tuple[int, str, str]">
+              <replace-type modified-type="(int, str, str)"/>
+          </modify-argument>
+          <modify-argument index="1"><remove-argument/></modify-argument>
+          <modify-argument index="2"><remove-argument/></modify-argument>
+          <modify-argument index="3"><remove-argument/></modify-argument>
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtcore.cpp" snippet="qlockfile-getlockinfo"/>
+      </modify-function>
   </object-type>
   <object-type name="QMessageAuthenticationCode"/>
   <object-type name="QSignalBlocker">
@@ -1472,6 +1560,7 @@
     <modify-function signature="tryLockForWrite(int)" allow-thread="yes"/>
   </object-type>
   <object-type name="QReadLocker">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="QReadLocker(QReadWriteLock*)">
         <modify-argument index="1">
             <reference-count action="set"/>
@@ -1486,6 +1575,7 @@
     </add-function>
   </object-type>
   <object-type name="QWriteLocker">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="QWriteLocker(QReadWriteLock*)">
         <modify-argument index="1">
             <reference-count action="set"/>
@@ -1503,6 +1593,7 @@
     <enum-type name="IteratorFlag" flags="IteratorFlags"/>
   </object-type>
   <object-type name="QThread">
+    <configuration condition="QT_CONFIG(thread)"/>
     <inject-code file="../glue/qtcore.cpp" class="native" position="beginning" snippet="qthread_pthread_cleanup"/>
     <enum-type name="Priority"/>
     <modify-function signature="currentThreadId()" remove="all"/>
@@ -1572,12 +1663,6 @@
       <modify-argument index="return">
         <define-ownership class="native" owner="c++"/>
       </modify-argument>
-      <inject-code class="native" position="end" file="../glue/qtcore.cpp"
-                   snippet="qabstractitemmodel_data"/>
-    </modify-function>
-    <modify-function signature="headerData(int,Qt::Orientation,int)const">
-      <inject-code class="native" position="end" file="../glue/qtcore.cpp"
-                   snippet="qabstractitemmodel_data"/>
     </modify-function>
     <modify-function signature="dataChanged(const QModelIndex&amp;,const QModelIndex&amp;,const QVector&lt;int&gt;&amp;)" allow-thread="yes"/>
     <modify-function signature="layoutAboutToBeChanged(const QList&lt;QPersistentModelIndex&gt;&amp;,QAbstractItemModel::LayoutChangeHint)" allow-thread="yes"/>
@@ -1593,8 +1678,9 @@
     <add-function signature="operator==(const QItemSelection&amp;)" return-type="bool"/>
     <add-function signature="operator!=(const QItemSelection&amp;)" return-type="bool"/>
     <!-- For some reason, the empty selection is not seen. Maybe related to the new [default]
-         tag in Qt6? -->
-    <declare-function signature="QItemSelection()" return-type="QItemSelection" />
+         tag in Qt6?
+         PYSIDE-2756: The return-type attribute is unnecessary -->
+    <declare-function signature="QItemSelection()"/>
     <!-- The __add__ function creates a result list, instead of using the inherited type.
          Fixed by adding with the correct type. -->
     <add-function signature="operator+(QItemSelection)" return-type="QItemSelection">
@@ -1611,7 +1697,8 @@
 
   <value-type name="QItemSelectionRange">
   </value-type>
-  <object-type name="QAbstractProxyModel" polymorphic-id-expression="qobject_cast&lt;QAbstractProxyModel*&gt;(%1)">
+  <object-type name="QAbstractProxyModel"
+               polymorphic-id-expression="qobject_cast&lt;QAbstractProxyModel*&gt;(%B)">
     <extra-includes>
       <include file-name="QItemSelection" location="global"/>
       <include file-name="QStringList" location="global"/>
@@ -1639,15 +1726,18 @@
       <include file-name="QThread" location="global"/>
       <include file-name="QCoreApplication" location="global"/>
       <include file-name="signalmanager.h" location="local"/>
-      <include file-name="glue/core_snippets_p.h" location="local"/>
     </extra-includes>
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="core-snippets-p-h"/>
     <modify-function signature="metaObject()const">
       <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-metaobject"/>
       <modify-argument index="return">
         <reference-count action="set"/>
       </modify-argument>
     </modify-function>
-
+    <!-- FIXME PYSIDE 7: Remove this (QT6_DECL_NEW_OVERLOAD_TAIL) -->
+    <modify-function signature="^moveToThread\(.*\)" remove="all"/>
+    <declare-function signature="moveToThread(QThread*)" return-type="bool"/>
     <modify-function signature="deleteLater()">
       <modify-argument index="this">
         <define-ownership owner="c++"/>
@@ -1671,9 +1761,6 @@
     </modify-function>
     <!-- End of Invalidate-after-use fix -->
     <modify-function signature="parent()const">
-      <modify-argument index="this">
-        <parent index="return" action="add"/>
-      </modify-argument>
       <modify-argument index="return">
         <define-ownership class="target" owner="default"/>
       </modify-argument>
@@ -1682,50 +1769,63 @@
       <modify-argument index="this">
         <parent index="1" action="add"/>
       </modify-argument>
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtCore.QObject]"/>
     </modify-function>
-    <modify-function signature="connect(const QObject*,const char*,const char*,Qt::ConnectionType)const">
-        <modify-argument index="4">
-            <rename to="type"/>
-        </modify-argument>
+    <!-- Manual overload order fixes PYSIDE-2627
+
+         The addition of the qobject-connect-4-context overload resulted in an
+         automatic overload ordering that prevented the right overload from
+         ever being called if the callable was a QObject. Set a manual order to
+         fix this. -->
+    <modify-function signature="connect(const QObject*,const char*,const char*,Qt::ConnectionType)const"
+                     overload-number="0">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-1"/>
     </modify-function>
     <!-- static version -->
-    <modify-function signature="connect(const QObject*,QMetaMethod,const QObject*,QMetaMethod,Qt::ConnectionType)">
-        <modify-argument index="5">
-            <rename to="type"/>
-        </modify-argument>
+    <modify-function signature="connect(const QObject*,QMetaMethod,const QObject*,QMetaMethod,Qt::ConnectionType)"
+                     overload-number="1">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-2"/>
     </modify-function>
-    <modify-function signature="connect(const QObject*,const char*,const QObject*,const char*,Qt::ConnectionType)">
+    <modify-function signature="connect(const QObject*,const char*,const QObject*,const char*,Qt::ConnectionType)"
+                     overload-number="2">
         <modify-argument index="5">
             <rename to="type"/>
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-3"/>
     </modify-function>
     <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect"/>
-    <add-function signature="connect(const QObject*,const char*,PyCallable*,Qt::ConnectionType@type@=Qt::AutoConnection)"
-                  return-type="QMetaObject::Connection" static="yes">
+    <add-function signature="connect(const QObject*@sender@,const char*@signal@,PyCallable*@functor@,Qt::ConnectionType@type@=Qt::AutoConnection)"
+                  return-type="QMetaObject::Connection" static="yes" overload-number="3">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-4"/>
     </add-function>
+    <add-function signature="connect(const QObject*@sender@,const char*@signal@,const QObject*@context@,PyCallable*@functor@,Qt::ConnectionType@type@=Qt::AutoConnection)"
+                  return-type="QMetaObject::Connection" static="yes" overload-number="4">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-4-context"/>
+    </add-function>
     <!-- static version -->
-    <add-function signature="connect(const char*,PyCallable*,Qt::ConnectionType@type@=Qt::AutoConnection)"
-                  return-type="QMetaObject::Connection">
+    <add-function signature="connect(const char*@signal@,PyCallable*@functor@,Qt::ConnectionType@type@=Qt::AutoConnection)"
+                  return-type="QMetaObject::Connection" overload-number="5">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-5"/>
     </add-function>
-    <add-function signature="connect(const char*,const QObject*,const char*,Qt::ConnectionType@type@=Qt::AutoConnection)"
-                  return-type="QMetaObject::Connection">
+    <add-function signature="connect(const char*@signal@,const QObject*@receiver@,const char*@method@,Qt::ConnectionType@type@=Qt::AutoConnection)"
+                  return-type="QMetaObject::Connection" overload-number="6">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-connect-6"/>
     </add-function>
 
     <add-function signature="emit(const char*,...)" return-type="bool">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-emit"/>
     </add-function>
-    <add-function signature="disconnect(const char*,PyCallable*)" return-type="bool">
+    <add-function signature="disconnect(const char*@signal@,PyCallable*@functor@)" return-type="bool">
          <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-disconnect-1"/>
     </add-function>
-    <add-function signature="disconnect(const QObject*,const char*,PyCallable*)" return-type="bool" static="yes">
+    <add-function signature="disconnect(const QObject*@sender@,const char*@signal@,PyCallable*@functor@)" return-type="bool" static="yes">
          <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-disconnect-2"/>
     </add-function>
+    <modify-function signature="disconnect(QMetaObject::Connection)">
+        <modify-argument index="1">
+            <rename to="connection"/>
+        </modify-argument>
+    </modify-function>
 
 
     <add-function signature="findChild(PyTypeObject*@type@,const QString&amp;@name@={},Qt::FindChildOptions@options@=Qt::FindChildrenRecursively)"
@@ -1773,10 +1873,6 @@
         </modify-argument>
     </add-function>
 
-   <modify-function signature="receivers(const char*)const">
-     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-receivers"/>
-   </modify-function>
-
    <modify-function signature="destroyed(QObject*)" allow-thread="yes">
      <modify-argument index="1">
        <rename to="object"/>
@@ -1787,6 +1883,7 @@
       <modify-argument index="return">
          <define-ownership owner="default"/>
       </modify-argument>
+       <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qobject-sender"/>
   </modify-function>
 
    <!-- This is not supported due the lack of information durring the call with no arguments,  this can cause a memory leak -->
@@ -1802,7 +1899,8 @@
        </modify-argument>
    </modify-function>
   </object-type>
-  <object-type name="QAbstractListModel" polymorphic-id-expression="qobject_cast&lt;QAbstractListModel*&gt;(%1)">
+  <object-type name="QAbstractListModel"
+               polymorphic-id-expression="qobject_cast&lt;QAbstractListModel*&gt;(%B)">
     <extra-includes>
       <include file-name="QStringList" location="global"/>
       <include file-name="QSize" location="global"/>
@@ -1810,7 +1908,7 @@
   </object-type>
   <value-type name="QUrlQuery"/>
 
-  <value-type name="QUrl" hash-function="PySide::hash">
+  <value-type name="QUrl">
     <!-- Qt5: lots of changes -->
     <enum-type name="ComponentFormattingOption" python-type="IntFlag" flags="ComponentFormattingOptions,FormattingOptions"/>
     <!-- note: above duplication of attribute is not by default XML compliant! -->
@@ -1820,7 +1918,6 @@
     <enum-type name="AceProcessingOption" flags="AceProcessingOptions" since="6.3"/>
     <extra-includes>
       <include file-name="QStringList" location="global"/>
-      <include file-name="pysideqhash.h" location="global"/>
     </extra-includes>
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
@@ -2263,12 +2360,21 @@
     <modify-function signature="write(const QByteArray&amp;)" allow-thread="yes"/>
     <modify-function signature="waitForReadyRead(int)" allow-thread="yes"/>
     <modify-function signature="waitForBytesWritten(int)" allow-thread="yes"/>
-    <!-- ### peek(qint64) do the job -->
     <modify-function signature="peek(char*,qint64)" remove="all"/>
-    <!-- ### read(qint64) do the job -->
+    <add-function signature="peek(PyBuffer@buffer@,qint64@maxlen@)" return-type="qint64">
+        <modify-argument index="1" pyi-type="bytearray"/>
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qiodevice-bufferedread"/>
+    </add-function>
     <modify-function signature="read(char*,qint64)" remove="all"/>
-    <!-- ### readLine(qint64) do the job -->
+    <add-function signature="read(PyBuffer@buffer@,qint64@maxlen@)" return-type="qint64">
+        <modify-argument index="1" pyi-type="bytearray"/>
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qiodevice-bufferedread"/>
+    </add-function>
     <modify-function signature="readLine(char*,qint64)" remove="all"/>
+    <add-function signature="readLine(PyBuffer@buffer@,qint64@maxlen@)" return-type="qint64">
+        <modify-argument index="1" pyi-type="bytearray"/>
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qiodevice-bufferedread"/>
+    </add-function>
     <!-- ### write(str) do the job -->
     <modify-function signature="write(const char*,qint64)" remove="all"/>
     <modify-function signature="write(const char*)" remove="all"/>
@@ -2317,8 +2423,8 @@
   <value-type name="QOperatingSystemVersionBase" since="6.3">
       <enum-type name="OSType"/>
   </value-type>
+  <value-type name="QOperatingSystemVersionUnexported" since="6.3" generate="false"/>
   <value-type name="QOperatingSystemVersion">
-      <enum-type name="OSType"/>
       <modify-function signature="QOperatingSystemVersion(const QOperatingSystemVersionBase&amp;)" remove="all"/>
   </value-type>
   <object-type name="QLibrary">
@@ -2332,6 +2438,7 @@
   </object-type>
   <namespace-type name="QtCoreHelper" visible="no">
     <object-type name="QMutexLocker" copyable="no">
+      <configuration condition="QT_CONFIG(thread)"/>
       <!-- PYSIDE-1271: Creating locking capable objects inside sections that
       contain allow-thread, require the classes to also allow having threads.
       The lack of the option here, was generating a deadlock when running a
@@ -2359,27 +2466,31 @@
           <reference-count action="set"/>
         </modify-argument>
       </modify-function>
-      <add-function signature="__enter__()" return-type="QMutexLocker">
+      <add-function signature="__enter__()" return-type="QtCoreHelper::QMutexLocker">
           <inject-code file="../glue/qtcore.cpp" snippet="default-enter"/>
       </add-function>
       <add-function signature="__exit__(PyObject*,PyObject*,PyObject*)">
           <inject-code file="../glue/qtcore.cpp" snippet="unlock"/>
       </add-function>
     </object-type>
+    <object-type name="QIOPipe"/>
     <value-type name="QGenericArgumentHolder"/>
     <value-type name="QGenericReturnArgumentHolder"/>
   </namespace-type>
 
   <!-- Qt5 addition -->
   <object-type name="QBasicMutex">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="lock()" allow-thread="yes"/>
     <modify-function signature="tryLock()" allow-thread="yes"/>
   </object-type>
 
   <object-type name="QMutex">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="tryLock(int)" allow-thread="yes"/>
   </object-type>
   <object-type name="QRecursiveMutex">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="lock()" allow-thread="yes"/>
     <modify-function signature="tryLock(int)" allow-thread="yes"/>
   </object-type>
@@ -2393,10 +2504,13 @@
       <modify-function signature="operator()()" remove="all"/>
   </object-type>
   <object-type name="QSemaphore">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="acquire(int)" allow-thread="yes"/>
     <modify-function signature="tryAcquire(int,int)" allow-thread="yes"/>
   </object-type>
-  <object-type name="QSemaphoreReleaser"/>
+  <object-type name="QSemaphoreReleaser">
+    <configuration condition="QT_CONFIG(thread)"/>
+  </object-type>
 
   <value-type name="QSocketDescriptor">
     <inject-code class="native" position="beginning" file="../glue/qtcore.cpp" snippet="qsocketdescriptor"/>
@@ -2437,8 +2551,14 @@
         </modify-argument>
         <inject-code file="../glue/qtcore.cpp" snippet="qtranslator-load"/>
     </modify-function>
+    <modify-function signature="translate(const char*,const char*, const char*,int)const">
+        <modify-argument index="1" pyi-type="str"/>
+        <modify-argument index="2" pyi-type="str"/>
+        <modify-argument index="3" pyi-type="Optional[str]"/>
+    </modify-function>
   </object-type>
   <object-type name="QWaitCondition">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="wait(QMutex*,QDeadlineTimer)" allow-thread="yes"/>
     <modify-function signature="wait(QMutex*,unsigned long)" allow-thread="yes"/>
     <modify-function signature="wait(QReadWriteLock*,QDeadlineTimer)" allow-thread="yes"/>
@@ -2451,19 +2571,28 @@
   </object-type>
   <object-type name="QBuffer">
     <!-- ### setData(QByteArray) do the job -->
-    <modify-function signature="setData(const char*,int)" remove="all"/>
+    <modify-function signature="setData(const char*,qsizetype)" remove="all"/>
     <!-- Disambiguate from Qt3DRender/qbuffer.h -->
     <include file-name="QtCore/qbuffer.h" location="global"/>
   </object-type>
   <object-type name="QTimer">
+    <extra-includes>
+      <include file-name="pysidestaticstrings.h" location="global"/>
+    </extra-includes>
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="qtimer-singleshot-functorclass"/>
     <modify-function signature="singleShot(int,const QObject*,const char*)">
-      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qtimer-singleshot-1"/>
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qtimer-singleshot-direct-mapping"/>
     </modify-function>
-    <add-function signature="singleShot(int,PyCallable*)" static="yes">
-        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qtimer-singleshot-2"/>
+    <add-function signature="singleShot(int@msec@,PyCallable*@functor@)" static="yes">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qtimer-singleshot-functor"/>
+    </add-function>
+    <add-function signature="singleShot(int@msec@,const QObject*@context@,PyCallable*@functor@)" static="yes">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qtimer-singleshot-functor-context"/>
     </add-function>
   </object-type>
   <object-type name="QProcess">
+    <configuration condition="QT_CONFIG(process)"/>
     <enum-type name="ExitStatus"/>
     <enum-type name="InputChannelMode"/>
     <enum-type name="ProcessChannel"/>
@@ -2471,6 +2600,11 @@
     <enum-type name="ProcessError"/>
     <enum-type name="ProcessState"/>
 
+    <?if !windows?>
+    <enum-type name="UnixProcessFlag" flags="UnixProcessFlags" since="6.6"/>
+    <value-type name="UnixProcessParameters" since="6.6"/>
+    <?endif?>
+
     <modify-function signature="waitForStarted(int)" allow-thread="yes"/>
     <modify-function signature="waitForBytesWritten(int)" allow-thread="yes"/>
     <modify-function signature="waitForFinished(int)" allow-thread="yes"/>
@@ -2481,7 +2615,7 @@
         <modify-argument index="4">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[bool, int]">
             <replace-type modified-type="(retval, pid)"/>
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qprocess-startdetached"/>
@@ -2509,20 +2643,17 @@
       <include file-name="pysidecleanup.h" location="global"/>
       <include file-name="pysideqapp.h" location="global"/>
     </extra-includes>
-    <!-- constructor documentation -->
-    <inject-documentation format="target" mode="append">
-.. class:: QCoreApplication(args)
-
-    Constructs a Qt kernel application. Kernel applications are applications
-    without a graphical user interface. These type of applications are used
-    at the console or as server processes.
-
-    The *args* argument is processed by the application, and made available
-    in a more convenient form by the :meth:`~QCoreApplication.arguments()`
-    method.
-    </inject-documentation>
-    <add-function signature="QCoreApplication(QStringList)">
+    <add-function signature="QCoreApplication(QStringList@args@)">
         <inject-code file="../glue/qtcore.cpp" snippet="qcoreapplication-1"/>
+        <inject-documentation format="target" mode="append">
+        Constructs a Qt kernel application. Kernel applications are applications
+        without a graphical user interface. These type of applications are used
+        at the console or as server processes.
+
+        The *args* argument is processed by the application, and made available
+        in a more convenient form by the :meth:`~PySide6.QtCore.QCoreApplication.arguments()`
+        method.
+        </inject-documentation>
     </add-function>
     <add-function signature="QCoreApplication()">
         <inject-code file="../glue/qtcore.cpp" snippet="qcoreapplication-2"/>
@@ -2558,6 +2689,43 @@
         <define-ownership owner="c++"/>
       </modify-argument>
     </modify-function>
+    <modify-function signature="translate(const char*,const char*,const char *,int)">
+      <modify-argument index="1" pyi-type="str"/>
+      <modify-argument index="2" pyi-type="str"/>
+      <modify-argument index="3" pyi-type="Optional[str]"/>
+    </modify-function>
+    <?if !no_QPermission?>
+    <declare-function signature="checkPermission(const QBluetoothPermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <declare-function signature="checkPermission(const QCalendarPermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <declare-function signature="checkPermission(const QCameraPermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <declare-function signature="checkPermission(const QContactsPermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <declare-function signature="checkPermission(const QLocationPermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <declare-function signature="checkPermission(const QMicrophonePermission &amp; @permission@)" return-type="Qt::PermissionStatus" since="6.5" />
+    <add-function signature="requestPermission(const QBluetoothPermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <add-function signature="requestPermission(const QCalendarPermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <add-function signature="requestPermission(const QCameraPermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <add-function signature="requestPermission(const QContactsPermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <add-function signature="requestPermission(const QLocationPermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <add-function signature="requestPermission(const QMicrophonePermission &amp; @permission@, const QObject* @context@, PyCallable* @functor@)" since="6.5">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+              snippet="qcoreapplication-requestpermission"/>
+    </add-function>
+    <?endif?>
   </object-type>
   <object-type name="QSettings">
     <enum-type name="Format"/>
@@ -2566,10 +2734,12 @@
     <extra-includes>
       <include file-name="QStringList" location="global"/>
     </extra-includes>
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="settings-value-helpers"/>
     <!-- PYSIDE-1010:
     We remove the original implementation of value() to include the optional parameter -->
     <modify-function signature="value(QAnyStringView,const QVariant&amp;)const" remove="all"/>
-    <add-function signature="value(const QString&amp;, const QVariant&amp; @defaultValue@ = 0, PyObject* @type@ = 0)" return-type="PyObject*">
+    <add-function signature="value(const QString&amp;, const QVariant&amp; @defaultValue@ = {}, PyObject* @type@ = nullptr)" return-type="PyObject*">
       <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qsettings-value"/>
       <inject-documentation mode="append" format="target">
         Custom overload that adds an optional named parameter to the function ``value()``
@@ -2602,15 +2772,18 @@
                      file="../glue/qtcore.cpp" snippet="repr-qevent"/>
     </add-function>
   </object-type>
-  <object-type name="QChildEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ChildAdded || %1-&gt;type() == QEvent::ChildPolished || %1-&gt;type() == QEvent::ChildRemoved">
+  <object-type name="QChildEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ChildAdded || %B-&gt;type() == QEvent::ChildPolished || %B-&gt;type() == QEvent::ChildRemoved">
     <modify-function signature="child()const">
       <modify-argument index="return">
          <define-ownership class="target" owner="default"/>
       </modify-argument>
     </modify-function>
   </object-type>
-  <object-type name="QTimerEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Timer"/>
-  <object-type name="QDynamicPropertyChangeEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DynamicPropertyChange"/>
+  <object-type name="QTimerEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::Timer"/>
+  <object-type name="QDynamicPropertyChangeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::DynamicPropertyChange"/>
 
 
   <object-type name="QDataStream" stream="yes">
@@ -2678,13 +2851,19 @@
     <add-function signature="readQVariant()" return-type="QVariant">
         <inject-code class="target" position="end" file="../glue/qtcore.cpp" snippet="stream-read-method"/>
     </add-function>
-    <modify-function signature="readRawData(char*,int)">
+    <modify-function signature="readRawData(char*,qint64)">
+        <modify-argument index="return" pyi-type="bytes"/>
         <modify-argument index="1">
             <remove-argument />
         </modify-argument>
         <inject-code class="target" file="../glue/qtcore.cpp" snippet="qdatastream-readrawdata"/>
     </modify-function>
-    <modify-function signature="writeRawData(const char*,int)">
+    <add-function signature="writeRawData(PyBuffer)">
+        <inject-code class="target" position="beginning"
+                     file="../glue/qtcore.cpp" snippet="qdatastream-writerawdata-pybuffer"/>
+    </add-function>
+    <modify-function signature="writeRawData(const char*,qint64)">
+        <modify-argument index="1" pyi-type="str"/>
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
@@ -2765,7 +2944,7 @@
     <add-function signature="writeString(QString)">
         <inject-code class="target" position="end" file="../glue/qtcore.cpp" snippet="stream-write-method"/>
     </add-function>
-    <modify-function signature="readBytes(char*&amp;,uint&amp;)">
+    <modify-function signature="readBytes(char*&amp;,qint64&amp;)">
         <modify-argument index="return">
             <replace-type modified-type="PyTuple"/>
         </modify-argument>
@@ -2774,8 +2953,9 @@
         </modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qdatastream-read-bytes"/>
     </modify-function>
+    <modify-function signature="readBytes(char*&amp;,uint&amp;)" remove="all"/>
 
-    <modify-function signature="writeBytes(const char*,uint)">
+    <modify-function signature="writeBytes(const char*,qint64)">
         <modify-argument index="1">
             <replace-type modified-type="PyBuffer"/>
             <conversion-rule class="native">
@@ -2853,11 +3033,13 @@
     <enum-type name="LocateOption" flags="LocateOptions"/>
   </object-type>
   <object-type name="QSystemSemaphore">
+    <configuration condition="#ifndef QT_NO_SYSTEMSEMAPHORE"/>
     <enum-type name="AccessMode"/>
     <enum-type name="SystemSemaphoreError"/>
   </object-type>
 
   <object-type name="QThreadPool">
+    <configuration condition="QT_CONFIG(thread)"/>
     <modify-function signature="clear()" allow-thread="yes"/>
     <modify-function signature="activeThreadCount()const" allow-thread="yes"/>
     <modify-function signature="releaseThread()" allow-thread="yes"/>
@@ -2925,6 +3107,7 @@
   </object-type>
   <value-type name="QModelIndex">
     <modify-function signature="internalPointer()const">
+        <modify-argument index="return" pyi-type="Any"/>
         <inject-code class="target" position="beginning">
             <insert-template name="return_internal_pointer" />
         </inject-code>
@@ -2937,19 +3120,23 @@
   </value-type>
 
   <object-type name="QFutureInterfaceBase">
+      <configuration condition="QT_CONFIG(future)"/>
       <enum-type name="State"/>
       <enum-type name="CancelMode" since="6.3"/>
   </object-type>
   <value-type name="QFuture" generate="no">
       <include file-name="QtCore/qfuture.h" location="global"/>
+      <configuration condition="QT_CONFIG(future)"/>
       <modify-function signature="waitForFinished()" allow-thread="yes"/>
   </value-type>
   <object-type name="QFutureWatcherBase" generate="no">
+      <configuration condition="QT_CONFIG(future)"/>
       <modify-function signature="futureInterface()" remove="all"/>
       <modify-function signature="futureInterface() const" remove="all"/>
   </object-type>
   <object-type name="QFutureWatcher" generate="no">
       <include file-name="QtCore/qfuturewatcher.h" location="global"/>
+      <configuration condition="QT_CONFIG(future)"/>
   </object-type>
 
   <!--// FIXME PYSIDE 7: Remove in favor of QtCoreHelper::QGenericArgumentHolder for
@@ -2966,11 +3153,89 @@
   <object-type name="QMessageLogContext"/>
 
   <value-type name="QMetaMethod">
+    <extra-includes>
+        <include file-name="pysidesignal.h" location="global"/>
+        <include file-name="glue/core_snippets_p.h" location="local"/>
+    </extra-includes>
+    <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
+                 snippet="qmetamethod-invoke-helpers"/>
     <enum-type name="Access"/>
     <enum-type name="MethodType"/>
+    <add-function signature="fromSignal(PySideSignalInstance@signal@)"
+                  return-type="QMetaMethod" static="true">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+                     snippet="qmetamethod-from-signal"/>
+        <inject-documentation format="target" mode="append">
+        Returns the meta-method that corresponds to the given signal, or an invalid QMetaMethod
+        if signal is not a signal of the class.
+        </inject-documentation>
+    </add-function>
+    <add-function signature="invoke(QObject*@object@,Qt::ConnectionType@type@,
+                                    QtCoreHelper::QGenericReturnArgumentHolder@ret@,
+                                    QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val9@={})"
+                  return-type="PyObject*">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+                     snippet="qmetamethod-invoke-conn-type-return-arg"/>
+    </add-function>
+    <add-function signature="invoke(QObject*@object@,
+                                    QtCoreHelper::QGenericReturnArgumentHolder@ret@,
+                                    QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val9@={})"
+                  return-type="PyObject*">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+                     snippet="qmetamethod-invoke-return-arg"/>
+    </add-function>
+    <add-function signature="invoke(QObject*@object@,Qt::ConnectionType@type@,
+                                    QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val9@={})"
+                  return-type="PyObject*">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+                     snippet="qmetamethod-invoke-conn-type"/>
+    </add-function>
+    <add-function signature="invoke(QObject*@object@,
+                                    QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                    QtCoreHelper::QGenericArgumentHolder@val9@={})"
+                  return-type="PyObject*">
+        <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
+                     snippet="qmetamethod-invoke"/>
+    </add-function>
     <!-- This isn't part of Qt public API -->
     <modify-function signature="attributes()const" remove="all"/>
     <modify-function signature="getParameterTypes(int*)const" remove="all"/>
+    <modify-field name="mobj" remove="yes"/>
   </value-type>
   <object-type name="QMetaObject">
     <enum-type name="Call"/>
@@ -2978,6 +3243,7 @@
     <extra-includes>
       <include file-name="dynamicqmetaobject.h" location="global"/>
       <include file-name="pysidemetatype.h" location="global"/>
+      <include file-name="glue/core_snippets_p.h" location="local"/>
       <include file-name="pysideutils.h" location="global"/> <!-- QString conversion -->
     </extra-includes>
     <inject-code class="native" position="beginning" file="../glue/qtcore.cpp"
@@ -2990,22 +3256,64 @@
         <declare-function signature="operator bool() const" return-type="bool"/>
       </value-type>
     <modify-function signature="^invokeMethod\(" allow-thread="yes"/>
-    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,Qt::ConnectionType@type@,QtCoreHelper::QGenericArgumentHolder@val0@={},QtCoreHelper::QGenericArgumentHolder@val1@={},QtCoreHelper::QGenericArgumentHolder@val2@={})"
+    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,Qt::ConnectionType@type@,
+                                          QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val9@={})"
                   static="yes" return-type="bool">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
                      snippet="qmetaobject-invokemethod-conn-type-arg"/>
     </add-function>
-    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,QtCoreHelper::QGenericArgumentHolder@val0@={},QtCoreHelper::QGenericArgumentHolder@val1@={},QtCoreHelper::QGenericArgumentHolder@val2@={})"
+    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,
+                                          QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val9@={})"
                   static="yes" return-type="bool">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
                      snippet="qmetaobject-invokemethod-arg"/>
     </add-function>
-    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,Qt::ConnectionType@type@,QtCoreHelper::QGenericReturnArgumentHolder@ret@,QtCoreHelper::QGenericArgumentHolder@val0@={},QtCoreHelper::QGenericArgumentHolder@val1@={},QtCoreHelper::QGenericArgumentHolder@val2@={})"
+    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,Qt::ConnectionType@type@,
+                                          QtCoreHelper::QGenericReturnArgumentHolder@ret@,
+                                          QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val9@={})"
                   static="yes" return-type="PyObject*">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
                      snippet="qmetaobject-invokemethod-conn-type-return-arg"/>
     </add-function>
-    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,QtCoreHelper::QGenericReturnArgumentHolder@ret@,QtCoreHelper::QGenericArgumentHolder@val0@={},QtCoreHelper::QGenericArgumentHolder@val1@={},QtCoreHelper::QGenericArgumentHolder@val2@={})"
+    <add-function signature="invokeMethod(QObject*@object@,const char *@member@,
+                                          QtCoreHelper::QGenericReturnArgumentHolder@ret@,
+                                          QtCoreHelper::QGenericArgumentHolder@val0@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val1@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val2@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val3@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val4@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val5@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val6@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val7@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val8@={},
+                                          QtCoreHelper::QGenericArgumentHolder@val9@={})"
                   static="yes" return-type="PyObject*">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp"
                      snippet="qmetaobject-invokemethod-return-arg"/>
@@ -3013,6 +3321,27 @@
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qmetaobject-repr"/>
     </add-function>
+    <modify-function signature="indexOfClassInfo(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfConstructor(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfEnumerator(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfMethod(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfProperty(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfSignal(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
+    <modify-function signature="indexOfSlot(const char *)">
+        <modify-argument index="1" pyi-type="str"/>
+    </modify-function>
   </object-type>
   <value-type name="QMetaProperty" >
     <!-- This isn't part of Qt public API -->
@@ -3141,6 +3470,7 @@
   <object-type name="QPauseAnimation" since="4.6"/>
 
   <value-type name="QProcessEnvironment" since="4.6">
+      <configuration condition="QT_CONFIG(processenvironment)"/>
       <enum-type name="Initialization" since="6.3"/>
   </value-type>
 
@@ -3162,10 +3492,12 @@
 
   <add-function signature="SIGNAL(const char*)" return-type="str">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qt-signal"/>
+    <modify-argument index="1" pyi-type="str"/>
   </add-function>
 
   <add-function signature="SLOT(const char*)" return-type="str">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qt-slot"/>
+    <modify-argument index="1" pyi-type="str"/>
   </add-function>
 
   <add-function signature="QT_TR_NOOP(PyObject)" return-type="PyObject*">
@@ -3203,12 +3535,18 @@
   </add-function>
 
   <object-type name="QFactoryInterface"/>
-  <object-type name="QRunnable"/>
+  <object-type name="QRunnable">
+    <configuration condition="QT_CONFIG(thread)"/>
+    <add-function signature="create(PyObject* @functionToRun@)" static="yes" return-type="QRunnable*">
+      <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qrunnable_create"/>
+    </add-function>
+  </object-type>
 
   <object-type name="QPluginLoader"/>
   <object-type name="QStringListModel"/>
 
    <object-type name="QSharedMemory">
+       <configuration condition="#ifndef QT_NO_SHAREDMEMORY"/>
        <enum-type name="AccessMode"/>
        <enum-type name="SharedMemoryError"/>
        <modify-function signature="data()">
@@ -3246,25 +3584,25 @@
     <include file-name="qloggingcategory.h" location="global" />
     </extra-includes>
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qloggingcategory_to_cpp">
-      qCDebug(*category, "%s", %2);
+      qCDebug((*category), "%s", %2);
     </inject-code>
   </add-function>
 
   <add-function signature="qCCritical(PyObject *, const char *)">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qloggingcategory_to_cpp">
-      qCCritical(*category, "%s", %2);
+      qCCritical((*category), "%s", %2);
     </inject-code>
   </add-function>
 
   <add-function signature="qCInfo(PyObject *, const char *)">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qloggingcategory_to_cpp">
-      qCInfo(*category, "%s", %2);
+      qCInfo((*category), "%s", %2);
     </inject-code>
   </add-function>
 
   <add-function signature="qCWarning(PyObject *, const char *)">
     <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qloggingcategory_to_cpp">
-      qCWarning(*category, "%s", %2);
+      qCWarning((*category), "%s", %2);
     </inject-code>
   </add-function>
 
@@ -3273,19 +3611,20 @@
 
   <suppress-warning text="^Anonymous enum.*does not have a type entry.*$"/>
   <suppress-warning text="Visibility of function '*' modified in class '*'"/>
-  <suppress-warning text="hiding of function '*' in class '*'"/>
   <suppress-warning text="Shadowing: *"/>
-  <suppress-warning text="namespace '*' does not have a type entry"/>
+  <suppress-warning text="^namespace '.*' does not have a type entry.*$"/>
   <!-- QCborStreamReader: Suppress warnings about 32/64bit signatures not found depending on qsizetype -->
   <suppress-warning text="^signature 'readStringChunk\(char.*in 'QCborStreamReader' not found.*$"/>
 
   <!-- TODO: this need be removed -->
-  <suppress-warning text="^skipping function '.*', unmatched return type '.*$"/>
-  <suppress-warning text="^skipping function '.*', unmatched type '.*$"/>
-  <suppress-warning text="skipping field 'QStringConverter::iface' with unmatched type 'QStringConverter::Interface'"/>
-  <suppress-warning text="skipping field 'Qt::Uninitialized' with unmatched type 'Qt::Initialization'"/>
-  <suppress-warning text="skipping field 'State::clearFn' with unmatched type 'void'"/>
+  <suppress-warning text="^skipping.*function '.*', unmatched return type '.*$"/>
+  <suppress-warning text="^skipping.*function '.*', unmatched type '.*$"/>
+  <suppress-warning text="skipping protected field 'QStringConverter::iface' with unmatched type 'QStringConverter::Interface'"/>
+  <suppress-warning text="^skipping public field 'Qt::.*' with unmatched type 'Qt::.*ordering'$"/>
+  <suppress-warning text="skipping public field 'Qt::Uninitialized' with unmatched type 'Qt::Initialization'"/>
+  <suppress-warning text="skipping public field 'State::clearFn' with unmatched type 'void'"/>
   <suppress-warning text="template baseclass 'QListSpecialMethods&lt;T&gt;' of 'QList' is not known"/>
   <suppress-warning text="^.*inherits from a non polymorphic type.*QIODeviceBase.*type discovery based on RTTI is impossible.*$"/>
+  <suppress-warning text="Base class 'QOperatingSystemVersionUnexported' of class 'QOperatingSystemVersion' not found in the type system for setting up inheritance."/>
 
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtDBus/CMakeLists.txt b/sources/pyside6/PySide6/QtDBus/CMakeLists.txt
index 1686df84f..5ee8dc67c 100644
--- a/sources/pyside6/PySide6/QtDBus/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtDBus/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtDBus)
 
 set(QtDBus_SRC
diff --git a/sources/pyside6/PySide6/QtDBus/typesystem_dbus.xml b/sources/pyside6/PySide6/QtDBus/typesystem_dbus.xml
index 8580c339e..ebed22257 100644
--- a/sources/pyside6/PySide6/QtDBus/typesystem_dbus.xml
+++ b/sources/pyside6/PySide6/QtDBus/typesystem_dbus.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtDBus">
+<typesystem package="PySide6.QtDBus"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 
     <namespace-type name="QDBus">
@@ -53,6 +54,8 @@
           <define-ownership class="target" owner="default"/>
         </modify-argument>
       </modify-function>
+      <!-- PYSIDE-2547, hangs -->
+      <modify-function signature="^connect\(.*\)$" allow-thread="yes"/>
     </value-type>
     <object-type name="QDBusConnectionInterface">
       <enum-type name="RegisterServiceReply"/>
@@ -82,7 +85,12 @@
     <value-type name="QDBusError">
       <enum-type name="ErrorType"/>
     </value-type>
-    <object-type name="QDBusInterface"/>
+    <object-type name="QDBusInterface" qt-metaobject="no">
+      <inject-documentation format="target" mode="append">
+        DBus signals can be captured with string-based connections
+        (see :ref:`signals-and-slots-strings`).
+      </inject-documentation>
+    </object-type>
     <value-type name="QDBusMessage">
       <enum-type name="MessageType"/>
     </value-type>
@@ -100,7 +108,7 @@
     </object-type>
     <object-type name="QDBusSignature"/>
     <object-type name="QDBusUnixFileDescriptor"/>
-    <object-type name="QDBusVariant"/>
+    <value-type name="QDBusVariant"/>
     <object-type name="QDBusVirtualObject"/>
     <suppress-warning text='^.*Unable to translate type "QDBusReply&lt;.*$'/>
     <suppress-warning text='^.*QDBusPendingCallWatcher inherits from a non polymorphic type.*$'/>
diff --git a/sources/pyside6/PySide6/QtDataVisualization/CMakeLists.txt b/sources/pyside6/PySide6/QtDataVisualization/CMakeLists.txt
index b11006df1..1276b424f 100644
--- a/sources/pyside6/PySide6/QtDataVisualization/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtDataVisualization/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtDataVisualization)
 
 list(APPEND QtDataVisualization_src "${QtDataVisualization_SOURCE_DIR}/qtdatavisualization_helper.cpp")
@@ -51,10 +54,8 @@ set(QtDataVisualization_include_dirs ${QtDataVisualization_SOURCE_DIR}
                           ${QtCore_GEN_DIR}
                           ${QtGui_GEN_DIR})
 
-set(QtDataVisualization_libraries    pyside6
-                          ${Qt${QT_MAJOR_VERSION}DataVisualization_LIBRARIES}
-                          ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                          ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES})
+set(QtDataVisualization_libraries pyside6
+                                  ${Qt${QT_MAJOR_VERSION}DataVisualization_LIBRARIES})
 
 set(QtDataVisualization_deps QtCore QtGui)
 
diff --git a/sources/pyside6/PySide6/QtDataVisualization/qtdatavisualization_helper.cpp b/sources/pyside6/PySide6/QtDataVisualization/qtdatavisualization_helper.cpp
index 12384a093..8ad31a77a 100644
--- a/sources/pyside6/PySide6/QtDataVisualization/qtdatavisualization_helper.cpp
+++ b/sources/pyside6/PySide6/QtDataVisualization/qtdatavisualization_helper.cpp
@@ -57,6 +57,14 @@ QSurfaceDataArray *surfaceDataFromNp(double xStart, double deltaX, double zStart
         return result;
 
     switch (view.type) {
+    case Shiboken::Numpy::View::Int16:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const int16_t *>(view.data), result);
+        break;
+    case Shiboken::Numpy::View::Unsigned16:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const uint16_t *>(view.data), result);
+        break;
     case Shiboken::Numpy::View::Int:
         populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
                       reinterpret_cast<const int *>(view.data), result);
@@ -65,6 +73,14 @@ QSurfaceDataArray *surfaceDataFromNp(double xStart, double deltaX, double zStart
         populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
                       reinterpret_cast<const unsigned *>(view.data), result);
         break;
+    case Shiboken::Numpy::View::Int64:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const int64_t *>(view.data), result);
+        break;
+    case Shiboken::Numpy::View::Unsigned64:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const uint64_t *>(view.data), result);
+        break;
     case Shiboken::Numpy::View::Float:
         populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
                       reinterpret_cast<const float *>(view.data), result);
diff --git a/sources/pyside6/PySide6/QtDataVisualization/typesystem_datavisualization.xml b/sources/pyside6/PySide6/QtDataVisualization/typesystem_datavisualization.xml
index 37ebca801..70014e3dc 100644
--- a/sources/pyside6/PySide6/QtDataVisualization/typesystem_datavisualization.xml
+++ b/sources/pyside6/PySide6/QtDataVisualization/typesystem_datavisualization.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2017 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtDataVisualization">
+<typesystem package="PySide6.QtDataVisualization"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
 
    <extra-includes>
       <include file-name="qtdatavisualization_helper.h" location="global"/>
@@ -116,11 +117,17 @@
   </object-type>
   <value-type name="QBarDataItem"/>
   <object-type name="QBarDataProxy">
-    <modify-function signature="resetArray(QBarDataArray*)">
-      <modify-argument index="1">
-        <parent index="this" action="add"/>
-      </modify-argument>
-    </modify-function>
+    <modify-function signature="resetArray(QBarDataArray*)" remove="all"/>
+    <add-function signature="resetArray(const QBarDataArray&amp;)">
+      <inject-code class="target" position="beginning" file="../glue/qtdatavisualization.cpp"
+                   snippet="dataproxy-resetarray"/>
+    </add-function>
+    <modify-function signature="resetArray(QBarDataArray*,const QStringList&amp;,const QStringList&amp;)"
+                     remove="all"/>
+    <add-function signature="resetArray(const QBarDataArray&amp;,const QStringList&amp;,const QStringList&amp;)">
+      <inject-code class="target" position="beginning" file="../glue/qtdatavisualization.cpp"
+                   snippet="dataproxy-resetarray2"/>
+    </add-function>
     <modify-function signature="resetArray(QBarDataArray*,const QStringList&amp;,const QStringList&amp;)">
       <modify-argument index="1">
         <parent index="this" action="add"/>
@@ -220,11 +227,12 @@
   </object-type>
   <value-type name="QScatterDataItem"/>
   <object-type name="QScatterDataProxy">
-    <modify-function signature="resetArray(QList&lt;QScatterDataItem&gt;*)">
-      <modify-argument index="1">
-        <parent index="this" action="add"/>
-      </modify-argument>
-    </modify-function>
+    <modify-function signature="resetArray(QList&lt;QScatterDataItem&gt;*)"
+                     remove="all"/>
+    <add-function signature="resetArray(QList&lt;QScatterDataItem&gt;*)">
+      <inject-code class="target" position="beginning" file="../glue/qtdatavisualization.cpp"
+                   snippet="scatterdataproxy-resetarray"/>
+    </add-function>
     <modify-function signature="addItem(const QScatterDataItem&amp;)">
       <modify-argument index="1">
         <parent index="this" action="add"/>
@@ -271,11 +279,10 @@
   </object-type>
   <value-type name="QSurfaceDataItem"/>
   <object-type name="QSurfaceDataProxy">
-    <extra-includes>
-      <include file-name="sbknumpycheck.h" location="global"/>
-      <include file-name="qtdatavisualization_helper.h" location="global"/>
-    </extra-includes>
-
+    <inject-code class="native" position="beginning">
+      #include &lt;sbknumpycheck.h&gt;
+      #include &lt;qtdatavisualization_helper.h&gt;
+    </inject-code>
     <!-- PYSIDE-1438: Replace all add/set/insertRow() taking a 'QList*' by overloads
          taking 'const QList &' since an allocated list needs to be passed. -->
     <modify-function signature="addRow(QList&lt;QSurfaceDataItem&gt;*)" remove="all"/>
@@ -462,4 +469,8 @@
   <extra-includes>
     <include file-name="qutils.h" location="global"/>
   </extra-includes>
+
+  <!-- QtQml/QtNetwork are pulled in via QtDataVisualizationDepends. -->
+  <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls)|(Qml).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtDesigner/CMakeLists.txt b/sources/pyside6/PySide6/QtDesigner/CMakeLists.txt
index f8a57834b..e91532b87 100644
--- a/sources/pyside6/PySide6/QtDesigner/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtDesigner/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtDesigner)
 
 qt_wrap_cpp(QtDesigner_static_src "${pyside6_SOURCE_DIR}/qpydesignerextensions.h")
@@ -48,14 +51,11 @@ set(QtDesigner_include_dirs ${QtDesigner_SOURCE_DIR}
                             ${QtDesigner_BINARY_DIR}
                             ${QtCore_GEN_DIR}
                             ${QtGui_GEN_DIR}
-                            ${QtWidgets_GEN_DIR}
-                            )
+                            ${QtWidgets_GEN_DIR})
+
 set(QtDesigner_libraries pyside6
-                         ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                         ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                         ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                         ${Qt${QT_MAJOR_VERSION}Designer_LIBRARIES}
-                         )
+                         ${Qt${QT_MAJOR_VERSION}Designer_LIBRARIES})
+
 set(QtDesigner_deps QtWidgets)
 
 create_pyside_module(NAME QtDesigner
diff --git a/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp b/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
index 22b76e131..31f8ec152 100644
--- a/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
+++ b/sources/pyside6/PySide6/QtDesigner/qpydesignercustomwidgetcollection.cpp
@@ -9,6 +9,8 @@
 #include <shiboken.h>
 #include <bindingmanager.h>
 
+QT_BEGIN_NAMESPACE
+
 static QString pyStringToQString(PyObject *s)
 {
     const char *utf8 = _PepUnicode_AsString(s);
@@ -217,3 +219,5 @@ void QPyDesignerCustomWidgetCollection::addCustomWidget(QDesignerCustomWidgetInt
 {
     instance()->m_customWidgets.append(c);
 }
+
+QT_END_NAMESPACE
diff --git a/sources/pyside6/PySide6/QtDesigner/typesystem_designer.xml b/sources/pyside6/PySide6/QtDesigner/typesystem_designer.xml
index 22d7a7652..7d37cbddf 100644
--- a/sources/pyside6/PySide6/QtDesigner/typesystem_designer.xml
+++ b/sources/pyside6/PySide6/QtDesigner/typesystem_designer.xml
@@ -3,8 +3,12 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtDesigner">
+<typesystem package="PySide6.QtDesigner"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
+
+  <rejection class="qdesigner_internal"/>
+
   <object-type name="QAbstractExtensionFactory"/>
   <object-type name="QAbstractExtensionManager"/>
   <object-type name="QAbstractFormBuilder"/>
diff --git a/sources/pyside6/PySide6/QtGraphs/CMakeLists.txt b/sources/pyside6/PySide6/QtGraphs/CMakeLists.txt
new file mode 100644
index 000000000..59cef220b
--- /dev/null
+++ b/sources/pyside6/PySide6/QtGraphs/CMakeLists.txt
@@ -0,0 +1,100 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+project(QtGraphs)
+
+set(QtGraphs_DROPPED_ENTRIES)
+
+list(APPEND QtGraphs_src "${QtGraphs_SOURCE_DIR}/qtgraphs_helper.cpp")
+
+set(QtGraphs_SRC
+# 3D
+${QtGraphs_GEN_DIR}/qabstract3daxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qcategory3daxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qlogvalue3daxisformatter_wrapper.cpp
+${QtGraphs_GEN_DIR}/qvalue3daxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qvalue3daxisformatter_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstract3dseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstractdataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qbar3dseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qbardataitem_wrapper.cpp
+${QtGraphs_GEN_DIR}/qbardataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qcustom3ditem_wrapper.cpp
+${QtGraphs_GEN_DIR}/qcustom3dlabel_wrapper.cpp
+${QtGraphs_GEN_DIR}/qcustom3dvolume_wrapper.cpp
+${QtGraphs_GEN_DIR}/qheightmapsurfacedataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qitemmodelbardataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qitemmodelscatterdataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qitemmodelsurfacedataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qscatter3dseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qscatterdataitem_wrapper.cpp
+${QtGraphs_GEN_DIR}/qscatterdataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/qsurface3dseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qsurfacedataitem_wrapper.cpp
+${QtGraphs_GEN_DIR}/qsurfacedataproxy_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dbars_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dscatter_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dscene_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dsurface_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstract3dgraph_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dinputhandler_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstract3dinputhandler_wrapper.cpp
+${QtGraphs_GEN_DIR}/qtouch3dinputhandler_wrapper.cpp
+${QtGraphs_GEN_DIR}/q3dtheme_wrapper.cpp
+# 2D
+${QtGraphs_GEN_DIR}/qbarcategoryaxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstractaxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qvalueaxis_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstractbarseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qbarseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qbarset_wrapper.cpp
+${QtGraphs_GEN_DIR}/qlineseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qabstractseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qscatterseries_wrapper.cpp
+${QtGraphs_GEN_DIR}/qgraphtheme_wrapper.cpp
+${QtGraphs_GEN_DIR}/qseriestheme_wrapper.cpp
+${QtGraphs_GEN_DIR}/qxyseries_wrapper.cpp
+# module is always needed
+${QtGraphs_GEN_DIR}/qtgraphs_module_wrapper.cpp
+)
+
+set(QtGraphs_include_dirs ${QtGraphs_SOURCE_DIR}
+                          ${QtGraphs_BINARY_DIR}
+                          ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}QtNetwork_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Widgets_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Quick_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}QuickWidgets_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Graphs_INCLUDE_DIRS}
+                          ${Qt${QT_MAJOR_VERSION}Quick3D_INCLUDE_DIRS}
+                          ${libpyside_SOURCE_DIR}
+                          ${QtCore_GEN_DIR}
+                          ${QtNetwork_GEN_DIR}
+                          ${QtGui_GEN_DIR}
+                          ${QtWidgets_GEN_DIR}
+                          ${QtQml_GEN_DIR}
+                          ${QtQuick_GEN_DIR}
+                          ${QtQuickWidgets_GEN_DIR}
+                          ${QtQuick3D_GEN_DIR})
+
+set(QtGraphs_libraries    pyside6
+                          ${Qt${QT_MAJOR_VERSION}Graphs_LIBRARIES})
+
+set(QtGraphs_deps QtCore QtNetwork QtGui QtWidgets QtQml QtQuick QtQuickWidgets QtQuick3D)
+
+check_qt_opengl("Graphs" QtGraphs_include_dirs QtGraphs_deps
+                QtGraphs_DROPPED_ENTRIES)
+
+create_pyside_module(NAME QtGraphs
+                     INCLUDE_DIRS QtGraphs_include_dirs
+                     LIBRARIES QtGraphs_libraries
+                     DEPS QtGraphs_deps
+                     TYPESYSTEM_PATH QtGraphs_SOURCE_DIR
+                     SOURCES QtGraphs_SRC
+                     STATIC_SOURCES QtGraphs_src
+                     DROPPED_ENTRIES QtGraphs_DROPPED_ENTRIES)
+
+install(FILES ${pyside6_SOURCE_DIR}/qtgraphs_helper.h
+        DESTINATION include/PySide6/QtGraphs)
diff --git a/sources/pyside6/PySide6/QtGraphs/qtgraphs_helper.cpp b/sources/pyside6/PySide6/QtGraphs/qtgraphs_helper.cpp
new file mode 100644
index 000000000..19fe4f818
--- /dev/null
+++ b/sources/pyside6/PySide6/QtGraphs/qtgraphs_helper.cpp
@@ -0,0 +1,97 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qtgraphs_helper.h"
+
+#include <sbknumpyview.h>
+
+#include <QtCore/QDebug>
+
+namespace QtGraphsHelper {
+
+template <class T>
+static void populateArray(double xStart, double deltaX, double zStart, double deltaZ,
+                          qsizetype xSize, qsizetype zSize, qsizetype zStrideBytes,
+                          const T *data, QSurfaceDataArray *result)
+{
+    result->reserve(zSize);
+    const qsizetype zStride = zStrideBytes / sizeof(T);
+    double z = zStart;
+    for (qsizetype zi = 0; zi < zSize; ++zi) {
+        QSurfaceDataRow row;
+        row.reserve(xSize);
+
+        double x = xStart;
+        auto *rowDataEnd = data + xSize;
+        for (auto *d = data; d < rowDataEnd; ++d) {
+            row.append(QSurfaceDataItem(QVector3D(x, *d, z)));
+            x += deltaX;
+        }
+        result->append(row);
+
+        data += zStride;
+        z += deltaZ;
+    }
+}
+
+QSurfaceDataArray surfaceDataFromNp(double xStart, double deltaX, double zStart, double deltaZ,
+                                    PyObject *pyData)
+{
+    static const char funcName[] = "QSurfaceDataProxy.resetArrayNp";
+
+    QSurfaceDataArray result;
+
+    auto view = Shiboken::Numpy::View::fromPyObject(pyData);
+    if (!view) {
+        PyErr_Format(PyExc_TypeError, "Invalid array passed to %s", funcName);
+        return result;
+    }
+    if (view.ndim != 2) {
+        PyErr_Format(PyExc_TypeError, "%s expects a 2 dimensional array (%d)", view.ndim);
+        return result;
+    }
+
+    const qsizetype zSize = view.dimensions[0];
+    const qsizetype xSize = view.dimensions[1];
+    if (zSize  == 0 || xSize == 0)
+        return result;
+
+    switch (view.type) {
+    case Shiboken::Numpy::View::Int16:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const int16_t *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Unsigned16:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const uint16_t *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Int:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const int *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Unsigned:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const unsigned *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Int64:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const int64_t *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Unsigned64:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const uint64_t *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Float:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const float *>(view.data), &result);
+        break;
+    case Shiboken::Numpy::View::Double:
+        populateArray(xStart, deltaX, zStart, deltaZ, xSize, zSize, view.stride[0],
+                      reinterpret_cast<const double *>(view.data), &result);
+
+        break;
+    }
+    return result;
+}
+
+} // namespace QtGraphsHelper
diff --git a/sources/pyside6/PySide6/QtGraphs/typesystem_graphs.xml b/sources/pyside6/PySide6/QtGraphs/typesystem_graphs.xml
new file mode 100644
index 000000000..43e4458be
--- /dev/null
+++ b/sources/pyside6/PySide6/QtGraphs/typesystem_graphs.xml
@@ -0,0 +1,303 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+-->
+<typesystem package="PySide6.QtGraphs"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
+
+   <extra-includes>
+      <include file-name="qtgraphs_helper.h" location="global"/>
+   </extra-includes>
+
+  <load-typesystem name="templates/datavisualization_common.xml" generate="no" />
+  <load-typesystem name="QtQuickWidgets/typesystem_quickwidgets.xml" generate="no" />
+
+  <function signature="qDefaultSurfaceFormat(bool)"/>
+
+
+  <object-type name="QAbstract3DAxis">
+    <enum-type name="AxisOrientation"/>
+    <enum-type name="AxisType"/>
+  </object-type>
+  <object-type name="QCategory3DAxis"/>
+  <object-type name="QLogValue3DAxisFormatter"/>
+  <object-type name="QValue3DAxis">
+  <modify-function signature="setFormatter(QValue3DAxisFormatter *)">
+    <modify-argument index="1">
+      <parent index="this" action="add"/>
+    </modify-argument>
+  </modify-function>
+  </object-type>
+  <object-type name="QValue3DAxisFormatter">
+    <modify-function signature="createNewInstance() const">
+      <modify-argument index="return">
+        <define-ownership class="native" owner="c++"/>
+        <define-ownership class="target" owner="default"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="QAbstract3DSeries">
+    <enum-type name="Mesh"/>
+    <enum-type name="SeriesType"/>
+  </object-type>
+  <object-type name="QAbstractDataProxy">
+    <enum-type name="DataType"/>
+  </object-type>
+  <object-type name="QBar3DSeries">
+    <modify-function signature="setDataProxy(QBarDataProxy*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <value-type name="QBarDataItem"/>
+  <object-type name="QBarDataProxy">
+  </object-type>
+  <object-type name="QCustom3DItem"/>
+  <object-type name="QCustom3DLabel"/>
+  <object-type name="QCustom3DVolume">
+      <modify-function signature="setTextureData(QList&lt;uchar&gt;*)" remove="all"/>
+      <add-function signature="setTextureData(const QList&lt;uchar&gt;&amp;)">
+          <inject-code class="target" position="beginning" file="../glue/qtdatavisualization.cpp"
+                       snippet="qcustom3dvolume-settexturedata"/>
+      </add-function>
+  </object-type>
+  <object-type name="QHeightMapSurfaceDataProxy"/>
+  <object-type name="QItemModelBarDataProxy">
+    <enum-type name="MultiMatchBehavior"/>
+  </object-type>
+  <object-type name="QItemModelScatterDataProxy"/>
+  <object-type name="QItemModelSurfaceDataProxy">
+    <enum-type name="MultiMatchBehavior"/>
+  </object-type>
+  <object-type name="QScatter3DSeries">
+    <modify-function signature="setDataProxy(QScatterDataProxy*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <value-type name="QScatterDataItem"/>
+  <object-type name="QScatterDataProxy">
+  </object-type>
+  <object-type name="QSurface3DSeries">
+    <enum-type name="DrawFlag" flags="DrawFlags"/>
+    <modify-function signature="QSurface3DSeries(QSurfaceDataProxy*,QObject*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setDataProxy(QSurfaceDataProxy*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <value-type name="QSurfaceDataItem"/>
+  <object-type name="QSurfaceDataProxy">
+    <inject-code class="native" position="beginning">
+      #include &lt;sbknumpycheck.h&gt;
+      #include &lt;qtgraphs_helper.h&gt;
+    </inject-code>
+    <add-function signature="resetArrayNp(double@x@,double@deltaX@,double@z@,double@deltaZ@,PyArrayObject*@data@)">
+        <inject-code file="../glue/qtgraphs.cpp"
+                     snippet="graphs-qsurfacedataproxy-resetarraynp"/>
+        <inject-documentation format="target" mode="append">
+        Populates the data from a 2 dimensional numpy array containing the y
+        values for a range starting a ``x``, ``z`` with steps of ``deltaX``,
+        ``deltaZ``, respectively.
+        </inject-documentation>
+    </add-function>
+
+  </object-type>
+  <object-type name="Q3DBars">
+    <modify-function signature="addAxis(QAbstract3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="releaseAxis(QAbstract3DAxis*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="setColumnAxis(QCategory3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setRowAxis(QCategory3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="Q3DScatter">
+    <modify-function signature="addAxis(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="releaseAxis(QValue3DAxis*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="setAxisX(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setAxisY(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setAxisZ(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="Q3DScene"/>
+  <object-type name="Q3DSurface">
+    <modify-function signature="addAxis(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="releaseAxis(QValue3DAxis*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="setAxisX(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setAxisY(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setAxisZ(QValue3DAxis*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="QAbstract3DGraph">
+    <enum-type name="ElementType"/>
+    <enum-type name="OptimizationHint" flags="OptimizationHints"/>
+    <enum-type name="RenderingMode"/>
+    <enum-type name="SelectionFlag" flags="SelectionFlags"/>
+    <enum-type name="ShadowQuality"/>
+    <enum-type name="CameraPreset" since="6.7"/>
+    <modify-function signature="addCustomItem(QCustom3DItem*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="addInputHandler(QAbstract3DInputHandler*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="addTheme(Q3DTheme*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="releaseCustomItem(QCustom3DItem*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="releaseInputHandler(QAbstract3DInputHandler*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="releaseTheme(Q3DTheme*)">
+      <modify-argument index="1">
+        <reference-count action="set"/>
+      </modify-argument>
+      <inject-code file="../glue/qtdatavisualization.cpp" snippet="releaseownership"/>
+    </modify-function>
+    <modify-function signature="setActiveInputHandler(QAbstract3DInputHandler*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="setActiveTheme(Q3DTheme*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="Q3DInputHandler"/>
+  <object-type name="QAbstract3DInputHandler">
+    <enum-type name="InputView"/>
+  </object-type>
+  <object-type name="QTouch3DInputHandler"/>
+  <object-type name="Q3DTheme">
+    <enum-type name="ColorStyle"/>
+    <enum-type name="Theme"/>
+  </object-type>
+
+  <!-- 2D -->
+  <object-type name="QBarCategoryAxis"/>
+  <object-type name="QAbstractAxis">
+    <enum-type name="AxisType"/>
+  </object-type>
+  <object-type name="QValueAxis"/>
+  <object-type name="QAbstractBarSeries">
+    <enum-type name="LabelsPosition"/>
+    <modify-function signature="append(QBarSet*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="append(QList&lt;QBarSet*&gt;)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="insert(int,QBarSet*)">
+      <modify-argument index="2">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+    <modify-function signature="take(QBarSet*)">
+      <modify-argument index="1">
+        <parent index="this" action="add"/>
+      </modify-argument>
+    </modify-function>
+  </object-type>
+  <object-type name="QBarSeries"/>
+  <object-type name="QBarSet"/>
+  <object-type name="QLineSeries"/>
+  <object-type name="QAbstractSeries">
+    <enum-type name="SeriesType"/>
+  </object-type>
+  <object-type name="QScatterSeries"/>
+  <object-type name="QGraphTheme">
+    <enum-type name="ColorTheme"/>
+  </object-type>
+  <object-type name="QSeriesTheme">
+    <enum-type name="SeriesColorTheme"/>
+  </object-type>
+  <object-type name="QXYSeries">
+  </object-type>
+
+  <extra-includes>
+    <include file-name="qutils.h" location="global"/>
+  </extra-includes>
+</typesystem>
diff --git a/sources/pyside6/PySide6/QtGui/CMakeLists.txt b/sources/pyside6/PySide6/QtGui/CMakeLists.txt
index 2c95c71af..c868b6c88 100644
--- a/sources/pyside6/PySide6/QtGui/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtGui/CMakeLists.txt
@@ -1,10 +1,84 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtGui)
 
 qt_wrap_cpp(QPYTEXTOBJECT_MOC "${pyside6_SOURCE_DIR}/qpytextobject.h")
 
 set(QtGui_DROPPED_ENTRIES)
 
+# Exclude sources that have clashing static helper functions named "iterator_..."
+set(QtGui_SRC_UNITY_EXCLUDED_SRC
+    ${QtGui_GEN_DIR}/qtextframe_iterator_wrapper.cpp
+    ${QtGui_GEN_DIR}/qtextblock_iterator_wrapper.cpp
+    ${QtGui_GEN_DIR}/qshaderversion_wrapper.cpp
+)
+
+set_property(SOURCE ${QtGui_SRC_UNITY_EXCLUDED_SRC}
+             PROPERTY SKIP_UNITY_BUILD_INCLUSION ON)
+
+set(QtGui_SRC_RHI
+${QtGui_GEN_DIR}/qrhi_wrapper.cpp
+${QtGui_GEN_DIR}/qrhibuffer_wrapper.cpp
+${QtGui_GEN_DIR}/qrhicolorattachment_wrapper.cpp
+${QtGui_GEN_DIR}/qrhicommandbuffer_wrapper.cpp
+${QtGui_GEN_DIR}/qrhicomputepipeline_wrapper.cpp
+${QtGui_GEN_DIR}/qrhidepthstencilclearvalue_wrapper.cpp
+${QtGui_GEN_DIR}/qrhidriverinfo_wrapper.cpp
+${QtGui_GEN_DIR}/qrhigraphicspipeline_targetblend_wrapper.cpp
+${QtGui_GEN_DIR}/qrhigraphicspipeline_wrapper.cpp
+${QtGui_GEN_DIR}/qrhigraphicspipeline_stencilopstate_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiinitparams_wrapper.cpp
+${QtGui_GEN_DIR}/qrhinativehandles_wrapper.cpp
+${QtGui_GEN_DIR}/qrhinullinitparams_wrapper.cpp
+${QtGui_GEN_DIR}/qrhireadbackdescription_wrapper.cpp
+${QtGui_GEN_DIR}/qrhireadbackresult_wrapper.cpp
+${QtGui_GEN_DIR}/qrhirenderbuffer_wrapper.cpp
+${QtGui_GEN_DIR}/qrhirenderpassdescriptor_wrapper.cpp
+${QtGui_GEN_DIR}/qrhirendertarget_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiresource_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiresourceupdatebatch_wrapper.cpp
+${QtGui_GEN_DIR}/qrhisampler_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiscissor_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebinding_textureandsampler_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebinding_data_storagebufferdata_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebinding_data_storageimagedata_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebinding_data_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebinding_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderresourcebindings_wrapper.cpp
+${QtGui_GEN_DIR}/qrhishaderstage_wrapper.cpp
+${QtGui_GEN_DIR}/qrhistats_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiswapchain_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiswapchainrendertarget_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitexture_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitexturecopydescription_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitexturerendertarget_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitexturerendertargetdescription_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitexturesubresourceuploaddescription_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitextureuploaddescription_wrapper.cpp
+${QtGui_GEN_DIR}/qrhitextureuploadentry_wrapper.cpp
+${QtGui_GEN_DIR}/qrhivertexinputattribute_wrapper.cpp
+${QtGui_GEN_DIR}/qrhivertexinputbinding_wrapper.cpp
+${QtGui_GEN_DIR}/qrhivertexinputlayout_wrapper.cpp
+${QtGui_GEN_DIR}/qrhiviewport_wrapper.cpp
+${QtGui_GEN_DIR}/qshader_wrapper.cpp
+${QtGui_GEN_DIR}/qshadercode_wrapper.cpp
+${QtGui_GEN_DIR}/qshaderkey_wrapper.cpp
+)
+
+if (ENABLE_WIN)
+    list(APPEND QtGui_SRC_RHI
+         ${QtGui_GEN_DIR}/qrhid3d11initparams_wrapper.cpp
+         ${QtGui_GEN_DIR}/qrhid3d11nativehandles_wrapper.cpp
+         ${QtGui_GEN_DIR}/qrhid3d12initparams_wrapper.cpp
+         ${QtGui_GEN_DIR}/qrhid3d12nativehandles_wrapper.cpp)
+elseif (ENABLE_MAC)
+    list(APPEND QtGui_SRC_RHI
+         ${QtGui_GEN_DIR}/qrhimetalinitparams_wrapper.cpp)
+endif()
+
 set(QtGui_SRC
+${QtGui_SRC_UNITY_EXCLUDED_SRC}
 ${QtGui_GEN_DIR}/qabstractfileiconprovider_wrapper.cpp
 ${QtGui_GEN_DIR}/qabstracttextdocumentlayout_paintcontext_wrapper.cpp
 ${QtGui_GEN_DIR}/qabstracttextdocumentlayout_selection_wrapper.cpp
@@ -14,6 +88,7 @@ ${QtGui_GEN_DIR}/qaccessibleactioninterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibleeditabletextinterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibleevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibleobject_wrapper.cpp
+${QtGui_GEN_DIR}/qaccessibleselectioninterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessiblestatechangeevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibletablecellinterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibletablemodelchangeevent_wrapper.cpp
@@ -31,6 +106,7 @@ ${QtGui_GEN_DIR}/qactiongroup_wrapper.cpp
 ${QtGui_GEN_DIR}/qbackingstore_wrapper.cpp
 ${QtGui_GEN_DIR}/qbitmap_wrapper.cpp
 ${QtGui_GEN_DIR}/qbrush_wrapper.cpp
+${QtGui_GEN_DIR}/qchildwindowevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qclipboard_wrapper.cpp
 ${QtGui_GEN_DIR}/qcloseevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qcolor_wrapper.cpp
@@ -54,6 +130,7 @@ ${QtGui_GEN_DIR}/qexposeevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qfileopenevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qfocusevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qfont_wrapper.cpp
+${QtGui_GEN_DIR}/qfont_tag_wrapper.cpp
 ${QtGui_GEN_DIR}/qfontdatabase_wrapper.cpp
 ${QtGui_GEN_DIR}/qfontinfo_wrapper.cpp
 ${QtGui_GEN_DIR}/qfontmetrics_wrapper.cpp
@@ -95,10 +172,8 @@ ${QtGui_GEN_DIR}/qmouseevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qmoveevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qmovie_wrapper.cpp
 ${QtGui_GEN_DIR}/qnativegestureevent_wrapper.cpp
+${QtGui_GEN_DIR}/qnativeinterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qoffscreensurface_wrapper.cpp
-${QtGui_GEN_DIR}/qopenglcontextgroup_wrapper.cpp
-${QtGui_GEN_DIR}/qopenglextrafunctions_wrapper.cpp
-${QtGui_GEN_DIR}/qopenglfunctions_wrapper.cpp
 ${QtGui_GEN_DIR}/qpagedpaintdevice_wrapper.cpp
 ${QtGui_GEN_DIR}/qpagelayout_wrapper.cpp
 ${QtGui_GEN_DIR}/qpageranges_wrapper.cpp
@@ -142,13 +217,13 @@ ${QtGui_GEN_DIR}/qsinglepointevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qstandarditem_wrapper.cpp
 ${QtGui_GEN_DIR}/qstandarditemmodel_wrapper.cpp
 ${QtGui_GEN_DIR}/qstatustipevent_wrapper.cpp
-${QtGui_GEN_DIR}/qopenglcontext_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessible_state_wrapper.cpp
 ${QtGui_GEN_DIR}/qaccessibleinterface_wrapper.cpp
 ${QtGui_GEN_DIR}/qscreen_wrapper.cpp
 ${QtGui_GEN_DIR}/qshortcut_wrapper.cpp
 ${QtGui_GEN_DIR}/qrasterwindow_wrapper.cpp
 ${QtGui_GEN_DIR}/qrawfont_wrapper.cpp
+${QtGui_SRC_RHI}
 ${QtGui_GEN_DIR}/qscrollevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qscrollprepareevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qstatictext_wrapper.cpp
@@ -157,7 +232,6 @@ ${QtGui_GEN_DIR}/qsurface_wrapper.cpp
 ${QtGui_GEN_DIR}/qsurfaceformat_wrapper.cpp
 ${QtGui_GEN_DIR}/qsyntaxhighlighter_wrapper.cpp
 ${QtGui_GEN_DIR}/qtabletevent_wrapper.cpp
-${QtGui_GEN_DIR}/qtextblock_iterator_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextblock_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextblockformat_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextblockgroup_wrapper.cpp
@@ -169,7 +243,6 @@ ${QtGui_GEN_DIR}/qtextdocumentfragment_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextdocumentwriter_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextformat_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextfragment_wrapper.cpp
-${QtGui_GEN_DIR}/qtextframe_iterator_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextframe_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextframeformat_wrapper.cpp
 ${QtGui_GEN_DIR}/qtextimageformat_wrapper.cpp
@@ -209,6 +282,46 @@ ${QtGui_GEN_DIR}/qwindowstatechangeevent_wrapper.cpp
 ${QtGui_GEN_DIR}/qtgui_module_wrapper.cpp
 )
 
+get_property(QtGui_enabled_features TARGET Qt${QT_MAJOR_VERSION}::Gui
+             PROPERTY QT_ENABLED_PUBLIC_FEATURES)
+
+if("xcb" IN_LIST QtGui_enabled_features)
+    list(APPEND QtGui_SRC
+         ${QtGui_GEN_DIR}/qnativeinterface_qx11application_wrapper.cpp)
+elseif(WIN32)
+    list(APPEND QtGui_SRC
+         ${QtGui_GEN_DIR}/qnativeinterface_qwindowsscreen_wrapper.cpp)
+endif()
+
+if("opengl" IN_LIST QtGui_enabled_features OR "opengles2" IN_LIST QtGui_enabled_features
+   OR "opengles3" IN_LIST QtGui_enabled_features)
+    list(APPEND QtGui_SRC
+         ${QtGui_GEN_DIR}/qopenglcontextgroup_wrapper.cpp
+         ${QtGui_GEN_DIR}/qopenglextrafunctions_wrapper.cpp
+         ${QtGui_GEN_DIR}/qopenglfunctions_wrapper.cpp
+         ${QtGui_GEN_DIR}/qopenglcontext_wrapper.cpp
+         ${QtGui_GEN_DIR}/qrhigles2initparams_wrapper.cpp
+         ${QtGui_GEN_DIR}/qrhigles2nativehandles_wrapper.cpp)
+else()
+    list(APPEND QtGui_DROPPED_ENTRIES
+         QOpenGLContext QOpenGLContextGroup QOpenGLPaintDevice
+         QOpenGLExtraFunctions QOpenGLFunctions
+         QRhiGles2InitParams QRhiGles2NativeHandles)
+endif()
+
+set(QtGui_private_include_dirs
+    ${Qt${QT_MAJOR_VERSION}Core_PRIVATE_INCLUDE_DIRS}
+    ${Qt${QT_MAJOR_VERSION}Gui_PRIVATE_INCLUDE_DIRS})
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
+    if (QT_FEATURE_opengles2)
+        # add openGL ES 2.0
+        find_package(GLESv2 REQUIRED)
+    else()
+        message(FATAL_ERROR "QtGui requires OpenGL ES 2.0 on Android")
+    endif()
+endif()
+
 configure_file("${QtGui_SOURCE_DIR}/QtGui_global.post.h.in"
                "${QtGui_BINARY_DIR}/QtGui_global.post.h" @ONLY)
 
@@ -217,6 +330,7 @@ set(QtGui_include_dirs  ${QtGui_SOURCE_DIR}
                         ${pyside6_SOURCE_DIR}
                         ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                         ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
+                        ${QtGui_private_include_dirs}
                         ${libpyside_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
                         )
@@ -232,7 +346,8 @@ create_pyside_module(NAME QtGui
                      SOURCES QtGui_SRC
                      STATIC_SOURCES QPYTEXTOBJECT_MOC
                      TYPESYSTEM_NAME ${QtGui_BINARY_DIR}/typesystem_gui.xml
-                     DROPPED_ENTRIES QtGui_DROPPED_ENTRIES)
+                     DROPPED_ENTRIES QtGui_DROPPED_ENTRIES
+                     ADDITIONAL_INCLUDE_DIRS QtGui_private_include_dirs)
 
 install(FILES ${pyside6_SOURCE_DIR}/qpytextobject.h
               ${pyside6_SOURCE_DIR}/qtguihelper.h
diff --git a/sources/pyside6/PySide6/QtGui/QtGui_global.post.h.in b/sources/pyside6/PySide6/QtGui/QtGui_global.post.h.in
index b5d457d95..e5a0eeb90 100644
--- a/sources/pyside6/PySide6/QtGui/QtGui_global.post.h.in
+++ b/sources/pyside6/PySide6/QtGui/QtGui_global.post.h.in
@@ -1,3 +1,6 @@
 #include "qpytextobject.h"  // PySide class
+#include <rhi/qrhi.h>
+#include <rhi/qrhi_platform.h>
+#include <rhi/qshader.h>
 #include <qtguihelper.h>
 void qt_set_sequence_auto_mnemonic(bool b);
diff --git a/sources/pyside6/PySide6/QtGui/typesystem_gui.xml b/sources/pyside6/PySide6/QtGui/typesystem_gui.xml
index 727bee0bf..858989404 100644
--- a/sources/pyside6/PySide6/QtGui/typesystem_gui.xml
+++ b/sources/pyside6/PySide6/QtGui/typesystem_gui.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtGui">
+<typesystem package="PySide6.QtGui"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <?if windows?>
     <load-typesystem name="QtGui/typesystem_gui_win.xml" generate="yes"/>
@@ -15,4 +16,5 @@
     <load-typesystem name="QtGui/typesystem_gui_x11.xml" generate="yes"/>
     <?endif?>
     <load-typesystem name="QtGui/typesystem_gui_common.xml" generate="yes"/>
+    <load-typesystem name="QtGui/typesystem_gui_rhi.xml" generate="yes"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtGui/typesystem_gui_common.xml b/sources/pyside6/PySide6/QtGui/typesystem_gui_common.xml
index ca7006325..feb2dc11b 100644
--- a/sources/pyside6/PySide6/QtGui/typesystem_gui_common.xml
+++ b/sources/pyside6/PySide6/QtGui/typesystem_gui_common.xml
@@ -42,32 +42,6 @@
   <function signature="qPixelFormatYuv(QPixelFormat::YUVLayout,uchar,QPixelFormat::AlphaUsage,QPixelFormat::AlphaPosition,QPixelFormat::AlphaPremultiplied,QPixelFormat::TypeInterpretation,QPixelFormat::ByteOrder)"/>
   <function signature="qt_set_sequence_auto_mnemonic(bool)"/>
 
-  <rejection class="*" function-name="qobject_interface_iid&lt;QStyleFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QAccessibleFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QInputContextFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QGraphicsItem*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QGraphicsLayout*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QAccessibleBridgeFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QImageIOHandlerFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QAccessibleInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QTextObjectInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QGraphicsLayoutItem*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QIconEngineFactoryInterface*&gt;"/>
-  <rejection class="*" function-name="qobject_interface_iid&lt;QPictureFormatInterface*&gt;"/>
-
-  <rejection class="*" function-name="qobject_cast&lt;QGraphicsLayout*&gt;"/>
-  <rejection class="*" function-name="qobject_cast&lt;QGraphicsItem*&gt;"/>
-  <rejection class="*" function-name="qobject_cast&lt;QGraphicsLayoutItem*&gt;"/>
-  <rejection class="*" function-name="qobject_cast&lt;QGraphicsLayoutItem*&gt;"/>
-
-  <rejection class="*" function-name="qGenericMatrixFromMatrix4x4"/>
-  <rejection class="*" function-name="qDrawBorderPixmap"/>
-  <rejection class="*" function-name="qDrawPixmaps"/>
-  <rejection class="*" function-name="qGenericMatrixToMatrix4x4"/>
-
-  <rejection class="*" function-name="d_func"/>
-  <rejection class="*" field-name="d_ptr"/>
-  <rejection class="*" field-name="d"/>
   <rejection class="^QOpenGL.*$" argument-type="^const GLboolean ?\*$"/>
   <rejection class="^QOpenGL.*$" argument-type="^GLchar\*$"/>
   <rejection class="^QOpenGL.*$" argument-type="^(const )?GLchar ?\*(const)?\*$"/>
@@ -86,8 +60,6 @@
   <rejection class="^QOpenGL.*$" argument-type="^(const )?QVector.D ?\*$"/>
   <rejection class="^QOpenGL.*$" argument-type="^(const )?void ?\*\*$"/>
 
-  <rejection class="QDrawBorderPixmap"/>
-
   <!--
     Event classes have a lot of non-documented protected fields, those fields
     are removed from PySide because they are Qt implementation details,
@@ -95,19 +67,12 @@
     -->
 
   <rejection class="^Q.*Event$" field-name="^m_.*$"/>
-  <rejection class="QEventPoint" field-name="^m_.*$"/>
 
-  <rejection class="QAbstractTextDocumentLayout::PaintContext" field-name="selections"/>
-  <rejection class="QBrush" function-name="cleanUp"/>
   <rejection class="QFont" enum-name="ResolveProperties"/>
-  <rejection class="QMotifStyle" field-name="focus"/>
-  <rejection class="QPictureIO" function-name="defineIOHandler"/>
   <rejection class="QPolygon" function-name="putPoints"/>
   <rejection class="QPolygon" function-name="setPoints"/>
   <rejection class="QPolygon" function-name="setPoint"/>
-  <rejection class="QPolygon" function-name="points"/>
   <rejection class="QPolygon" function-name="point"/>
-  <rejection class="QActionGroup" function-name="selected"/>
   <rejection class="QPaintEngine" function-name="fix_neg_rect"/>
 
   <inject-code class="native" position="beginning" file="../glue/qtgui.cpp"
@@ -157,21 +122,31 @@
   <object-type name="QAccessibleEditableTextInterface"/>
   <object-type name="QAccessibleInterface"/>
   <object-type name="QAccessibleObject" qt-register-metatype="base"/>
+  <object-type name="QAccessibleSelectionInterface" since="6.7"/>
   <object-type name="QAccessibleTableCellInterface"/>
   <object-type name="QAccessibleTextInterface"/>
   <object-type name="QAccessibleValueInterface"/>
 
-  <object-type name="QAccessibleEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::InvalidEvent"/>
-  <object-type name="QAccessibleStateChangeEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::StateChanged"/>
-  <object-type name="QAccessibleTableModelChangeEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TableModelChanged">
+  <object-type name="QAccessibleEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::InvalidEvent"/>
+  <object-type name="QAccessibleStateChangeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::StateChanged"/>
+  <object-type name="QAccessibleTableModelChangeEvent"
+                    polymorphic-id-expression="%B-&gt;type() == QAccessible::TableModelChanged">
       <enum-type name="ModelChangeType"/>
   </object-type>
-  <object-type name="QAccessibleTextCursorEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TextCaretMoved"/>
-  <object-type name="QAccessibleTextInsertEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TextInserted"/>
-  <object-type name="QAccessibleTextRemoveEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TextRemoved"/>
-  <object-type name="QAccessibleTextSelectionEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TextSelectionChanged"/>
-  <object-type name="QAccessibleTextUpdateEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::TextUpdated"/>
-  <object-type name="QAccessibleValueChangeEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QAccessible::ValueChanged"/>
+  <object-type name="QAccessibleTextCursorEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::TextCaretMoved"/>
+  <object-type name="QAccessibleTextInsertEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::TextInserted"/>
+  <object-type name="QAccessibleTextRemoveEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::TextRemoved"/>
+  <object-type name="QAccessibleTextSelectionEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::TextSelectionChanged"/>
+  <object-type name="QAccessibleTextUpdateEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::TextUpdated"/>
+  <object-type name="QAccessibleValueChangeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QAccessible::ValueChanged"/>
 
   <object-type name="QAction">
     <enum-type name="ActionEvent"/>
@@ -261,7 +236,7 @@
       <modify-argument index="1">
         <remove-argument/>
       </modify-argument>
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[PySide6.QtGui.QTransform, bool]">
         <replace-type modified-type="PyTuple"/>
       </modify-argument>
       <inject-code class="target" position="beginning">
@@ -515,6 +490,7 @@
   <value-type name="QIcon" >
     <enum-type name="Mode"/>
     <enum-type name="State"/>
+    <enum-type name="ThemeIcon" since="6.7"/>
     <modify-function signature="QIcon(QIconEngine*)">
       <modify-argument index="1">
         <no-null-pointer/>
@@ -635,21 +611,22 @@
     </modify-function>
   </value-type>
 
-  <value-type name="QConicalGradient" polymorphic-id-expression="%1-&gt;type() == QGradient::ConicalGradient"/>
+  <value-type name="QConicalGradient" polymorphic-id-expression="%B-&gt;type() == QGradient::ConicalGradient"/>
   <value-type name="QFontInfo"/>
-  <value-type name="QRadialGradient" polymorphic-id-expression="%1-&gt;type() == QGradient::RadialGradient"/>
+  <value-type name="QRadialGradient" polymorphic-id-expression="%B-&gt;type() == QGradient::RadialGradient"/>
   <value-type name="QFont" >
     <enum-type name="Capitalization"/>
     <enum-type name="SpacingType"/>
     <enum-type name="Stretch" python-type="IntEnum"/>
     <enum-type name="Style"/>
     <enum-type name="StyleHint"/>
-    <enum-type name="StyleStrategy"/>
+    <enum-type name="StyleStrategy" python-type="Flag"/>
     <enum-type name="Weight" python-type="IntEnum"/>
     <enum-type name="HintingPreference" since="4.8" revision="4800"/>
     <extra-includes>
       <include file-name="QStringList" location="global"/>
     </extra-includes>
+    <value-type name="Tag" since="6.7"/>
     <!-- PYSIDE-1685: QFont(QString) should be checked first, else it will be interpreted as sequence -->
     <modify-function signature="QFont(const QString&amp;,int,int, bool)" overload-number="0"/>
     <modify-function signature="QFont(const QStringList &amp;,int,int, bool)" overload-number="1"/>
@@ -705,7 +682,7 @@
         </inject-code>
     </modify-function>
 
-    <modify-function signature="QImage(const QString&amp;, const char *)">
+    <modify-function signature="QImage(const QString&amp;, const char *)" allow-thread="yes">
         <modify-argument index="1"><replace-type modified-type="PyPathLike"/></modify-argument>
         <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qfile-path-1"/>
     </modify-function>
@@ -1129,14 +1106,14 @@
       <inject-code class="target" position="beginning" file="../glue/qtgui.cpp" snippet="qfontmetrics-size"/>
     </modify-function>
   </value-type>
-  <value-type name="QGradient" polymorphic-id-expression="%1-&gt;type() == QGradient::NoGradient">
+  <value-type name="QGradient" polymorphic-id-expression="%B-&gt;type() == QGradient::NoGradient">
       <enum-type name="CoordinateMode"/>
       <enum-type name="InterpolationMode"/>
       <enum-type name="Preset"/>
       <enum-type name="Spread"/>
       <enum-type name="Type"/>
   </value-type>
-  <value-type name="QLinearGradient" polymorphic-id-expression="%1-&gt;type() == QGradient::LinearGradient"/>
+  <value-type name="QLinearGradient" polymorphic-id-expression="%B-&gt;type() == QGradient::LinearGradient"/>
   <object-type name="QPaintDevice">
       <enum-type name="PaintDeviceMetric"/>
   </object-type>
@@ -1282,9 +1259,6 @@
         <define-ownership class="target" owner="target"/>
       </modify-argument>
     </modify-function>
-
-    <!-- ??? -->
-    <modify-function signature="operator&lt;(QStandardItem)const" remove="all"/>
   </object-type>
   <object-type name="QSyntaxHighlighter">
     <modify-function signature="setCurrentBlockUserData(QTextBlockUserData*)">
@@ -1293,7 +1267,7 @@
       </modify-argument>
     </modify-function>
     <modify-function signature="setDocument(QTextDocument*)">
-      <modify-argument index="1">
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtGui.QTextDocument]">
         <parent index="this" action="add"/>
       </modify-argument>
     </modify-function>
@@ -1340,37 +1314,38 @@
     </modify-function>
   </object-type>
 
-  <object-type name="QActionEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ActionAdded || %1-&gt;type() == QEvent::ActionRemoved || %1-&gt;type() == QEvent::ActionChanged"/>
-  <object-type name="QCloseEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Close"/>
-  <object-type name="QContextMenuEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ContextMenu">
+  <object-type name="QActionEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ActionAdded || %B-&gt;type() == QEvent::ActionRemoved || %B-&gt;type() == QEvent::ActionChanged"/>
+  <object-type name="QCloseEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Close"/>
+  <object-type name="QContextMenuEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::ContextMenu">
       <enum-type name="Reason"/>
   </object-type>
 
   <value-type name="QEventPoint">
       <enum-type name="State"/>
   </value-type>
-  <object-type name="QDragEnterEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DragEnter">
+  <object-type name="QDragEnterEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::DragEnter">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QDragLeaveEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DragLeave">
+  <object-type name="QDragLeaveEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::DragLeave">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QDragMoveEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DragMove">
+  <object-type name="QDragMoveEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::DragMove">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QDropEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Drop">
+  <object-type name="QDropEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Drop">
     <modify-function signature="source()const">
       <modify-argument index="return">
         <define-ownership class="target" owner="default"/>
@@ -1382,22 +1357,29 @@
         </inject-code>
     </add-function>
   </object-type>
-  <object-type name="QEnterEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::Enter"/>
-  <object-type name="QExposeEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Expose"/>
-  <object-type name="QFileOpenEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::FileOpen"/>
-  <object-type name="QFocusEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::FocusIn || %1-&gt;type() == QEvent::FocusOut">
+  <object-type name="QChildWindowEvent" since="6.7"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ChildWindowAdded || %B-&gt;type() == QEvent::ChildWindowRemoved"/>
+  <object-type name="QEnterEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::Enter"/>
+  <object-type name="QExposeEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Expose"/>
+  <object-type name="QFileOpenEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::FileOpen"/>
+  <object-type name="QFocusEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::FocusIn || %B-&gt;type() == QEvent::FocusOut">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QHelpEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::ToolTip || %1-&gt;type() == QEvent::WhatsThis"/>
-  <object-type name="QHideEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::Hide"/>
-  <object-type name="QHoverEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::HoverEnter || %1-&gt;type() == QEvent::HoverLeave || %1-&gt;type() == QEvent::HoverMove"/>
-  <object-type name="QIconDragEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::IconDrag"/>
+  <object-type name="QHelpEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ToolTip || %B-&gt;type() == QEvent::WhatsThis"/>
+  <object-type name="QHideEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Hide"/>
+  <object-type name="QHoverEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::HoverEnter || %B-&gt;type() == QEvent::HoverLeave || %B-&gt;type() == QEvent::HoverMove"/>
+  <object-type name="QIconDragEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::IconDrag"/>
 
-  <object-type name="QInputMethodEvent" copyable="no" polymorphic-id-expression="%1-&gt;type() == QEvent::InputMethod">
+  <object-type name="QInputMethodEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::InputMethod">
     <!-- only declare this if ndef QT_NO_INPUTMETHOD -->
     <enum-type name="AttributeType"/>
     <value-type name="Attribute">
@@ -1410,60 +1392,68 @@
     </add-function>
     <!-- endif ndef QT_NO_INPUTMETHOD -->
   </object-type>
-  <object-type name="QInputMethodQueryEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::InputMethodQuery"/>
+  <object-type name="QInputMethodQueryEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::InputMethodQuery"/>
 
-  <object-type name="QMoveEvent" copyable = "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Move">
+  <object-type name="QMoveEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Move">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QNativeGestureEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::NativeGesture"/>
-  <object-type name="QPlatformSurfaceEvent" copyable="false"
-               polymorphic-id-expression="%1-&gt;type() == QEvent::PlatformSurface">
+  <object-type name="QNativeGestureEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::NativeGesture"/>
+  <object-type name="QPlatformSurfaceEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::PlatformSurface">
      <enum-type name="SurfaceEventType"/>
   </object-type>
-  <object-type name="QResizeEvent" copyable = "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Resize">
+  <object-type name="QResizeEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Resize">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QShortcutEvent" copyable = "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Shortcut">
+  <object-type name="QShortcutEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::Shortcut">
   </object-type>
-  <object-type name="QShowEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Show"/>
-  <object-type name="QSinglePointEvent" copyable="false"/>
-  <object-type name="QStatusTipEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::StatusTip"/>
-  <object-type name="QTabletEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::TabletMove || %1-&gt;type() == QEvent::TabletPress || %1-&gt;type() == QEvent::TabletRelease">
+  <object-type name="QShowEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::Show"/>
+  <object-type name="QSinglePointEvent"/>
+  <object-type name="QStatusTipEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::StatusTip"/>
+  <object-type name="QTabletEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::TabletMove || %B-&gt;type() == QEvent::TabletPress || %B-&gt;type() == QEvent::TabletRelease">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QToolBarChangeEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ToolBarChange"/>
-  <object-type name="QWhatsThisClickedEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::WhatsThisClicked"/>
-  <object-type name="QWheelEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Wheel">
+  <object-type name="QToolBarChangeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ToolBarChange"/>
+  <object-type name="QWhatsThisClickedEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::WhatsThisClicked"/>
+  <object-type name="QWheelEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Wheel">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <!-- Qt5.5: suppress this nameless enum -->
-  <suppress-warning text="enum 'QWheelEvent::DefaultDeltasPerStep' does not have a type entry or is not an enum"/>
 
-  <object-type name="QWindowStateChangeEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::WindowStateChange">
+  <object-type name="QWindowStateChangeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::WindowStateChange">
       <add-function signature="__repr__" return-type="PyObject">
           <inject-code class="target" position="beginning">
               <insert-template name="repr_qdebug_gui"/>
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QInputEvent" copyable="false"/>
-  <object-type name="QKeyEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::KeyPress || %1-&gt;type() == QEvent::KeyRelease || %1-&gt;type() == QEvent::ShortcutOverride">
+  <object-type name="QInputEvent"/>
+  <object-type name="QKeyEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::KeyPress || %B-&gt;type() == QEvent::KeyRelease || %B-&gt;type() == QEvent::ShortcutOverride">
       <add-function signature="operator!=(QKeySequence::StandardKey)">
           <inject-code class="target" file="../glue/qtgui.cpp" snippet="qkeyevent-operatornotequal"/>
       </add-function>
@@ -1473,8 +1463,8 @@
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QMouseEvent" copyable= "false"
-               polymorphic-id-expression="%1-&gt;type() == QEvent::MouseButtonDblClick || %1-&gt;type() == QEvent::MouseButtonPress || %1-&gt;type() == QEvent::MouseButtonRelease || %1-&gt;type() == QEvent::MouseMove">
+  <object-type name="QMouseEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::MouseButtonDblClick || %B-&gt;type() == QEvent::MouseButtonPress || %B-&gt;type() == QEvent::MouseButtonRelease || %B-&gt;type() == QEvent::MouseMove">
       <modify-function signature="globalPos() const" deprecated="yes"/>
       <modify-function signature="localPos() const" deprecated="yes"/>
       <modify-function signature="pos() const" deprecated="yes"/>
@@ -1490,8 +1480,8 @@
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QPaintEvent" copyable= "false" polymorphic-id-expression="%1-&gt;type() == QEvent::Paint"/>
-  <object-type name="QScrollEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::Scroll">
+  <object-type name="QPaintEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Paint"/>
+  <object-type name="QScrollEvent" polymorphic-id-expression="%B-&gt;type() == QEvent::Scroll">
       <enum-type name="ScrollState"/>
   </object-type>
   <object-type name="QPointerEvent" copyable= "false">
@@ -1501,7 +1491,8 @@
           </inject-code>
       </add-function>
   </object-type>
-  <object-type name="QScrollPrepareEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::ScrollPrepare"/>
+  <object-type name="QScrollPrepareEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::ScrollPrepare"/>
 
   <object-type name="QTextFrame" >
     <extra-includes>
@@ -1615,7 +1606,7 @@
     </add-function>
   </object-type>
 
-  <object-type name="QStandardItemModel" polymorphic-id-expression="qobject_cast&lt;QStandardItemModel*&gt;(%1)">
+  <object-type name="QStandardItemModel" polymorphic-id-expression="qobject_cast&lt;QStandardItemModel*&gt;(%B)">
     <extra-includes>
       <include file-name="QStringList" location="global"/>
       <include file-name="QSize" location="global"/>
@@ -1759,6 +1750,18 @@
       <include file-name="QPixmap" location="global"/>
     </extra-includes>
     <enum-type name="Mode"/>
+    <modify-function signature="setPixmap(const QPixmap&amp;, QClipboard::Mode)">
+      <modify-argument index="1" pyi-type="PySide6.QtGui.QPixmap"/>
+    </modify-function>
+    <add-function signature="setPixmap(PyPathLike@path@)">
+      <inject-code file="../glue/qtgui.cpp" snippet="qclipboard-setpixmap"/>
+    </add-function>
+    <modify-function signature="setImage(const QImage&amp;, QClipboard::Mode)">
+      <modify-argument index="1" pyi-type="PySide6.QtGui.QImage"/>
+    </modify-function>
+    <add-function signature="setImage(PyPathLike@path@)">
+      <inject-code file="../glue/qtgui.cpp" snippet="qclipboard-setimage"/>
+    </add-function>
     <modify-function signature="setMimeData(QMimeData*,QClipboard::Mode)" allow-thread="yes">
       <modify-argument index="1">
         <!-- TODO: maybe this is not the best solution -->
@@ -1766,7 +1769,7 @@
       </modify-argument>
     </modify-function>
     <modify-function signature="text(QString&amp;,QClipboard::Mode)const">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[str, PySide6.QtGui.QClipboard.Mode]">
         <replace-type modified-type="(retval, subtype)"/>
       </modify-argument>
       <inject-code class="target" position="end" file="../glue/qtgui.cpp" snippet="qclipboard-text"/>
@@ -1787,6 +1790,7 @@
       <include file-name="QTextOption" location="global"/>
     </extra-includes>
     <enum-type name="CursorMode"/>
+    <enum-type name="GlyphRunRetrievalFlag" flags="GlyphRunRetrievalFlags" since="6.5"/>
     <value-type name="FormatRange">
       <include file-name="QTextLayout" location="global"/>
     </value-type>
@@ -1883,11 +1887,9 @@
     </add-function>
     <!-- ### Overloads using QList<T> does the job of these methods -->
     <modify-function signature="drawLines(const QLine*,int)" remove="all"/>
-    <modify-function signature="drawLines(const QLineF*,int)" remove="all"/>
     <modify-function signature="drawLines(const QPoint*,int)" remove="all"/>
     <modify-function signature="drawLines(const QPointF*,int)" remove="all"/>
     <modify-function signature="drawRects(const QRect*,int)" remove="all"/>
-    <modify-function signature="drawRects(const QRectF*,int)" remove="all"/>
     <!-- ### -->
     <!-- PYSIDE-1540: Preferably use the QPolygon overloads first to avoid
          a costly sequence type check on QPolygon. -->
@@ -1897,7 +1899,6 @@
             <insert-template name="qpainter_drawlist"/>
         </inject-code>
     </add-function>
-    <modify-function signature="drawPoints(const QPointF*,int)" remove="all"/>
     <add-function signature="drawPoints(QList&lt;QPointF>)" overload-number="3">
         <inject-code>
             <insert-template name="qpainter_drawlist"/>
@@ -1966,6 +1967,9 @@
       <inject-code class="target" position="beginning">
         <insert-template name="fix_args,QRectF*"/>
       </inject-code>
+      <inject-documentation format="target" mode="prepend">
+      The function returns the bounding rectangle enclosing the whole text.
+      </inject-documentation>
     </modify-function>
     <modify-function signature="drawText(QRect,int,QString,QRect*)">
       <modify-argument index="4">
@@ -1978,6 +1982,9 @@
       <inject-code class="target" position="beginning">
         <insert-template name="fix_args,QRect*"/>
       </inject-code>
+      <inject-documentation format="target" mode="prepend">
+      The function returns the bounding rectangle enclosing the whole text.
+      </inject-documentation>
     </modify-function>
     <modify-function signature="drawText(int,int,int,int,int,QString,QRect*)">
       <modify-argument index="7">
@@ -1987,6 +1994,9 @@
       <inject-code class="target" position="beginning">
         <insert-template name="fix_args,QRect*"/>
       </inject-code>
+      <inject-documentation format="target" mode="prepend">
+      The function returns the bounding rectangle enclosing the whole text.
+      </inject-documentation>
     </modify-function>
     <add-function signature="__enter__()" return-type="QPainter">
         <inject-code file="../glue/qtgui.cpp" snippet="qpainter-enter"/>
@@ -2366,7 +2376,7 @@
       <modify-argument index="1">
         <remove-argument/>
       </modify-argument>
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[PySide6.QtGui.QMatrix4x4, bool]">
         <replace-type modified-type="PyTuple"/>
       </modify-argument>
       <inject-code class="target" position="beginning">
@@ -2406,10 +2416,27 @@
         </inject-code>
     </add-function>
 
-    <!-- Qt5.5: XXX support the output variables! For now, I just suppressed the new methods. -->
-    <modify-function signature="getAxisAndAngle(float*,float*,float*,float*)const"/>
-    <modify-function signature="getAxisAndAngle(QVector3D*,float*)const"/>
-    <modify-function signature="getEulerAngles(float*,float*,float*)const"/>
+    <!-- There can be only one return type.  -->
+    <modify-function signature="getAxisAndAngle(float*,float*,float*,float*)const" remove="all"/>
+    <modify-function signature="getAxisAndAngle(QVector3D*,float*)const">
+        <modify-argument index="return" pyi-type="Tuple[PySide6.QtGui.QVector3D, float]">
+            <replace-type modified-type="(QVector3D, float)"/>
+        </modify-argument>
+        <modify-argument index="1"><remove-argument/></modify-argument>
+        <modify-argument index="2"><remove-argument/></modify-argument>
+        <inject-code class="target" position="beginning"
+                     file="../glue/qtgui.cpp" snippet="qquaternion-getaxisandangle-vector3d-float"/>
+    </modify-function>
+    <modify-function signature="getEulerAngles(float*,float*,float*)const">
+        <modify-argument index="return" pyi-type="Tuple[float, float, float]">
+            <replace-type modified-type="(float, float, float)"/>
+        </modify-argument>
+        <modify-argument index="1"><remove-argument/></modify-argument>
+        <modify-argument index="2"><remove-argument/></modify-argument>
+        <modify-argument index="3"><remove-argument/></modify-argument>
+        <inject-code class="target" position="beginning"
+                     file="../glue/qtgui.cpp" snippet="qquaternion-geteulerangles"/>
+    </modify-function>
   </value-type>
 
   <object-type name="QTouchEvent" since="4.6">
@@ -2518,18 +2545,6 @@
     </add-function>
   </value-type>
 
-  <suppress-warning text="template baseclass 'QListSpecialMethods&lt;T&gt;' of 'QList' is not known"/>
-  <suppress-warning text="template baseclass 'QGenericMatrix&lt;float&gt;' of '*' is not known"/>
-
-  <!-- Qt5: note: the unnamed enum cannot be rejected by
-    <rejection class="QMatrix4x4" enum-name="enum_1"/>
-    Instead, we have to suppress the warning. Why that?
-
-    Compare also the note at the beginning of typesystem_widgets_common.xml .
-    This seems to be a related problem with unnamed structures in shiboken.
-  -->
-  <suppress-warning text="enum 'QMatrix4x4::enum_1' is specified in typesystem, but not declared"/>
-
   <object-type name="QSessionManager">
     <extra-includes>
     </extra-includes>
@@ -2537,9 +2552,6 @@
      <!-- ### -->
   </object-type>
 
-  <!-- This enum is present on QtCore -->
-  <suppress-warning text="enum 'QCoreApplication::ApplicationFlags' is specified in typesystem, but not declared"/>
-
   <!-- Qt5: here the new QWindow stuff and what it pulls in -->
   <object-type name="QBackingStore"/>
   <object-type name="QSurface">
@@ -2561,7 +2573,7 @@
     </extra-includes>
   </primitive-type>
 
-  <object-type name="QWindow" delete-in-main-thread="true">
+  <object-type name="QWindow" delete-in-main-thread="true" polymorphic-base="true">
     <enum-type name="AncestorMode"/>
     <enum-type name="Visibility"/>
     <modify-function signature="raise()" rename="raise_"/>
@@ -2621,6 +2633,13 @@
     <add-function signature="exec_()" return-type="int">
         <inject-code file="../glue/qtgui.cpp" snippet="qguiapplication-exec"/>
     </add-function>
+    <add-function signature="nativeInterface()const" return-type="PyObject">
+        <modify-argument index="return"> <!-- Suppress return value heuristics -->
+            <define-ownership class="target" owner="default"/>
+        </modify-argument>
+        <inject-code class="target" position="beginning" file="../glue/qtgui.cpp"
+                     snippet="qguiapplication-nativeInterface"/>
+    </add-function>
     <modify-function signature="setOverrideCursor(const QCursor&amp;)">
         <modify-argument index="return" pyi-type="PyObject">
             <replace-type modified-type="QtGuiHelper::QOverrideCursorGuard*"/>
@@ -2630,6 +2649,31 @@
     </modify-function>
   </object-type>
 
+  <namespace-type name="QNativeInterface" private="yes" since="6.7">
+      <object-type name="QX11Application" private="yes" disable-wrapper="yes"
+                   force-abstract="yes">
+          <configuration condition="QT_CONFIG(xcb)"/>
+          <modify-function signature="display()const">
+              <modify-argument index="return">
+                  <replace-type modified-type="int"/>
+              </modify-argument>
+              <inject-code class="target" position="end" file="../glue/qtgui.cpp"
+                           snippet="qx11application-resource-ptr"/>
+          </modify-function>
+          <modify-function signature="connection()const">
+              <modify-argument index="return">
+                  <replace-type modified-type="int"/>
+              </modify-argument>
+              <inject-code class="target" position="end" file="../glue/qtgui.cpp"
+                           snippet="qx11application-resource-ptr"/>
+          </modify-function>
+      </object-type>
+      <object-type name="QWindowsScreen" private="yes" disable-wrapper="yes"
+                   force-abstract="yes">
+          <configuration condition="#ifdef Q_OS_WIN"/>
+      </object-type>
+  </namespace-type>
+
   <object-type name="QOpenGLContext">
     <enum-type name="OpenGLModuleType"/>
   </object-type>
@@ -3077,6 +3121,13 @@
         </modify-argument>
         <inject-code file="../glue/qtgui.cpp" snippet="qscreen-grabWindow"/>
       </modify-function>
+      <add-function signature="nativeInterface()const" return-type="PyObject">
+          <modify-argument index="return"> <!-- Suppress return value heuristics -->
+              <define-ownership class="target" owner="default"/>
+          </modify-argument>
+          <inject-code class="target" position="beginning" file="../glue/qtgui.cpp"
+                       snippet="qscreen-nativeInterface"/>
+      </add-function>
   </object-type>
   <object-type name="QStyleHints"/>
 
@@ -3117,7 +3168,7 @@
 
   <namespace-type name="QtGuiHelper" visible="no">
       <object-type name="QOverrideCursorGuard" copyable="no">
-      <add-function signature="__enter__()" return-type="QOverrideCursorGuard">
+      <add-function signature="__enter__()" return-type="QtGuiHelper::QOverrideCursorGuard">
           <inject-code file="../glue/qtcore.cpp" snippet="default-enter"/>
       </add-function>
       <add-function signature="__exit__(PyObject*,PyObject*,PyObject*)">
@@ -3126,4 +3177,6 @@
       </object-type>
   </namespace-type>
 
+  <opaque-container name="QList" opaque-containers="QVector2D:QVector2DList;QVector3D:QVector3DList;QVector4D:QVector4DList"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtGui/typesystem_gui_rhi.xml b/sources/pyside6/PySide6/QtGui/typesystem_gui_rhi.xml
new file mode 100644
index 000000000..22ab56e20
--- /dev/null
+++ b/sources/pyside6/PySide6/QtGui/typesystem_gui_rhi.xml
@@ -0,0 +1,176 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+-->
+<typesystem package="PySide6.QtGui">
+  <value-type name="QRhiDepthStencilClearValue" since="6.6" private="yes"/>
+  <value-type name="QRhiViewport" since="6.6" private="yes"/>
+  <value-type name="QRhiScissor" since="6.6" private="yes"/>
+  <value-type name="QRhiVertexInputBinding" since="6.6" private="yes">
+      <enum-type name="Classification"/>
+  </value-type>
+  <value-type name="QRhiVertexInputAttribute" since="6.6" private="yes">
+      <enum-type name="Format"/>
+  </value-type>
+  <value-type name="QRhiVertexInputLayout" since="6.6" private="yes">
+      <add-function signature="setBindings(QList&lt;QRhiVertexInputBinding&gt;@bindings@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp" snippet="qrhi-initializer-list"/>
+      </add-function>
+      <add-function signature="setAttributes(QList&lt;QRhiVertexInputAttribute&gt;@attributes@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp" snippet="qrhi-initializer-list"/>
+      </add-function>
+  </value-type>
+  <value-type name="QRhiShaderStage" since="6.6" private="yes">
+      <enum-type name="Type"/>
+  </value-type>
+  <value-type name="QRhiShaderResourceBinding" since="6.6" private="yes">
+      <enum-type name="Type"/>
+      <enum-type name="StageFlag" flags="StageFlags"/>
+      <value-type name="TextureAndSampler" private="yes"/>
+      <value-type name="Data" private="yes">
+          <value-type name="StorageImageData" private="yes"/>
+          <value-type name="StorageBufferData" private="yes"/>
+      </value-type>
+  </value-type>
+  <value-type name="QRhiColorAttachment" since="6.6" private="yes"/>
+  <value-type name="QRhiTextureRenderTargetDescription" since="6.6" private="yes">
+      <add-function signature="setColorAttachments(QList&lt;QRhiColorAttachment&gt;@bcolor_attachments@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp" snippet="qrhi-initializer-list"/>
+      </add-function>
+  </value-type>
+  <value-type name="QRhiTextureSubresourceUploadDescription" since="6.6" private="yes"/>
+  <value-type name="QRhiTextureUploadEntry" since="6.6" private="yes"/>
+  <value-type name="QRhiTextureUploadDescription" since="6.6" private="yes">
+      <add-function signature="setEntries(QList&lt;QRhiTextureUploadEntry&gt;@entries@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp" snippet="qrhi-initializer-list"/>
+      </add-function>
+  </value-type>
+  <value-type name="QRhiTextureCopyDescription" since="6.6" private="yes"/>
+  <value-type name="QRhiReadbackDescription" since="6.6" private="yes"/>
+  <value-type name="QRhiNativeHandles" since="6.6" private="yes"/>
+  <object-type name="QRhiResource" since="6.6" private="yes">
+      <enum-type name="Type"/>
+  </object-type>
+  <object-type name="QRhiBuffer" since="6.6" private="yes">
+      <enum-type name="Type"/>
+      <enum-type name="UsageFlag" flags="UsageFlags"/>
+      <!-- const char * mixup -->
+      <modify-function signature="beginFullDynamicBufferUpdateForCurrentFrame()" remove="all"/>
+  </object-type>
+  <object-type name="QRhiTexture" since="6.6" private="yes">
+      <enum-type name="Format"/>
+      <enum-type name="Flag" flags="Flags"/>
+  </object-type>
+  <object-type name="QRhiSampler" since="6.6" private="yes">
+      <enum-type name="Filter"/>
+      <enum-type name="AddressMode"/>
+      <enum-type name="CompareOp"/>
+  </object-type>
+  <object-type name="QRhiRenderBuffer" since="6.6" private="yes">
+      <enum-type name="Type"/>
+      <enum-type name="Flag" flags="Flags"/>
+  </object-type>
+  <object-type name="QRhiRenderPassDescriptor" since="6.6" private="yes"/>
+  <object-type name="QRhiRenderTarget" since="6.6" private="yes"/>
+  <object-type name="QRhiSwapChainRenderTarget" since="6.6" private="yes"/>
+  <object-type name="QRhiTextureRenderTarget" since="6.6" private="yes">
+      <enum-type name="Flag" flags="Flags"/>
+  </object-type>
+  <object-type name="QRhiShaderResourceBindings" since="6.6" private="yes">
+      <enum-type name="UpdateFlag" flags="UpdateFlags"/>
+      <modify-field name="BINDING_PREALLOC" remove="true"/>
+      <add-function signature="setBindings(QList&lt;QRhiShaderResourceBinding&gt;@bindings@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp" snippet="qrhi-initializer-list"/>
+      </add-function>
+  </object-type>
+  <object-type name="QRhiGraphicsPipeline" since="6.6" private="yes">
+      <enum-type name="Flag" flags="Flags"/>
+      <enum-type name="BlendOp"/>
+      <enum-type name="Topology"/>
+      <enum-type name="CullMode"/>
+      <enum-type name="FrontFace"/>
+      <enum-type name="ColorMaskComponent" flags="ColorMask"/>
+      <enum-type name="BlendFactor"/>
+      <enum-type name="CompareOp"/>
+      <enum-type name="StencilOp"/>
+      <enum-type name="PolygonMode"/>
+      <value-type name="StencilOpState" private="yes"/>
+      <value-type name="TargetBlend" private="yes"/>
+      <add-function signature="setShaderStages(QList&lt;QRhiShaderStage&gt;@stages@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp"
+                       snippet="qrhi-initializer-list"/>
+      </add-function>
+      <add-function signature="setTargetBlends(QList&lt;QRhiGraphicsPipeline::TargetBlend&gt;@blends@)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp"
+                       snippet="qrhi-initializer-list"/>
+      </add-function>
+  </object-type>
+  <object-type name="QRhiSwapChain" since="6.6" private="yes">
+      <enum-type name="Flag" flags="Flags"/>
+      <enum-type name="Format"/>
+      <enum-type name="StereoTargetBuffer"/>
+  </object-type>
+  <object-type name="QRhiComputePipeline" since="6.6" private="yes">
+      <enum-type name="Flag" flags="Flags"/>
+  </object-type>
+  <object-type name="QRhiCommandBuffer" since="6.6" private="yes">
+      <enum-type name="BeginPassFlag" flags="BeginPassFlags"/>
+      <enum-type name="IndexFormat"/>
+      <modify-function signature="^setVertexInput\(.*\)$" remove="all"/>
+      <add-function signature="setVertexInput(int@startBinding@,QList&lt;std::pair&lt;QRhiBuffer*,quint32&gt;&gt;@bindings@,QRhiBuffer*@indexBuf@=nullptr,quint32@indexOffset@=0,QRhiCommandBuffer::IndexFormat @indexFormat@ = QRhiCommandBuffer::IndexUInt16)">
+          <inject-code class="target" position="beginning"
+                       file="../glue/qtgui.cpp"
+                       snippet="qrhi-commandbuffer-setvertexinput"/>
+      </add-function>
+  </object-type>
+  <value-type name="QRhiReadbackResult" since="6.6" private="yes"/>
+  <object-type name="QRhiResourceUpdateBatch" since="6.6" private="yes"/>
+  <value-type name="QRhiDriverInfo" since="6.6" private="yes">
+      <enum-type name="DeviceType"/>
+  </value-type>
+  <value-type name="QRhiStats" since="6.6" private="yes"/>
+  <value-type name="QRhiInitParams" since="6.6" private="yes"/>
+  <value-type name="QRhiNullInitParams" since="6.6" private="yes"/>
+  <value-type name="QRhiGles2InitParams" since="6.6" private="yes"/>
+  <value-type name="QRhiGles2NativeHandles" since="6.6" private="yes"/>
+  <?if windows?>
+  <value-type name="QRhiD3D11InitParams" since="6.6" private="yes"/>
+  <value-type name="QRhiD3D11NativeHandles" since="6.6" private="yes"/>
+  <value-type name="QRhiD3D12InitParams" since="6.6" private="yes"/>
+  <value-type name="QRhiD3D12NativeHandles" since="6.6" private="yes"/>
+  <?endif?>
+  <?if darwin?>
+  <value-type name="QRhiMetalInitParams" since="6.6" private="yes"/>
+  <?endif?>
+
+  <object-type name="QRhi" since="6.6" private="yes">
+      <enum-type name="Flag" flags="Flags"/>
+      <enum-type name="Implementation"/>
+      <enum-type name="FrameOpResult"/>
+      <enum-type name="Feature"/>
+      <enum-type name="BeginFrameFlag" flags="BeginFrameFlags"/>
+      <enum-type name="EndFrameFlag" flags="EndFrameFlags"/>
+      <enum-type name="ResourceLimit"/>
+  </object-type>
+
+  <value-type name="QShader" since="6.6" private="yes">
+      <enum-type name="Stage"/>
+      <enum-type name="Source"/>
+      <enum-type name="Variant"/>
+      <enum-type name="SerializedFormatVersion"/>
+  </value-type>
+  <value-type name="QShaderCode" since="6.6" private="yes"/>
+  <value-type name="QShaderKey" since="6.6" private="yes"/>
+  <value-type name="QShaderVersion" since="6.6" private="yes">
+    <enum-type name="Flag" flags="Flags"/>
+  </value-type>
+
+</typesystem>
diff --git a/sources/pyside6/PySide6/QtGui/typesystem_gui_win.xml b/sources/pyside6/PySide6/QtGui/typesystem_gui_win.xml
index 89e3a33fe..b3b8a75b6 100644
--- a/sources/pyside6/PySide6/QtGui/typesystem_gui_win.xml
+++ b/sources/pyside6/PySide6/QtGui/typesystem_gui_win.xml
@@ -22,6 +22,15 @@
             </target-to-native>
         </conversion-rule>
     </primitive-type>
+    <primitive-type name="HMONITOR" target-lang-api-name="PyLong">
+        <conversion-rule>
+            <native-to-target file="../glue/qtgui.cpp" snippet="return-pylong-voidptr"/>
+            <target-to-native>
+                <add-conversion type="PyLong" file="../glue/qtgui.cpp"
+                                snippet="conversion-pylong"/>
+            </target-to-native>
+        </conversion-rule>
+    </primitive-type>
     <primitive-type name="HRGN" target-lang-api-name="PyLong">
         <conversion-rule>
             <native-to-target file="../glue/qtgui.cpp" snippet="return-pylong-voidptr"/>
diff --git a/sources/pyside6/PySide6/QtGui/typesystem_gui_x11.xml b/sources/pyside6/PySide6/QtGui/typesystem_gui_x11.xml
index c4f16911e..70331e29c 100644
--- a/sources/pyside6/PySide6/QtGui/typesystem_gui_x11.xml
+++ b/sources/pyside6/PySide6/QtGui/typesystem_gui_x11.xml
@@ -3,4 +3,7 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtGui"/>
+<typesystem package="PySide6.QtGui">
+    <custom-type name="_XDisplay"/>
+    <custom-type name="xcb_connection_t"/>
+</typesystem>
diff --git a/sources/pyside6/PySide6/QtHelp/CMakeLists.txt b/sources/pyside6/PySide6/QtHelp/CMakeLists.txt
index 1b1f1ad74..7bf46dcef 100644
--- a/sources/pyside6/PySide6/QtHelp/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtHelp/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtHelp)
 
 set(QtHelp_SRC
@@ -5,6 +8,7 @@ ${QtHelp_GEN_DIR}/qcompressedhelpinfo_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpcontentitem_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpcontentmodel_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpcontentwidget_wrapper.cpp
+${QtHelp_GEN_DIR}/qhelpglobal_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpengine_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpenginecore_wrapper.cpp
 ${QtHelp_GEN_DIR}/qhelpfilterdata_wrapper.cpp
@@ -37,9 +41,6 @@ set(QtHelp_include_dirs ${QtHelp_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
                         )
 set(QtHelp_libraries  pyside6
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
                       ${Qt${QT_MAJOR_VERSION}Help_LIBRARIES})
 
 set(QtHelp_deps QtWidgets)
diff --git a/sources/pyside6/PySide6/QtHelp/typesystem_help.xml b/sources/pyside6/PySide6/QtHelp/typesystem_help.xml
index 88712bfb7..5fa30e034 100644
--- a/sources/pyside6/PySide6/QtHelp/typesystem_help.xml
+++ b/sources/pyside6/PySide6/QtHelp/typesystem_help.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.QtHelp">
+<typesystem package="PySide6.QtHelp"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
 
     <value-type name="QCompressedHelpInfo"/>
@@ -15,8 +16,9 @@
         </modify-argument>
       </modify-function>
     </value-type>
-    <object-type name="QHelpContentModel" polymorphic-id-expression="qobject_cast&lt;QHelpContentModel*&gt;(%1)"/>
+    <object-type name="QHelpContentModel" polymorphic-id-expression="qobject_cast&lt;QHelpContentModel*&gt;(%B)"/>
     <object-type name="QHelpContentWidget"/>
+    <value-type name="QHelpGlobal"/>
     <object-type name="QHelpEngine"/>
     <object-type name="QHelpEngineCore"/>
     <value-type name="QHelpFilterData"/>
diff --git a/sources/pyside6/PySide6/QtHttpServer/CMakeLists.txt b/sources/pyside6/PySide6/QtHttpServer/CMakeLists.txt
index 4e0c6ef76..c931f064f 100644
--- a/sources/pyside6/PySide6/QtHttpServer/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtHttpServer/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtHttpServer)
 
 set(QtHttpServer_SRC
@@ -25,11 +28,7 @@ set(QtHttpServer_include_dirs ${QtHttpServer_SOURCE_DIR}
                                 ${QtWebSockets_GEN_DIR})
 
 set(QtHttpServer_libraries pyside6
-                           ${Qt${QT_MAJOR_VERSION}HttpServer_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Concurrent_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}WebSockets_LIBRARIES})
+                           ${Qt${QT_MAJOR_VERSION}HttpServer_LIBRARIES})
 
 set(QtHttpServer_deps QtCore QtConcurrent QtNetwork QtWebSockets)
 
diff --git a/sources/pyside6/PySide6/QtHttpServer/typesystem_httpserver.xml b/sources/pyside6/PySide6/QtHttpServer/typesystem_httpserver.xml
index 0c96dc7a6..026a8758a 100644
--- a/sources/pyside6/PySide6/QtHttpServer/typesystem_httpserver.xml
+++ b/sources/pyside6/PySide6/QtHttpServer/typesystem_httpserver.xml
@@ -3,12 +3,14 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtHttpServer">
+<typesystem package="PySide6.QtHttpServer"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtConcurrent/typesystem_concurrent.xml" generate="no"/>
   <load-typesystem name="QtWebSockets/typesystem_websockets.xml" generate="no"/>
 
   <typedef-type name="QFutureHttpServerResponse" source="QFuture&lt;QHttpServerResponse&gt;"/>
-  <object-type name="QAbstractHttpServer"/>
+  <!-- virtual void missingHandler(const QHttpServerRequest &, QHttpServerResponder &&) = 0 -->
+  <object-type name="QAbstractHttpServer" disable-wrapper="yes"/>
   <object-type name="QHttpServer">
       <extra-includes>
           <include file-name="QtHttpServer/QHttpServerRequest" location="global"/>
diff --git a/sources/pyside6/PySide6/QtLocation/CMakeLists.txt b/sources/pyside6/PySide6/QtLocation/CMakeLists.txt
index 9e58d94ac..db5777e04 100644
--- a/sources/pyside6/PySide6/QtLocation/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtLocation/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtLocation)
 
 set(QtLocation_OPTIONAL_SRC )
@@ -10,7 +13,6 @@ ${QtLocation_GEN_DIR}/qgeoroute_wrapper.cpp
 ${QtLocation_GEN_DIR}/qgeoroutereply_wrapper.cpp
 ${QtLocation_GEN_DIR}/qgeoroutesegment_wrapper.cpp
 ${QtLocation_GEN_DIR}/qgeoserviceprovider_wrapper.cpp
-${QtLocation_GEN_DIR}/qgeoserviceproviderfactoryv2_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplace_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacecontentreply_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacedetailsreply_wrapper.cpp
@@ -29,8 +31,6 @@ ${QtLocation_GEN_DIR}/qplacecategory_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacecontactdetail_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacecontent_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacecontentrequest_wrapper.cpp
-${QtLocation_GEN_DIR}/qplaceeditorial_wrapper.cpp
-${QtLocation_GEN_DIR}/qplaceimage_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacemanagerengine_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacematchreply_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacematchrequest_wrapper.cpp
@@ -38,7 +38,6 @@ ${QtLocation_GEN_DIR}/qplaceproposedsearchresult_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplaceratings_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacereply_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplaceresult_wrapper.cpp
-${QtLocation_GEN_DIR}/qplacereview_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacesearchreply_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacesearchrequest_wrapper.cpp
 ${QtLocation_GEN_DIR}/qplacesearchresult_wrapper.cpp
diff --git a/sources/pyside6/PySide6/QtLocation/typesystem_location.xml b/sources/pyside6/PySide6/QtLocation/typesystem_location.xml
index ea8b661af..e35b7bd11 100644
--- a/sources/pyside6/PySide6/QtLocation/typesystem_location.xml
+++ b/sources/pyside6/PySide6/QtLocation/typesystem_location.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2018 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtLocation">
+<typesystem package="PySide6.QtLocation"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtPositioning/typesystem_positioning.xml" generate="no"/>
   <object-type name="QGeoCodeReply">
@@ -47,16 +48,14 @@
   <object-type name="QGeoRoutingManager"/>
   <object-type name="QGeoRoutingManagerEngine"/>
   <object-type name="QGeoServiceProviderFactory"/>
-  <object-type name="QGeoServiceProviderFactoryV2"/>
   <value-type name="QPlaceAttribute"/>
   <value-type name="QPlaceCategory"/>
   <value-type name="QPlaceContactDetail"/>
   <value-type name="QPlaceContent">
       <enum-type name="Type"/>
+      <enum-type name="DataTag" since="6.5"/>
   </value-type>
   <value-type name="QPlaceContentRequest"/>
-  <object-type name="QPlaceEditorial"/>
-  <object-type name="QPlaceImage"/>
   <object-type name="QPlaceManagerEngine"/>
   <object-type name="QPlaceMatchReply"/>
   <value-type name="QPlaceMatchRequest"/>
@@ -67,7 +66,6 @@
       <enum-type name="Type"/>
   </object-type>
   <object-type name="QPlaceResult"/>
-  <object-type name="QPlaceReview"/>
   <object-type name="QPlaceSearchReply"/>
   <object-type name="QPlaceSearchRequest">
       <enum-type name="RelevanceHint"/>
@@ -77,4 +75,8 @@
   </object-type>
   <object-type name="QPlaceSearchSuggestionReply"/>
   <value-type name="QPlaceSupplier"/>
+
+  <!-- QtQml, QtNetwork are pulled in via QtLocationDepends. -->
+  <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls)|(Qml).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtMultimedia/CMakeLists.txt b/sources/pyside6/PySide6/QtMultimedia/CMakeLists.txt
index 5a6f3e38e..e40c5a2ed 100644
--- a/sources/pyside6/PySide6/QtMultimedia/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtMultimedia/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtMultimedia)
 
 set(QtMultimedia_SRC
@@ -13,6 +16,7 @@ ${QtMultimedia_GEN_DIR}/qaudio_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qcameraformat_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qcameradevice_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qcamera_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qcapturablewindow_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qimagecapture_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qmediacapturesession_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qmediadevices_wrapper.cpp
@@ -23,10 +27,15 @@ ${QtMultimedia_GEN_DIR}/qmediaplayer_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qmediarecorder_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qmediatimerange_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qmediatimerange_interval_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qscreencapture_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qsoundeffect_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qtvideo_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qvideoframe_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qvideoframe_paintoptions_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qvideoframeformat_wrapper.cpp
 ${QtMultimedia_GEN_DIR}/qvideosink_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qwavedecoder_wrapper.cpp
+${QtMultimedia_GEN_DIR}/qwindowcapture_wrapper.cpp
 
 # module is always needed
 ${QtMultimedia_GEN_DIR}/qtmultimedia_module_wrapper.cpp
@@ -44,11 +53,8 @@ set(QtMultimedia_include_dirs   ${QtMultimedia_SOURCE_DIR}
                                 ${QtNetwork_GEN_DIR})
 
 set(QtMultimedia_libraries  pyside6
-                            ${Qt${QT_MAJOR_VERSION}Multimedia_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                            )
+                            ${Qt${QT_MAJOR_VERSION}Multimedia_LIBRARIES})
+
 set(QtMultimedia_deps QtCore QtGui QtNetwork)
 
 create_pyside_module(NAME QtMultimedia
diff --git a/sources/pyside6/PySide6/QtMultimedia/typesystem_multimedia.xml b/sources/pyside6/PySide6/QtMultimedia/typesystem_multimedia.xml
index 3fa7e6e6d..2791f695a 100644
--- a/sources/pyside6/PySide6/QtMultimedia/typesystem_multimedia.xml
+++ b/sources/pyside6/PySide6/QtMultimedia/typesystem_multimedia.xml
@@ -3,16 +3,23 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtMultimedia">
+<typesystem package="PySide6.QtMultimedia"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
 
     <namespace-type name="QAudio">
         <enum-type name="Error"/>
-        <enum-type name="Mode"/>
         <enum-type name="State"/>
         <enum-type name="VolumeScale"/>
+        <inject-code class="target" position="end"
+                     file="../glue/qtmultimedia.cpp"
+                     snippet="qtaudio-namespace-compatibility-alias"/>
+    </namespace-type>
+
+    <namespace-type name="QtVideo" since="6.7">
+        <enum-type name="Rotation"/>
     </namespace-type>
 
     <value-type name="QAudioBuffer">
@@ -47,29 +54,31 @@
     <object-type name="QAudioOutput"/>
 
     <object-type name="QAudioSource">
-      <modify-function signature="start()">
+      <modify-function signature="start()" allow-thread="true">
         <modify-argument index="return">
           <define-ownership class="target" owner="c++"/>
         </modify-argument>
       </modify-function>
-      <modify-function signature="start(QIODevice*)">
+      <modify-function signature="start(QIODevice*)" allow-thread="true">
         <modify-argument index="1">
           <define-ownership class="target" owner="c++"/>
         </modify-argument>
       </modify-function>
+      <modify-function signature="stop()" allow-thread="true"/>
     </object-type>
 
     <object-type name="QAudioSink">
-      <modify-function signature="start()">
+      <modify-function signature="start()" allow-thread="true">
         <modify-argument index="return">
           <define-ownership class="target" owner="c++"/>
         </modify-argument>
       </modify-function>
-      <modify-function signature="start(QIODevice*)">
+      <modify-function signature="start(QIODevice*)" allow-thread="true">
         <modify-argument index="1">
           <define-ownership class="target" owner="c++"/>
         </modify-argument>
       </modify-function>
+      <modify-function signature="stop()" allow-thread="true"/>
     </object-type>
 
     <object-type name="QCamera">
@@ -85,6 +94,9 @@
     <value-type name="QCameraDevice">
         <enum-type name="Position" since="6.1"/>
     </value-type>
+
+    <value-type name="QCapturableWindow" since="6.6"/>
+
     <object-type name="QImageCapture">
         <enum-type name="Error"/>
         <enum-type name="FileFormat"/>
@@ -125,6 +137,10 @@
         <value-type name="Interval"/>
     </value-type>
 
+    <object-type name="QScreenCapture" since="6.5">
+        <enum-type name="Error"/>
+    </object-type>
+
     <object-type name="QSoundEffect">
         <enum-type name="Loop"/>
         <enum-type name="Status"/>
@@ -138,6 +154,9 @@
           <inject-code file="../glue/qtmultimedia.cpp" snippet="qvideoframe-bits"/>
         </modify-function>
         <modify-function signature="bits(int)const" remove="all"/>
+        <value-type name="PaintOptions">
+            <enum-type name="PaintFlag" flags="PaintFlags"/>
+        </value-type>
     </value-type>
     <value-type name="QVideoFrameFormat" since="6.1">
         <enum-type name="ColorSpace" since="6.4"/>
@@ -148,5 +167,14 @@
         <enum-type name="YCbCrColorSpace"/>
     </value-type>
 
+    <object-type name="QWaveDecoder">
+        <!-- No implementation -->
+        <modify-function signature="setIODevice(QIODevice*)" remove="all"/>
+    </object-type>
+
+    <object-type name="QWindowCapture" since="6.6">
+        <enum-type name="Error"/>
+    </object-type>
+
     <object-type name="QVideoSink" since="6.1"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtMultimediaWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtMultimediaWidgets/CMakeLists.txt
index 94443b496..c3988551e 100644
--- a/sources/pyside6/PySide6/QtMultimediaWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtMultimediaWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtMultimediaWidgets)
 
 set(QtMultimediaWidgets_SRC
@@ -23,12 +26,8 @@ set(QtMultimediaWidgets_include_dirs ${QtMultimediaWidgets_SOURCE_DIR}
                                      ${QtMultimedia_GEN_DIR})
 
 set(QtMultimediaWidgets_libraries    pyside6
-                                     ${Qt${QT_MAJOR_VERSION}Multimedia_LIBRARIES}
-                                     ${Qt${QT_MAJOR_VERSION}MultimediaWidgets_LIBRARIES}
-                                     ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                                     ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                                     ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                                     ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES})
+                                     ${Qt${QT_MAJOR_VERSION}MultimediaWidgets_LIBRARIES})
+
 
 set(QtMultimediaWidgets_deps QtCore QtGui QtNetwork QtWidgets QtMultimedia)
 
diff --git a/sources/pyside6/PySide6/QtMultimediaWidgets/typesystem_multimediawidgets.xml b/sources/pyside6/PySide6/QtMultimediaWidgets/typesystem_multimediawidgets.xml
index 8d53e743a..05b4e2456 100644
--- a/sources/pyside6/PySide6/QtMultimediaWidgets/typesystem_multimediawidgets.xml
+++ b/sources/pyside6/PySide6/QtMultimediaWidgets/typesystem_multimediawidgets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtMultimediaWidgets">
+<typesystem package="PySide6.QtMultimediaWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
   <load-typesystem name="QtMultimedia/typesystem_multimedia.xml" generate="no"/>
diff --git a/sources/pyside6/PySide6/QtNetwork/CMakeLists.txt b/sources/pyside6/PySide6/QtNetwork/CMakeLists.txt
index eadd3b982..529e2e86b 100644
--- a/sources/pyside6/PySide6/QtNetwork/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtNetwork/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtNetwork)
 
 set(QtNetwork_DROPPED_ENTRIES )
@@ -15,6 +18,8 @@ ${QtNetwork_GEN_DIR}/qdnstextrecord_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhostaddress_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhostinfo_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhstspolicy_wrapper.cpp
+${QtNetwork_GEN_DIR}/qhttp1configuration_wrapper.cpp
+${QtNetwork_GEN_DIR}/qhttpheaders_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhttpmultipart_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhttppart_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qhttp2configuration_wrapper.cpp
@@ -35,7 +40,10 @@ ${QtNetwork_GEN_DIR}/qnetworkproxyfactory_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qnetworkproxyquery_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qnetworkreply_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qnetworkrequest_wrapper.cpp
+${QtNetwork_GEN_DIR}/qnetworkrequestfactory_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qpassworddigestor_wrapper.cpp
+${QtNetwork_GEN_DIR}/qrestaccessmanager_wrapper.cpp
+${QtNetwork_GEN_DIR}/qrestreply_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qssl_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qsslcertificate_wrapper.cpp
 ${QtNetwork_GEN_DIR}/qsslcertificateextension_wrapper.cpp
@@ -65,11 +73,9 @@ else()
          ${QtNetwork_GEN_DIR}/qsslerror_wrapper.cpp
          ${QtNetwork_GEN_DIR}/qsslkey_wrapper.cpp
          ${QtNetwork_GEN_DIR}/qsslpresharedkeyauthenticator_wrapper.cpp
+         ${QtNetwork_GEN_DIR}/qsslserver_wrapper.cpp
          ${QtNetwork_GEN_DIR}/qsslsocket_wrapper.cpp
          ${QtNetwork_GEN_DIR}/qocspresponse_wrapper.cpp)
-     if (Qt${QT_MAJOR_VERSION}Network_VERSION VERSION_GREATER_EQUAL 6.4.0)
-         list(APPEND QtNetwork_SRC ${QtNetwork_GEN_DIR}/qsslserver_wrapper.cpp)
-     endif()
     message(STATUS "Qt${QT_MAJOR_VERSION}Network: Adding SSL classes")
 endif()
 
@@ -79,7 +85,8 @@ if("dtls" IN_LIST QtNetwork_disabled_features)
 else()
     list(APPEND QtNetwork_SRC
          ${QtNetwork_GEN_DIR}/qdtls_wrapper.cpp
-         ${QtNetwork_GEN_DIR}/qdtlsclientverifier_wrapper.cpp)
+         ${QtNetwork_GEN_DIR}/qdtlsclientverifier_wrapper.cpp
+         ${QtNetwork_GEN_DIR}/qdtlsclientverifier_generatorparameters_wrapper.cpp)
     message(STATUS "Qt${QT_MAJOR_VERSION}Network: Adding DTLS classes")
 endif()
 
diff --git a/sources/pyside6/PySide6/QtNetwork/typesystem_network.xml b/sources/pyside6/PySide6/QtNetwork/typesystem_network.xml
index 55fddf34f..4dc7c9b0a 100644
--- a/sources/pyside6/PySide6/QtNetwork/typesystem_network.xml
+++ b/sources/pyside6/PySide6/QtNetwork/typesystem_network.xml
@@ -3,14 +3,21 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtNetwork">
+<typesystem package="PySide6.QtNetwork"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 
-    <rejection class="dtlsopenssl"/>
+    <rejection class="QTlsPrivate"/>
 
-    <enum-type name="QDtlsError"/>
-    <enum-type name="QOcspCertificateStatus"/>
-    <enum-type name="QOcspRevocationReason"/>
+    <enum-type name="QDtlsError">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </enum-type>
+    <enum-type name="QOcspCertificateStatus">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </enum-type>
+    <enum-type name="QOcspRevocationReason">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </enum-type>
 
     <namespace-type name="QPasswordDigestor">
         <extra-includes>
@@ -35,7 +42,6 @@
     </namespace-type>
 
     <rejection class="QIPv6Address" field-name="c"/>
-    <rejection class="dtlsopenssl"/>
 
     <object-type name="QAbstractSocket">
         <enum-type name="BindFlag" flags="BindMode"/>
@@ -66,12 +72,22 @@
 
     <object-type name="QDtls">
         <enum-type name="HandshakeState"/>
+        <configuration condition="QT_CONFIG(dtls)"/>
+    </object-type>
+    <object-type name="QDtlsClientVerifier">
+        <configuration condition="QT_CONFIG(dtls)"/>
+        <value-type name="GeneratorParameters">
+            <configuration condition="QT_CONFIG(dtls)"/>
+        </value-type>
     </object-type>
-    <object-type name="QDtlsClientVerifier"/>
 
     <value-type name="QHstsPolicy">
         <enum-type name="PolicyFlag" flags="PolicyFlags"/>
     </value-type>
+    <value-type name="QHttp1Configuration"/>
+    <value-type name="QHttpHeaders" since="6.7">
+        <enum-type name="WellKnownHeader"/>
+    </value-type>
     <object-type name="QHttpMultiPart">
         <enum-type name="ContentType"/>
     </object-type>
@@ -88,15 +104,17 @@
                 <remove-default-expression/>
                 <remove-argument/>
             </modify-argument>
-            <modify-argument index="return">
-                <replace-type modified-type="(retval, timeOut)"/>
+            <modify-argument index="return" pyi-type="Tuple[bool, bool]">
+                <replace-type modified-type="(retval, timedOut)"/>
             </modify-argument>
             <inject-code class="target" position="beginning">
                 <insert-template name="fix_args,bool*"/>
             </inject-code>
         </modify-function>
     </object-type>
-    <value-type name="QOcspResponse"/>
+    <value-type name="QOcspResponse">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </value-type>
     <object-type name="QTcpSocket"/>
     <object-type name="QUdpSocket">
         <modify-function signature="readDatagram(char*,qint64,QHostAddress*,quint16*)" allow-thread="yes">
@@ -111,7 +129,7 @@
                 <remove-default-expression/>
                 <remove-argument/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[PySide6.QtCore.QByteArray, PySide6.QtNetwork.QHostAddress, int]">
                 <replace-type modified-type="(data, address, port)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp" snippet="qudpsocket-readdatagram"/>
@@ -136,8 +154,8 @@
             <inject-code class="target" position="beginning">
                 <insert-template name="fix_args,bool*"/>
             </inject-code>
-            <modify-argument index="return">
-                <replace-type modified-type="(retval, timeOut)"/>
+            <modify-argument index="return" pyi-type="Tuple[bool, bool]">
+                <replace-type modified-type="(retval, timedOut)"/>
             </modify-argument>
 
         </modify-function>
@@ -161,6 +179,11 @@
         <modify-function signature="put(const QNetworkRequest &amp;,QIODevice*)" allow-thread="yes"/>
         <modify-function signature="put(const QNetworkRequest &amp;,const QByteArray &amp;)" allow-thread="yes"/>
         <modify-function signature="sendCustomRequest(const QNetworkRequest &amp;,const QByteArray &amp;,QIODevice*)" allow-thread="yes" since="4.7"/>
+        <modify-function signature="setCache(QAbstractNetworkCache*)">
+            <modify-argument index="1">
+                <define-ownership class="target" owner="c++"/>
+            </modify-argument>
+        </modify-function>
         <modify-function signature="setCookieJar(QNetworkCookieJar*)">
             <modify-argument index="1">
                 <define-ownership class="target" owner="c++"/>
@@ -188,6 +211,8 @@
     </value-type>
 
     <value-type name="QHostInfo">
+        <inject-code class="native" position="beginning" file="../glue/qtnetwork.cpp"
+                     snippet="qhostinfo-lookuphost-functor"/>
         <enum-type name="HostInfoError"/>
         <add-function signature="lookupHost(const QString &amp;,PyCallable)">
             <inject-code class="target" position="beginning"
@@ -198,11 +223,13 @@
 
     <value-type name="QNetworkAddressEntry">
         <enum-type name="DnsEligibilityStatus"/>
+        <configuration condition="#ifndef QT_NO_NETWORKINTERFACE"/>
     </value-type>
 
     <value-type name="QNetworkInterface">
         <enum-type name="InterfaceFlag" flags="InterfaceFlags"/>
         <enum-type name="InterfaceType"/>
+        <configuration condition="#ifndef QT_NO_NETWORKINTERFACE"/>
     </value-type>
 
     <value-type name="QNetworkProxy">
@@ -237,43 +264,193 @@
     </value-type>
     <value-type name="QNetworkRequest">
         <enum-type name="Attribute"/>
-        <enum-type name="LoadControl" since="4.7"/>
-        <enum-type name="Priority" since="4.7"/>
+        <enum-type name="LoadControl"/>
+        <enum-type name="Priority"/>
         <enum-type name="CacheLoadControl"/>
         <enum-type name="KnownHeaders"/>
         <enum-type name="RedirectPolicy"/>
         <enum-type name="TransferTimeoutConstant"/>
     </value-type>
-
+    <value-type name="QNetworkRequestFactory" since="6.7"/>
     <object-type name="QAbstractNetworkCache"/>
     <object-type name="QNetworkDiskCache"/>
     <value-type name="QNetworkCacheMetaData"/>
 
-    <object-type name="QSctpServer"/>
-    <object-type name="QSctpSocket"/>
+    <object-type name="QRestAccessManager" since="6.7">
+        <inject-code class="native" position="beginning" file="../glue/qtnetwork.cpp"
+                     snippet="qrestaccessmanager-functor"/>
+
+        <add-function signature="deleteResource(QNetworkRequest@request@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-callback"/>
+        </add-function>
+
+        <add-function signature="get(QNetworkRequest@request@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-callback"/>
+        </add-function>
+        <add-function signature="get(QNetworkRequest@request@,QByteArray@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="get(QNetworkRequest@request@,QIODevice*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="get(QNetworkRequest@request@,QJsonDocument@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+
+        <add-function signature="head(QNetworkRequest@request@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-callback"/>
+        </add-function>
+
+        <add-function signature="patch(QNetworkRequest@request@,QByteArray@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="patch(QNetworkRequest@request@,QIODevice*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="patch(QNetworkRequest@request@,QJsonDocument@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="patch(QNetworkRequest@request@,QVariantMap@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+
+        <add-function signature="post(QNetworkRequest@request@,QByteArray@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="post(QNetworkRequest@request@,QHttpMultiPart*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="post(QNetworkRequest@request@,QIODevice*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="post(QNetworkRequest@request@,QJsonDocument@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="post(QNetworkRequest@request@,QVariantMap@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+
+        <add-function signature="put(QNetworkRequest@request@,QByteArray@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="put(QNetworkRequest@request@,QHttpMultiPart*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="put(QNetworkRequest@request@,QIODevice*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="put(QNetworkRequest@request@,QJsonDocument@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+        <add-function signature="put(QNetworkRequest@request@,QVariantMap@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-data-callback"/>
+        </add-function>
+
+        <add-function signature="sendCustomRequest(QNetworkRequest@request@,QByteArray@method@,QByteArray@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-method-data-callback"/>
+        </add-function>
+        <add-function signature="sendCustomRequest(QNetworkRequest@request@,QByteArray@method@,QHttpMultiPart*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-method-data-callback"/>
+        </add-function>
+        <add-function signature="sendCustomRequest(QNetworkRequest@request@,QByteArray@method@,QIODevice*@data@,QObject*@context@,PyCallable*@slot@)"
+                      return-type="QNetworkReply*">
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestaccessmanager-method-data-callback"/>
+        </add-function>
+    </object-type>
+
+    <object-type name="QRestReply" since="6.7">
+        <add-function signature="readJson()" return-type="PyObject">
+            <modify-argument index="return"
+                             pyi-type="Tuple[Optional[PySide6.QtCore.QJsonDocument],PySide6.QtCore.QJsonParseError]"/>
+            <inject-code class="target" position="beginning" file="../glue/qtnetwork.cpp"
+                         snippet="qrestreply-readjson"/>
+        </add-function>
+    </object-type>
+
+    <object-type name="QSctpServer">
+        <configuration condition="QT_CONFIG(sctp)"/>
+    </object-type>
+    <object-type name="QSctpSocket">
+        <configuration condition="QT_CONFIG(sctp)"/>
+    </object-type>
 
     <!-- The following entries may be present in the system or not. Keep this section organized. -->
     <value-type name="QSslCertificate">
         <enum-type name="PatternSyntax"/>
         <enum-type name="SubjectInfo"/>
+        <configuration condition="QT_CONFIG(ssl)"/>
     </value-type>
 
-    <value-type name="QSslCertificateExtension"/>
+    <value-type name="QSslCertificateExtension">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </value-type>
 
-    <value-type name="QSslCipher"/>
+    <value-type name="QSslCipher">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </value-type>
 
     <value-type name="QSslConfiguration">
         <enum-type name="NextProtocolNegotiationStatus"/>
+        <configuration condition="QT_CONFIG(ssl)"/>
     </value-type>
 
     <value-type name="QSslDiffieHellmanParameters">
         <enum-type name="Error"/>
+        <configuration condition="QT_CONFIG(ssl)"/>
     </value-type>
 
-    <value-type name="QSslEllipticCurve"/>
+    <value-type name="QSslEllipticCurve">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </value-type>
 
     <value-type name="QSslError">
         <enum-type name="SslError"/>
+        <configuration condition="QT_CONFIG(ssl)"/>
     </value-type>
 
     <value-type name="QSslKey"/>
@@ -282,11 +459,16 @@
         <enum-type name="PeerVerifyMode"/>
         <modify-function signature="connectToHostEncrypted(const QString&amp;,quint16,QFlags&lt;QIODeviceBase::OpenModeFlag>,QAbstractSocket::NetworkLayerProtocol)" allow-thread="yes"/>
         <modify-function signature="waitForEncrypted(int)" allow-thread="yes"/>
+        <configuration condition="QT_CONFIG(ssl)"/>
     </object-type>
 
-    <value-type name="QSslPreSharedKeyAuthenticator"/>
+    <value-type name="QSslPreSharedKeyAuthenticator">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </value-type>
 
-    <object-type name="QSslServer" since="6.4"/>
+    <object-type name="QSslServer" since="6.4">
+        <configuration condition="QT_CONFIG(ssl)"/>
+    </object-type>
 
     <!-- The above entries may be present in the system or not. Keep this section organized. -->
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtNetworkAuth/CMakeLists.txt b/sources/pyside6/PySide6/QtNetworkAuth/CMakeLists.txt
index 3313c9d3b..4d9498e4d 100644
--- a/sources/pyside6/PySide6/QtNetworkAuth/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtNetworkAuth/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtNetworkAuth)
 
 set(QtNetworkAuth_SRC
@@ -23,8 +26,6 @@ set(QtNetworkAuth_include_dirs ${QtNetworkAuth_SOURCE_DIR}
                                ${QtNetworkAuth_GEN_DIR})
 
 set(QtNetworkAuth_libraries pyside6
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
                             ${Qt${QT_MAJOR_VERSION}NetworkAuth_LIBRARIES})
 
 set(QtNetworkAuth_deps QtNetwork)
diff --git a/sources/pyside6/PySide6/QtNetworkAuth/typesystem_networkauth.xml b/sources/pyside6/PySide6/QtNetworkAuth/typesystem_networkauth.xml
index a46dd2fca..bedfc5a28 100644
--- a/sources/pyside6/PySide6/QtNetworkAuth/typesystem_networkauth.xml
+++ b/sources/pyside6/PySide6/QtNetworkAuth/typesystem_networkauth.xml
@@ -4,13 +4,16 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.QtNetworkAuth">
+<typesystem package="PySide6.QtNetworkAuth"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
     <object-type name="QAbstractOAuth">
         <enum-type name="ContentType"/>
         <enum-type name="Error"/>
         <enum-type name="Stage"/>
         <enum-type name="Status"/>
+        <inject-code class="native" position="beginning" file="../glue/qtnetworkauth.cpp"
+                     snippet="qabstractoauth-lookuphost-functor"/>
         <modify-function signature="setReplyHandler(QAbstractOAuthReplyHandler*)">
             <modify-argument index="1">
                 <define-ownership class="target" owner="c++"/>
diff --git a/sources/pyside6/PySide6/QtNfc/CMakeLists.txt b/sources/pyside6/PySide6/QtNfc/CMakeLists.txt
index d9cb0e31a..b94249a55 100644
--- a/sources/pyside6/PySide6/QtNfc/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtNfc/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtNfc)
 
 set(QtNfc_SRC
@@ -11,6 +14,7 @@ set(QtNfc_SRC
     ${QtNfc_GEN_DIR}/qndefnfcurirecord_wrapper.cpp
     ${QtNfc_GEN_DIR}/qnearfieldmanager_wrapper.cpp
     ${QtNfc_GEN_DIR}/qnearfieldtarget_wrapper.cpp
+    ${QtNfc_GEN_DIR}/qnearfieldtarget_requestid_wrapper.cpp
 # module is always needed
     ${QtNfc_GEN_DIR}/qtnfc_module_wrapper.cpp)
 
diff --git a/sources/pyside6/PySide6/QtNfc/typesystem_nfc.xml b/sources/pyside6/PySide6/QtNfc/typesystem_nfc.xml
index be9465901..b548227f0 100644
--- a/sources/pyside6/PySide6/QtNfc/typesystem_nfc.xml
+++ b/sources/pyside6/PySide6/QtNfc/typesystem_nfc.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtNfc">
+<typesystem package="PySide6.QtNfc"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <value-type name="QNdefFilter">
         <value-type name="Record"/>
@@ -27,5 +28,8 @@
         <enum-type name="AccessMethod" flags="AccessMethods"/>
         <enum-type name="Error"/>
         <enum-type name="Type"/>
+        <value-type name="RequestId"/>
     </object-type>
+    <!-- QtNetwork is pulled in via QtNfcDepends. -->
+    <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls).*' does not have a type entry.*$"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtOpenGL/CMakeLists.txt b/sources/pyside6/PySide6/QtOpenGL/CMakeLists.txt
index ed2e9a2c4..5bf8b5f3b 100644
--- a/sources/pyside6/PySide6/QtOpenGL/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtOpenGL/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtOpenGL)
 
 set(QtOpenGL_DROPPED_ENTRIES)
@@ -38,38 +41,39 @@ if("opengles2" IN_LIST QtGui_enabled_features)
 else()
     list(APPEND QtOpenGL_DROPPED_ENTRIES QOpenGLFunctions_ES2)
     list(APPEND QtOpenGL_SRC
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_0_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_1_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_2_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_3_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_4_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_5_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_2_0_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_2_1_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_0_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_1_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_2_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_2_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_3_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_3_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_0_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_0_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_1_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_1_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_2_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_2_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_3_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_3_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_4_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_4_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_5_compatibility_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_5_core_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopenglversionfunctionsfactory_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopengltimemonitor_wrapper.cpp
-         ${QtOpenGL_GEN_DIR}/qopengltimerquery_wrapper.cpp)
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_0_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_1_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_2_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_3_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_4_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_1_5_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_2_0_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_2_1_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_0_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_1_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_2_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_2_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_3_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_3_3_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_0_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_0_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_1_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_1_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_2_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_2_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_3_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_3_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_4_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_4_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_5_compatibility_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglfunctions_4_5_core_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopenglversionfunctionsfactory_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopengltimemonitor_wrapper.cpp
+        ${QtOpenGL_GEN_DIR}/qopengltimerquery_wrapper.cpp)
     message(STATUS "Qt${QT_MAJOR_VERSION}OpenGL: Adding Desktop OpenGL classes")
 endif()
 
+
 configure_file("${QtOpenGL_SOURCE_DIR}/QtOpenGL_global.post.h.in"
                "${QtOpenGL_BINARY_DIR}/QtOpenGL_global.post.h" @ONLY)
 
@@ -83,8 +87,6 @@ set(QtOpenGL_include_dirs   ${QtOpenGL_SOURCE_DIR}
                             ${QtOpenGL_GEN_DIR}
                             )
 set(QtOpenGL_libraries      pyside6
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
                             ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES})
 set(QtOpenGL_deps QtGui)
 
diff --git a/sources/pyside6/PySide6/QtOpenGL/QtOpenGL_global.post.h.in b/sources/pyside6/PySide6/QtOpenGL/QtOpenGL_global.post.h.in
index 2e6d36b5f..571b245a3 100644
--- a/sources/pyside6/PySide6/QtOpenGL/QtOpenGL_global.post.h.in
+++ b/sources/pyside6/PySide6/QtOpenGL/QtOpenGL_global.post.h.in
@@ -1,9 +1,10 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
 #include <QtGui/qtgui-config.h>
-// OpenGL functions are not in the QtGui module header
-#if QT_CONFIG(opengl)
+
+#if QT_CONFIG(opengles2)
+#  include <QtOpenGL/qopenglfunctions_es2.h>
+#elif QT_CONFIG(opengl)
 #  include <QtOpenGL/qopenglfunctions_1_0.h>
 #  include <QtOpenGL/qopenglfunctions_1_1.h>
 #  include <QtOpenGL/qopenglfunctions_1_2.h>
@@ -32,6 +33,3 @@
 #  include <QtOpenGL/qopenglfunctions_4_5_core.h>
 #  include <QtOpenGL/qopenglversionfunctionsfactory.h>
 #endif
-#if QT_CONFIG(opengles2)
-#  include <QtOpenGL/qopenglfunctions_es2.h>
-#endif
diff --git a/sources/pyside6/PySide6/QtOpenGL/typesystem_opengl.xml b/sources/pyside6/PySide6/QtOpenGL/typesystem_opengl.xml
index 4fd7f7f24..efbd16056 100644
--- a/sources/pyside6/PySide6/QtOpenGL/typesystem_opengl.xml
+++ b/sources/pyside6/PySide6/QtOpenGL/typesystem_opengl.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtOpenGL">
+<typesystem package="PySide6.QtOpenGL"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no" />
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no" />
   <load-typesystem name="templates/opengl_common.xml" generate="no" />
@@ -145,6 +146,9 @@
     <enum-type name="RangeAccessFlag" flags="RangeAccessFlags"/>
     <enum-type name="Type"/>
     <enum-type name="UsagePattern"/>
+    <modify-function signature="allocate(const void*,int)">
+        <modify-argument index="1" pyi-type="bytes"/>
+    </modify-function>
   </object-type>
   <object-type name="QOpenGLDebugLogger">
       <enum-type name="LoggingMode"/>
@@ -621,7 +625,7 @@
   </object-type>
   <value-type name="QOpenGLFramebufferObjectFormat"/>
   <object-type name="QAbstractOpenGLFunctions"/>
-  <value-type  name="QOpenGLPixelTransferOptions"/>
+  <value-type name="QOpenGLPixelTransferOptions"/>
   <object-type name="QOpenGLShader">
     <enum-type name="ShaderTypeBit" flags="ShaderType"/>
   </object-type>
@@ -716,6 +720,4 @@
       </object-type>
   </object-type>
 
-  <suppress-warning text="^There's no user provided way.*QOpenGLFunctions_\d_\d.*::glIndex.*$"/>
-
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtOpenGLWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtOpenGLWidgets/CMakeLists.txt
index b8b6664b5..8c7386130 100644
--- a/sources/pyside6/PySide6/QtOpenGLWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtOpenGLWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtOpenGLWidgets)
 
 set(QtOpenGLWidgets_SRC
@@ -18,10 +21,6 @@ set(QtOpenGLWidgets_include_dirs ${QtOpenGLWidgets_SOURCE_DIR}
                                  ${QtOpenGLWidgets_GEN_DIR})
 
 set(QtOpenGLWidgets_libraries pyside6
-                              ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                              ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                              ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES}
-                              ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
                               ${Qt${QT_MAJOR_VERSION}OpenGLWidgets_LIBRARIES})
 
 set(QtOpenGLWidgets_deps QtOpenGL QtWidgets)
diff --git a/sources/pyside6/PySide6/QtOpenGLWidgets/typesystem_openglwidgets.xml b/sources/pyside6/PySide6/QtOpenGLWidgets/typesystem_openglwidgets.xml
index 092902402..1e308a3f2 100644
--- a/sources/pyside6/PySide6/QtOpenGLWidgets/typesystem_openglwidgets.xml
+++ b/sources/pyside6/PySide6/QtOpenGLWidgets/typesystem_openglwidgets.xml
@@ -3,12 +3,14 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtOpenGLWidgets">
+<typesystem package="PySide6.QtOpenGLWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no" />
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no" />
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no" />
 
   <object-type name="QOpenGLWidget">
       <enum-type name="UpdateBehavior"/>
+      <enum-type name="TargetBuffer" since="6.5"/>
   </object-type>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtPdf/CMakeLists.txt b/sources/pyside6/PySide6/QtPdf/CMakeLists.txt
index 1847a6c46..5b9c1457d 100644
--- a/sources/pyside6/PySide6/QtPdf/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtPdf/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtPdf)
 
 set(QtPdf_SRC
@@ -6,6 +9,7 @@ ${QtPdf_GEN_DIR}/qpdfdocument_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdfdocumentrenderoptions_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdfpagerenderer_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdflink_wrapper.cpp
+${QtPdf_GEN_DIR}/qpdflinkmodel_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdfpagenavigator_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdfsearchmodel_wrapper.cpp
 ${QtPdf_GEN_DIR}/qpdfselection_wrapper.cpp
@@ -25,10 +29,7 @@ set(QtPdf_include_dirs ${QtPdf_SOURCE_DIR}
                        ${QtNetwork_GEN_DIR})
 
 set(QtPdf_libraries pyside6
-    ${Qt${QT_MAJOR_VERSION}Pdf_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES})
+                    ${Qt${QT_MAJOR_VERSION}Pdf_LIBRARIES})
 
 set(QtPdf_deps QtCore QtGui QtNetwork)
 
diff --git a/sources/pyside6/PySide6/QtPdf/typesystem_pdf.xml b/sources/pyside6/PySide6/QtPdf/typesystem_pdf.xml
index 2cf7b886b..e008e4880 100644
--- a/sources/pyside6/PySide6/QtPdf/typesystem_pdf.xml
+++ b/sources/pyside6/PySide6/QtPdf/typesystem_pdf.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtPdf">
+<typesystem package="PySide6.QtPdf"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <object-type name="QPdfBookmarkModel">
@@ -15,15 +16,20 @@
         <enum-type name="MetaDataField"/>
         <enum-type name="PageModelRole"/>
     </object-type>
-    <value-type name="QPdfDocumentRenderOptions"/>
+    <value-type name="QPdfDocumentRenderOptions">
+        <enum-type name="RenderFlag" flags="RenderFlags" since="6.5"/>
+        <enum-type name="Rotation" since="6.5"/>
+    </value-type>
     <object-type name="QPdfPageRenderer">
         <enum-type name="RenderMode"/>
-        <enum-type name="RenderFlag" flags="RenderFlags"/>
     </object-type>
     <value-type name="QPdfLink"/>
     <object-type name="QPdfPageNavigator"/>
     <object-type name="QPdfSearchModel">
         <enum-type name="Role"/>
     </object-type>
+    <object-type name="QPdfLinkModel" since="6.6">
+        <enum-type name="Role"/>
+    </object-type>
     <object-type name="QPdfSelection"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtPdfWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtPdfWidgets/CMakeLists.txt
index 1e0fbed29..de1335f8a 100644
--- a/sources/pyside6/PySide6/QtPdfWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtPdfWidgets/CMakeLists.txt
@@ -1,6 +1,10 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtPdfWidgets)
 
 set(QtPdfWidgets_SRC
+${QtPdfWidgets_GEN_DIR}/qpdfpageselector_wrapper.cpp
 ${QtPdfWidgets_GEN_DIR}/qpdfview_wrapper.cpp
 # module is always needed
 ${QtPdfWidgets_GEN_DIR}/qtpdfwidgets_module_wrapper.cpp
@@ -22,12 +26,7 @@ set(QtPdfWidgets_include_dirs ${QtPdfWidgets_SOURCE_DIR}
                               ${QtPdf_GEN_DIR})
 
 set(QtPdfWidgets_libraries pyside6
-    ${Qt${QT_MAJOR_VERSION}Pdf_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}PdfWidgets_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-    ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES})
+                           ${Qt${QT_MAJOR_VERSION}PdfWidgets_LIBRARIES})
 
 set(QtPdfWidgets_deps QtCore QtGui QtNetwork QtWidgets QtPdf)
 
diff --git a/sources/pyside6/PySide6/QtPdfWidgets/typesystem_pdfwidgets.xml b/sources/pyside6/PySide6/QtPdfWidgets/typesystem_pdfwidgets.xml
index 16ed4f2ce..5df72075c 100644
--- a/sources/pyside6/PySide6/QtPdfWidgets/typesystem_pdfwidgets.xml
+++ b/sources/pyside6/PySide6/QtPdfWidgets/typesystem_pdfwidgets.xml
@@ -3,11 +3,13 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtPdfWidgets">
+<typesystem package="PySide6.QtPdfWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
     <load-typesystem name="QtPdf/typesystem_pdf.xml" generate="no"/>
+    <object-type name="QPdfPageSelector" since="6.6"/>
     <object-type name="QPdfView">
         <enum-type name="PageMode"/>
         <enum-type name="ZoomMode"/>
diff --git a/sources/pyside6/PySide6/QtPositioning/CMakeLists.txt b/sources/pyside6/PySide6/QtPositioning/CMakeLists.txt
index 125c18ce5..cad6dcb74 100644
--- a/sources/pyside6/PySide6/QtPositioning/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtPositioning/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtPositioning)
 
 set(QtPositioning_OPTIONAL_SRC )
@@ -20,6 +23,7 @@ ${QtPositioning_GEN_DIR}/qgeosatelliteinfo_wrapper.cpp
 ${QtPositioning_GEN_DIR}/qgeosatelliteinfosource_wrapper.cpp
 ${QtPositioning_GEN_DIR}/qgeoshape_wrapper.cpp
 ${QtPositioning_GEN_DIR}/qnmeapositioninfosource_wrapper.cpp
+${QtPositioning_GEN_DIR}/qnmeasatelliteinfosource_wrapper.cpp
 # module is always needed
 ${QtPositioning_GEN_DIR}/qtpositioning_module_wrapper.cpp
 )
@@ -43,3 +47,14 @@ create_pyside_module(NAME QtPositioning
                      TYPESYSTEM_PATH QtPositioning_SOURCE_DIR
                      SOURCES QtPositioning_SRC
                      DROPPED_ENTRIES QtPositioning_DROPPED_ENTRIES)
+
+if (APPLE)
+    # The QtLocation permission plugin cannot be linked to QtCore.abi3.so because for a framework
+    # build of Qt, the QtCore framework bundle must be loaded before calling
+    # Q_IMPORT_PLUGIN(QDarwinLocationPermissionPlugin)
+    set(permission_plugin_name "QDarwinLocationPermissionPlugin")
+    set(permission_plugin "${QT_CMAKE_EXPORT_NAMESPACE}::${permission_plugin_name}")
+    set_target_properties(QtPositioning PROPERTIES "_qt_has_${permission_plugin_name}_usage_description" TRUE)
+    # importing the plugin
+    qt6_import_plugins(QtPositioning INCLUDE ${permission_plugin})
+endif()
diff --git a/sources/pyside6/PySide6/QtPositioning/typesystem_positioning.xml b/sources/pyside6/PySide6/QtPositioning/typesystem_positioning.xml
index 359a7062d..8dac3f00d 100644
--- a/sources/pyside6/PySide6/QtPositioning/typesystem_positioning.xml
+++ b/sources/pyside6/PySide6/QtPositioning/typesystem_positioning.xml
@@ -3,8 +3,11 @@
 // Copyright (C) 2018 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtPositioning">
+<typesystem package="PySide6.QtPositioning"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
+  <inject-code class="native" position="beginning" file="../glue/qtpositioning.cpp"
+               snippet="darwin_location_permission_plugin"/>
   <value-type name="QGeoAddress"/>
   <value-type name="QGeoAreaMonitorInfo"/>
   <object-type name="QGeoAreaMonitorSource">
@@ -41,4 +44,8 @@
   <object-type name="QNmeaPositionInfoSource">
       <enum-type name="UpdateMode"/>
   </object-type>
+  <object-type name="QNmeaSatelliteInfoSource">
+      <enum-type name="UpdateMode"/>
+      <enum-type name="SatelliteInfoParseStatus"/>
+  </object-type>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtPrintSupport/CMakeLists.txt b/sources/pyside6/PySide6/QtPrintSupport/CMakeLists.txt
index 70a3d8f67..fb0db5f83 100644
--- a/sources/pyside6/PySide6/QtPrintSupport/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtPrintSupport/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtPrintSupport)
 
 set(QtPrintSupport_SRC
@@ -22,14 +25,11 @@ set(QtPrintSupport_include_dirs ${QtPrintSupport_SOURCE_DIR}
                                 ${libpyside_SOURCE_DIR}
                                 ${QtCore_GEN_DIR}
                                 ${QtGui_GEN_DIR}
-                                ${QtWidgets_GEN_DIR}
-                                )
+                                ${QtWidgets_GEN_DIR})
+
 set(QtPrintSupport_libraries    pyside6
-                                ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                                ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                                ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                                ${Qt${QT_MAJOR_VERSION}PrintSupport_LIBRARIES}
-                                )
+                                ${Qt${QT_MAJOR_VERSION}PrintSupport_LIBRARIES})
+
 set(QtPrintSupport_deps QtWidgets)
 create_pyside_module(NAME QtPrintSupport
                      INCLUDE_DIRS QtPrintSupport_include_dirs
diff --git a/sources/pyside6/PySide6/QtPrintSupport/typesystem_printsupport.xml b/sources/pyside6/PySide6/QtPrintSupport/typesystem_printsupport.xml
index 58d4a54b3..46973a5f9 100644
--- a/sources/pyside6/PySide6/QtPrintSupport/typesystem_printsupport.xml
+++ b/sources/pyside6/PySide6/QtPrintSupport/typesystem_printsupport.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtPrintSupport">
+<typesystem package="PySide6.QtPrintSupport"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
     <load-typesystem name="QtPrintSupport/typesystem_printsupport_common.xml" generate="yes"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtQml/CMakeLists.txt b/sources/pyside6/PySide6/QtQml/CMakeLists.txt
index a2a0af2cd..87de1d7dd 100644
--- a/sources/pyside6/PySide6/QtQml/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtQml/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtQml)
 
 qt_wrap_cpp(QPYQMLPARSERSTATUS_MOC "${pyside6_SOURCE_DIR}/qpyqmlparserstatus.h")
@@ -60,8 +63,6 @@ set(QtQml_include_dirs  ${QtQml_SOURCE_DIR}
                         ${QtQml_GEN_DIR})
 
 set(QtQml_libraries pyside6 pyside6qml
-                    ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                    ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
                     ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES})
 
 set(QtQml_deps QtNetwork)
diff --git a/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp
index d498f5bb0..ca3dfebed 100644
--- a/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp
+++ b/sources/pyside6/PySide6/QtQml/pysideqmlvolatilebool.cpp
@@ -3,6 +3,7 @@
 
 #include "pysideqmlvolatilebool.h"
 
+#include <pep384ext.h>
 #include <signature.h>
 
 #include <QtCore/QDebug>
@@ -30,8 +31,7 @@ QtQml_VolatileBoolObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (ok < 0)
         return nullptr;
 
-    QtQml_VolatileBoolObject *self
-            = reinterpret_cast<QtQml_VolatileBoolObject *>(type->tp_alloc(type, 0));
+    auto *self = PepExt_TypeCallAlloc<QtQml_VolatileBoolObject>(type, 0);
 
     if (self != nullptr)
         self->flag = new AtomicBool(ok);
@@ -49,7 +49,10 @@ static void QtQml_VolatileBoolObject_dealloc(PyObject *self)
 static PyObject *
 QtQml_VolatileBoolObject_get(QtQml_VolatileBoolObject *self)
 {
-    return *self->flag ? Py_True : Py_False;
+    if (*self->flag) {
+        Py_RETURN_TRUE;
+    }
+    Py_RETURN_FALSE;
 }
 
 static PyObject *
@@ -63,10 +66,8 @@ QtQml_VolatileBoolObject_set(QtQml_VolatileBoolObject *self, PyObject *args)
     }
 
     ok = PyObject_IsTrue(value);
-    if (ok < 0) {
-        PyErr_SetString(PyExc_TypeError, "Not a boolean value.");
-        return nullptr;
-    }
+    if (ok < 0)
+        return PyErr_Format(PyExc_TypeError, "Not a boolean value.");
 
     *self->flag = ok > 0;
 
@@ -113,25 +114,31 @@ QtQml_VolatileBoolObject_str(QtQml_VolatileBoolObject *self)
     return s;
 }
 
-static PyType_Slot QtQml_VolatileBoolType_slots[] = {
-    {Py_tp_repr, reinterpret_cast<void *>(QtQml_VolatileBoolObject_repr)},
-    {Py_tp_str, reinterpret_cast<void *>(QtQml_VolatileBoolObject_str)},
-    {Py_tp_methods, reinterpret_cast<void *>(QtQml_VolatileBoolObject_methods)},
-    {Py_tp_new, reinterpret_cast<void *>(QtQml_VolatileBoolObject_new)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(QtQml_VolatileBoolObject_dealloc)},
-    {0, 0}
-};
-static PyType_Spec QtQml_VolatileBoolType_spec = {
-    "2:PySide6.QtQml.VolatileBool",
-    sizeof(QtQml_VolatileBoolObject),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    QtQml_VolatileBoolType_slots,
-};
+static PyTypeObject *createVolatileBoolType()
+{
+    PyType_Slot QtQml_VolatileBoolType_slots[] = {
+        {Py_tp_repr, reinterpret_cast<void *>(QtQml_VolatileBoolObject_repr)},
+        {Py_tp_str, reinterpret_cast<void *>(QtQml_VolatileBoolObject_str)},
+        {Py_tp_methods, reinterpret_cast<void *>(QtQml_VolatileBoolObject_methods)},
+        {Py_tp_new, reinterpret_cast<void *>(QtQml_VolatileBoolObject_new)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(QtQml_VolatileBoolObject_dealloc)},
+        {0, 0}
+    };
+
+    PyType_Spec QtQml_VolatileBoolType_spec = {
+        "2:PySide6.QtQml.VolatileBool",
+        sizeof(QtQml_VolatileBoolObject),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        QtQml_VolatileBoolType_slots,
+    };
+
+    return SbkType_FromSpec(&QtQml_VolatileBoolType_spec);
+}
 
 PyTypeObject *QtQml_VolatileBool_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&QtQml_VolatileBoolType_spec);
+    static auto *type = createVolatileBoolType();
     return type;
 }
 
diff --git a/sources/pyside6/PySide6/QtQml/typesystem_qml.xml b/sources/pyside6/PySide6/QtQml/typesystem_qml.xml
index 0275984a6..3392ef379 100644
--- a/sources/pyside6/PySide6/QtQml/typesystem_qml.xml
+++ b/sources/pyside6/PySide6/QtQml/typesystem_qml.xml
@@ -3,20 +3,23 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtQml">
+<typesystem package="PySide6.QtQml"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
 
+    <rejection class="QQmlPrivate"/>
+
     <inject-code class="target" position="declaration">
     // Volatile Bool Ptr type definition for QQmlIncubationController::incubateWhile(std::atomic&lt;bool&gt; *, int)
     #include &lt;atomic&gt;
 
     using AtomicBool = std::atomic&lt;bool&gt;;
 
-    typedef struct {
+    struct QtQml_VolatileBoolObject {
         PyObject_HEAD
         AtomicBool *flag;
-    } QtQml_VolatileBoolObject;
+    };
     </inject-code>
 
     <inject-code class="native" position="beginning">
@@ -35,7 +38,7 @@
              in generator tests folder. -->
     </primitive-type>
 
-    <enum-type name="QQmlModuleImportSpecialVersions"/>
+    <enum-type name="QQmlModuleImportSpecialVersions" doc-file="qqmlengine"/>
 
     <!-- expose QQmlIncubationController::incubateWhile() (see
          QtQml_VolatileBoolTypeF/pysideqmlvolatilebool.h) -->
@@ -43,33 +46,51 @@
         <value-type name="atomic" generate="no"/>
     </namespace-type>
 
-    <add-function signature="qmlAttachedPropertiesObject(PyTypeObject*,QObject*,bool=true)"
+    <add-function signature="qmlAttachedPropertiesObject(PyTypeObject*@type_obj@,QObject*,bool=true)"
                   return-type="QObject*">
         <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlattachedpropertiesobject"/>
     </add-function>
 
-    <add-function signature="qmlRegisterType(PyTypeObject,const char*,int,int,const char*)" return-type="int">
+    <add-function signature="qmlRegisterType(PyTypeObject@type_obj@,const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@)" return-type="int">
         <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregistertype"/>
+        <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                              snippet="qmlregistertype"/>
+        <modify-argument index="2" pyi-type="str"/>
     </add-function>
 
-    <add-function signature="qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*,PyObject*)" return-type="int">
+    <add-function signature="qmlRegisterSingletonType(PyTypeObject@type_obj@,const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@,PyObject*@callback@)" return-type="int">
       <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregistersingletontype_qobject_callback"/>
+      <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                            snippet="qmlregistersingletontype_qobject_callback"/>
+      <modify-argument index="2" pyi-type="str"/>
     </add-function>
 
-    <add-function signature="qmlRegisterSingletonType(PyTypeObject,const char*,int,int,const char*)" return-type="int">
+    <add-function signature="qmlRegisterSingletonType(PyTypeObject@type_obj@,const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@)" return-type="int">
       <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregistersingletontype_qobject_nocallback"/>
+      <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                            snippet="qmlregistersingletontype_qobject_nocallback"/>
+      <modify-argument index="2" pyi-type="str"/>
     </add-function>
 
-    <add-function signature="qmlRegisterSingletonType(const char*,int,int,const char*,PyObject*)" return-type="int">
+    <add-function signature="qmlRegisterSingletonType(const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@,PyObject*@callback@)" return-type="int">
       <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregistersingletontype_qjsvalue"/>
+      <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                            snippet="qmlregistersingletontype_qjsvalue"/>
+      <modify-argument index="1" pyi-type="str"/>
     </add-function>
 
-    <add-function signature="qmlRegisterSingletonInstance(PyTypeObject,const char*,int,int,const char*,PyObject*)" return-type="int">
+    <add-function signature="qmlRegisterSingletonInstance(PyTypeObject@type_obj@,const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@,PyObject*@callback@)" return-type="int">
       <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregistersingletoninstance"/>
+      <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                            snippet="qmlregistersingletoninstance"/>
+      <modify-argument index="2" pyi-type="str"/>
     </add-function>
 
-    <add-function signature="qmlRegisterUncreatableType(PyTypeObject,const char*,int,int,const char*,const char*)" return-type="int">
+    <add-function signature="qmlRegisterUncreatableType(PyTypeObject@type_obj@,const char*@uri@,int@version_major@,int@version_minor@,const char*@qml_name@,const char*@message@)" return-type="int">
         <inject-code class="target" file="../glue/qtqml.cpp" snippet="qmlregisteruncreatabletype"/>
+        <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                              snippet="qmlregisteruncreatabletype"/>
+        <modify-argument index="2" pyi-type="str"/>
     </add-function>
 
     <add-function signature="QmlElement(PyObject*)" return-type="PyObject*">
@@ -89,7 +110,7 @@
             <modify-argument index="return" pyi-type="Optional[PySide6.QtQml.QJSEngine]"/>
         </modify-function>
     </function>
-    <function signature="qmlClearTypeRegistrations()"/>
+    <function signature="qmlClearTypeRegistrations()" doc-file="qqmlengine"/>
     <function signature="qmlContext(const QObject*)">
         <modify-function>
             <modify-argument index="return" pyi-type="Optional[PySide6.QtQml.QQmlContext]"/>
@@ -100,12 +121,15 @@
             <modify-argument index="return" pyi-type="Optional[PySide6.QtQml.QQmlEngine]"/>
         </modify-function>
      </function>
-    <function signature="qmlProtectModule(const char*,int)"/>
-    <function signature="qmlRegisterModule(const char*,int,int)"/>
-    <function signature="qmlTypeId(const char*,int,int,const char*)"/>
-    <function signature="qmlRegisterType(const QUrl &amp;,const char *,int,int,const char *)"/>
-    <function signature="qmlRegisterSingletonType(const QUrl &amp;,const char *,int,int,const char *)"/>
-    <function signature="qmlRegisterUncreatableMetaObject(const QMetaObject&amp;,const char*,int,int, const char*,const QString&amp;)"/>
+    <function signature="qmlProtectModule(const char*,int)" doc-file="qqmlengine"/>
+    <function signature="qmlRegisterModule(const char*,int,int)" doc-file="qqmlengine"/>
+    <function signature="qmlTypeId(const char*,int,int,const char*)" doc-file="qqmlengine"/>
+    <function signature="qmlRegisterType(const QUrl &amp;,const char *,int,int,const char *)"
+              doc-file="qqmlengine"/>
+    <function signature="qmlRegisterSingletonType(const QUrl &amp;,const char *,int,int,const char *)"
+              doc-file="qqmlengine"/>
+    <function signature="qmlRegisterUncreatableMetaObject(const QMetaObject&amp;,const char*,int,int, const char*,const QString&amp;)"
+              doc-file="qqmlengine"/>
 
     <enum-type identified-by-value="QML_HAS_ATTACHED_PROPERTIES">
         <extra-includes>
@@ -149,6 +173,7 @@
             <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qfile-path-1"/>
         </modify-function>
         <modify-function signature="load(const QUrl &amp;)" allow-thread="yes" overload-number="2"/>
+        <modify-function signature="loadFromModule(QAnyStringView,QAnyStringView)" allow-thread="yes"/>
     </object-type>
     <object-type name="QQmlComponent">
         <enum-type name="CompilationMode"/>
@@ -159,6 +184,10 @@
         <modify-function signature="QQmlComponent(QQmlEngine*,QString,QQmlComponent::CompilationMode,QObject*)" allow-thread="yes"/>
         <modify-function signature="QQmlComponent(QQmlEngine*,QUrl,QObject*)" allow-thread="yes"/>
         <modify-function signature="QQmlComponent(QQmlEngine*,QUrl,QQmlComponent::CompilationMode,QObject*)" allow-thread="yes"/>
+        <modify-function signature="loadFromModule(QAnyStringView,QAnyStringView,QQmlComponent::CompilationMode)" allow-thread="yes"/>
+        <modify-function signature="loadUrl(QUrl)" allow-thread="yes"/>
+        <modify-function signature="loadUrl(QUrl,QQmlComponent::CompilationMode)" allow-thread="yes"/>
+        <modify-function signature="setData(QByteArray,QUrl)" allow-thread="yes"/>
     </object-type>
     <object-type name="QQmlContext">
         <value-type name="PropertyPair"/>
@@ -186,6 +215,30 @@
             <modify-argument index="1"><replace-type modified-type="PyPathLike"/></modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtcore.cpp" snippet="qfile-path-1"/>
         </modify-function>
+        <add-function signature="singletonInstance(int@qmlTypeId@)"
+                      return-type="QObject*">
+            <!-- Suppress return value heuristics -->
+            <modify-argument index="return"
+                             pyi-type="Union[PySide6.QtCore.QObject, PySide6.QtQml.QJSValue, None]">
+                <define-ownership class="target" owner="default"/>
+            </modify-argument>
+            <inject-code class="target" file="../glue/qtqml.cpp"
+                         snippet="qqmlengine-singletoninstance-qmltypeid"/>
+            <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                                  snippet="qqmlengine-singletoninstance-qmltypeid"/>
+        </add-function>
+        <add-function signature="singletonInstance(QString@uri@,QString@typeName@)"
+                      return-type="QObject*">
+            <!-- Suppress return value heuristics -->
+            <modify-argument index="return"
+                             pyi-type="Union[PySide6.QtCore.QObject, PySide6.QtQml.QJSValue, None]">
+                <define-ownership class="target" owner="default"/>
+            </modify-argument>
+            <inject-code class="target" file="../glue/qtqml.cpp"
+                         snippet="qqmlengine-singletoninstance-typename"/>
+            <inject-documentation format="target" mode="append" file="../doc/qtqml_functions.rst"
+                                  snippet="qqmlengine-singletoninstance-typename"/>
+        </add-function>
     </object-type>
 
     <object-type name="QQmlExpression">
@@ -193,7 +246,7 @@
             <modify-argument index="1">
                 <remove-argument />
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[Any, bool]">
                 <replace-type modified-type="PyTuple"/>
             </modify-argument>
             <inject-code class="target" position="beginning">
@@ -255,7 +308,7 @@
             <modify-argument index="1">
                 <remove-argument />
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[float, bool]">
                 <replace-type modified-type="PyTuple"/>
             </modify-argument>
             <inject-code class="target" position="beginning">
@@ -266,7 +319,7 @@
             <modify-argument index="1">
                 <remove-argument />
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, bool]">
                 <replace-type modified-type="PyTuple"/>
             </modify-argument>
             <inject-code class="target" position="beginning">
diff --git a/sources/pyside6/PySide6/QtQuick/CMakeLists.txt b/sources/pyside6/PySide6/QtQuick/CMakeLists.txt
index 22d65d989..775230242 100644
--- a/sources/pyside6/PySide6/QtQuick/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtQuick/CMakeLists.txt
@@ -1,11 +1,24 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtQuick)
 
+set(QtQuick_DROPPED_ENTRIES)
+
 set(QtQuick_registerType "${QtQuick_SOURCE_DIR}/pysidequickregistertype.cpp")
 
+# Exclude sources that have clashing static helper functions named "renderstate_..."
+set(QtQuick_SRC_UNITY_EXCLUDED_SRC
+    ${QtQuick_GEN_DIR}/qsgrendernode_renderstate_wrapper.cpp
+    ${QtQuick_GEN_DIR}/qsgmaterialshader_renderstate_wrapper.cpp
+)
+
+set_property(SOURCE ${QtQuick_SRC_UNITY_EXCLUDED_SRC}
+             PROPERTY SKIP_UNITY_BUILD_INCLUSION ON)
+
 set(QtQuick_SRC
+${QtQuick_SRC_UNITY_EXCLUDED_SRC}
 ${QtQuick_GEN_DIR}/qquickasyncimageprovider_wrapper.cpp
-${QtQuick_GEN_DIR}/qquickframebufferobject_wrapper.cpp
-${QtQuick_GEN_DIR}/qquickframebufferobject_renderer_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickgraphicsconfiguration_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickgraphicsdevice_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquicktexturefactory_wrapper.cpp
@@ -19,9 +32,12 @@ ${QtQuick_GEN_DIR}/qsharedpointer_qquickitemgrabresult_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickpainteditem_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickrendercontrol_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickrendertarget_wrapper.cpp
+${QtQuick_GEN_DIR}/qquickrhiitemrenderer_wrapper.cpp
+${QtQuick_GEN_DIR}/qquickrhiitem_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquicktextdocument_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickview_wrapper.cpp
 ${QtQuick_GEN_DIR}/qquickwindow_wrapper.cpp
+${QtQuick_GEN_DIR}/qquickwindow_graphicsstateinfo_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgbasicgeometrynode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgclipnode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgdynamictexture_wrapper.cpp
@@ -33,21 +49,25 @@ ${QtQuick_GEN_DIR}/qsggeometry_point2d_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsggeometry_texturedpoint2d_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsggeometry_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsggeometrynode_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgimagenode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgmaterial_wrapper.cpp
-${QtQuick_GEN_DIR}/qsgmaterialshader_renderstate_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgmaterialshader_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgmaterialshader_graphicspipelinestate_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgmaterialtype_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgninepatchnode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgnode_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgnodevisitor_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgopacitynode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgopaquetexturematerial_wrapper.cpp
 #${QtQuick_GEN_DIR}/qsgsimplematerial_wrapper.cpp
 #${QtQuick_GEN_DIR}/qsgsimplematerialshader_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgrectanglenode_wrapper.cpp
-${QtQuick_GEN_DIR}/qsgrendernode_renderstate_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgrendernode_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgrootnode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgsimplerectnode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgsimpletexturenode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgrendererinterface_wrapper.cpp
+${QtQuick_GEN_DIR}/qsgtextnode_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgtexture_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgtexturematerial_wrapper.cpp
 ${QtQuick_GEN_DIR}/qsgtextureprovider_wrapper.cpp
@@ -62,28 +82,32 @@ set(QtQuick_include_dirs  ${QtQuick_SOURCE_DIR}
                           ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Core_PRIVATE_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
-                          ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Network_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Qml_PRIVATE_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Quick_INCLUDE_DIRS}
                           ${libpyside_SOURCE_DIR}
                           ${QtGui_GEN_DIR}
-                          ${QtOpenGL_GEN_DIR}
                           ${QtCore_GEN_DIR}
                           ${QtNetwork_GEN_DIR}
                           ${QtQml_GEN_DIR}
                           ${QtQuick_GEN_DIR})
 
 set(QtQuick_libraries pyside6 pyside6qml
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES}
                       ${Qt${QT_MAJOR_VERSION}Quick_LIBRARIES})
 
-set(QtQuick_deps QtGui QtOpenGL QtNetwork QtQml)
+set(QtQuick_deps QtGui QtNetwork QtQml)
+
+check_qt_opengl("Quick" QtQuick_include_dirs QtQuick_deps
+                QtQuick_DROPPED_ENTRIES)
+
+if (Qt${QT_MAJOR_VERSION}OpenGL_FOUND)
+    list(APPEND QtQuick_SRC
+         ${QtQuick_GEN_DIR}/qquickframebufferobject_wrapper.cpp
+         ${QtQuick_GEN_DIR}/qquickframebufferobject_renderer_wrapper.cpp)
+else()
+    list(APPEND QtQuick_DROPPED_ENTRIES QQuickFramebufferObject)
+endif()
 
 create_pyside_module(NAME QtQuick
                      INCLUDE_DIRS QtQuick_include_dirs
@@ -91,4 +115,5 @@ create_pyside_module(NAME QtQuick
                      DEPS QtQuick_deps
                      TYPESYSTEM_PATH QtQuick_SOURCE_DIR
                      SOURCES QtQuick_SRC
-                     STATIC_SOURCES QtQuick_registerType)
+                     STATIC_SOURCES QtQuick_registerType
+                     DROPPED_ENTRIES QtQuick_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/QtQuick/pysidequickregistertype.cpp b/sources/pyside6/PySide6/QtQuick/pysidequickregistertype.cpp
index f15e1f3d5..f7749b4e7 100644
--- a/sources/pyside6/PySide6/QtQuick/pysidequickregistertype.cpp
+++ b/sources/pyside6/PySide6/QtQuick/pysidequickregistertype.cpp
@@ -9,7 +9,10 @@
 #include <shiboken.h>
 
 #include <QtQuick/QQuickPaintedItem>
-#include <QtQuick/QQuickFramebufferObject>
+
+#if QT_CONFIG(opengl) || QT_CONFIG(opengles2) || QT_CONFIG(opengles3)
+#  include <QtQuick/QQuickFramebufferObject>
+#endif
 
 bool pyTypeObjectInheritsFromClass(PyTypeObject *pyObjType, const char *classPtrName)
 {
@@ -22,7 +25,7 @@ bool pyTypeObjectInheritsFromClass(PyTypeObject *pyObjType, const char *classPtr
 template <class WrappedClass>
 bool registerTypeIfInheritsFromClass(const char *classPtrName,
                                      PyTypeObject *typeToRegister,
-                                     QQmlPrivate::RegisterType *type)
+                                     QQmlPrivate::RegisterTypeAndRevisions *type)
 {
     if (!pyTypeObjectInheritsFromClass(typeToRegister, classPtrName))
         return false;
@@ -35,7 +38,7 @@ bool registerTypeIfInheritsFromClass(const char *classPtrName,
     return true;
 }
 
-bool quickRegisterType(PyObject *pyObj, QQmlPrivate::RegisterType *type)
+bool quickRegisterType(PyObject *pyObj, QQmlPrivate::RegisterTypeAndRevisions *type)
 {
     using namespace Shiboken;
 
@@ -51,8 +54,10 @@ bool quickRegisterType(PyObject *pyObj, QQmlPrivate::RegisterType *type)
 
     return registerTypeIfInheritsFromClass<QQuickPaintedItem>("QQuickPaintedItem*",
                                                               pyObjType, type)
+#if QT_CONFIG(opengl) || QT_CONFIG(opengles2) || QT_CONFIG(opengles3)
         || registerTypeIfInheritsFromClass<QQuickFramebufferObject>("QQuickFramebufferObject*",
                                                                     pyObjType, type)
+#endif
         || registerTypeIfInheritsFromClass<QQuickItem>("QQuickItem*",
                                                        pyObjType, type);
 }
@@ -62,7 +67,9 @@ void PySide::initQuickSupport(PyObject *module)
     Q_UNUSED(module);
     // We need to manually register a pointer version of these types in order for them to be used as property types.
     qRegisterMetaType<QQuickPaintedItem*>("QQuickPaintedItem*");
+#if QT_CONFIG(opengl) || QT_CONFIG(opengles2) || QT_CONFIG(opengles3)
     qRegisterMetaType<QQuickFramebufferObject*>("QQuickFramebufferObject*");
+#endif
     qRegisterMetaType<QQuickItem*>("QQuickItem*");
 
     Qml::setQuickRegisterItemFunction(quickRegisterType);
diff --git a/sources/pyside6/PySide6/QtQuick/typesystem_quick.xml b/sources/pyside6/PySide6/QtQuick/typesystem_quick.xml
index 3684c7d36..61aed6005 100644
--- a/sources/pyside6/PySide6/QtQuick/typesystem_quick.xml
+++ b/sources/pyside6/PySide6/QtQuick/typesystem_quick.xml
@@ -3,11 +3,15 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtQuick">
+<typesystem package="PySide6.QtQuick"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
+    <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <!-- QQuickFramebufferObject::Renderer needs QOpenGLFramebufferObject -->
+    <?if !no_QtOpenGL?>
     <load-typesystem name="QtOpenGL/typesystem_opengl.xml" generate="no"/>
+    <?endif?>
     <load-typesystem name="QtQml/typesystem_qml.xml" generate="no"/>
 
     <smart-pointer-type name="QSharedPointer" type="shared" getter="data"
@@ -49,7 +53,7 @@
     <object-type name="QQuickImageResponse"/>
 
     <object-type name="QQuickTransform"/>
-    <object-type name="QQuickItem" delete-in-main-thread="true">
+    <object-type name="QQuickItem" delete-in-main-thread="true" polymorphic-base="true">
         <value-type name="UpdatePaintNodeData"/>
         <enum-type name="Flag" flags="Flags"/>
         <enum-type name="ItemChange"/>
@@ -58,16 +62,28 @@
             <modify-argument index="2">
                 <remove-argument />
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, PySide6.QtGui.QTransform]">
                 <replace-type modified-type="PyTuple"/>
             </modify-argument>
             <inject-code class="target" position="beginning">
                 <insert-template name="fix_args,bool*"/>
             </inject-code>
         </modify-function>
+        <modify-function signature="updatePaintNode(QSGNode*,QQuickItem::UpdatePaintNodeData*)">
+          <modify-argument index="return">
+            <define-ownership class="native" owner="c++"/>
+            <define-ownership class="target" owner="default"/>
+          </modify-argument>
+        </modify-function>
+
         <!-- TODO: Find a way to wrap `union ItemChangeData {}` -->
     </object-type>
 
+    <object-type name="QQuickRhiItemRenderer" since="6.7"/>
+    <object-type name="QQuickRhiItem" since="6.7">
+        <enum-type name="TextureFormat"/>
+    </object-type>
+
     <object-type name="QQuickItemGrabResult"/>
 
     <object-type name="QQuickPaintedItem">
@@ -82,7 +98,9 @@
         <modify-function signature="^fromVulkanImage\(.*$" remove="all"/>
     </value-type>
 
-    <object-type name="QQuickTextDocument"/>
+    <object-type name="QQuickTextDocument">
+        <enum-type name="Status" since="6.7"/>
+    </object-type>
 
     <object-type name="QQuickView">
         <enum-type name="ResizeMode"/>
@@ -94,13 +112,24 @@
         <enum-type name="RenderStage"/>
         <enum-type name="SceneGraphError"/>
         <enum-type name="TextRenderType"/>
+        <value-type name="GraphicsStateInfo"/>
+    </object-type>
+
+    <object-type name="QSGBasicGeometryNode">
+        <modify-function signature="setGeometry(QSGGeometry*)">
+            <modify-argument index="1">
+              <define-ownership class="target" owner="c++"/>
+            </modify-argument>
+        </modify-function>
     </object-type>
 
-    <object-type name="QSGBasicGeometryNode"/>
     <object-type name="QSGClipNode"/>
     <object-type name="QSGDynamicTexture"/>
     <object-type name="QSGFlatColorMaterial"/>
     <object-type name="QSGGeometry">
+        <extra-includes>
+            <include file-name="algorithm" location="global"/>
+        </extra-includes>
         <enum-type name="DataPattern"/>
         <enum-type name="AttributeType"/>
         <enum-type name="DrawingMode" python-type="IntEnum"/>
@@ -110,8 +139,38 @@
         <value-type name="ColoredPoint2D"/>
         <value-type name="Point2D"/>
         <value-type name="TexturedPoint2D"/>
+        <modify-function signature="vertexDataAsPoint2D()">
+            <modify-argument index="return">
+                <replace-type modified-type="PyObject*"/>
+            </modify-argument>
+            <inject-code class="target" file="../glue/qtquick.cpp" snippet="qsgeometry-vertexdataaspoint2d"/>
+        </modify-function>
+        <add-function signature="setVertexDataAsPoint2D(const QList&lt;QSGGeometry::Point2D&gt;&amp;@points@)">
+            <inject-code class="target" file="../glue/qtquick.cpp" snippet="qsgeometry-setvertexdataaspoint2d"/>
+            <inject-documentation format="target" mode="append">
+            Sets the vertex data from a list of QSGGeometry.Point2D.
+            The list size must match the allocated number of vertexes
+            as returned by QSGGeometry.vertexCount().
+            </inject-documentation>
+        </add-function>
+
+    </object-type>
+    <object-type name="QSGGeometryNode">
+        <modify-function signature="setMaterial(QSGMaterial*)">
+            <modify-argument index="1">
+              <define-ownership class="target" owner="c++"/>
+            </modify-argument>
+        </modify-function>
+        <modify-function signature="setOpaqueMaterial(QSGMaterial*)">
+            <modify-argument index="1">
+              <define-ownership class="target" owner="c++"/>
+            </modify-argument>
+        </modify-function>
+    </object-type>
+
+    <object-type name="QSGImageNode">
+        <enum-type name="TextureCoordinatesTransformFlag" flags="TextureCoordinatesTransformMode"/>
     </object-type>
-    <object-type name="QSGGeometryNode"/>
 
     <object-type name="QSGMaterial">
         <enum-type name="Flag" flags="Flags"/>
@@ -122,20 +181,35 @@
         <value-type name="RenderState">
             <enum-type name="DirtyState" flags="DirtyStates"/>
         </value-type>
+        <value-type name="GraphicsPipelineState">
+            <enum-type name="BlendFactor"/>
+            <enum-type name="ColorMaskComponent" flags="ColorMask"/>
+            <enum-type name="CullMode"/>
+            <enum-type name="PolygonMode"/>
+        </value-type>
         <modify-function signature="updateSampledImage(QSGMaterialShader::RenderState&amp;,int,QSGTexture**,QSGMaterial*,QSGMaterial*)" remove="all"/>
+        <!-- Private QRhi class -->
+        <modify-function signature="setShader(QSGMaterialShader::Stage,QShader)" remove="all"/>
     </object-type>
     <object-type name="QSGMaterialType"/>
+    <object-type name="QSGNinePatchNode"/>
     <object-type name="QSGNode">
         <enum-type name="DirtyStateBit" flags="DirtyState"/>
         <enum-type name="Flag" flags="Flags"/>
         <enum-type name="NodeType"/>
     </object-type>
+    <object-type name="QSGNodeVisitor"/>
+
     <object-type name="QSGOpacityNode"/>
     <object-type name="QSGOpaqueTextureMaterial"/>
     <object-type name="QSGSimpleRectNode"/>
     <object-type name="QSGSimpleTextureNode">
         <enum-type name="TextureCoordinatesTransformFlag" flags="TextureCoordinatesTransformMode"/>
     </object-type>
+    <object-type name="QSGTextNode" since="6.7">
+        <enum-type name="TextStyle"/>
+        <enum-type name="RenderType"/>
+    </object-type>
     <object-type name="QSGRectangleNode"/>
     <object-type name="QSGRendererInterface">
         <enum-type name="GraphicsApi"/>
@@ -150,6 +224,7 @@
         <enum-type name="RenderingFlag" flags="RenderingFlags"/>
         <object-type name="RenderState"/>
     </object-type>
+    <object-type name="QSGRootNode"/>
     <object-type name="QSGTexture">
         <enum-type name="AnisotropyLevel"/>
         <enum-type name="Filtering"/>
diff --git a/sources/pyside6/PySide6/QtQuick3D/CMakeLists.txt b/sources/pyside6/PySide6/QtQuick3D/CMakeLists.txt
index ecc12a26a..37f8ebfb1 100644
--- a/sources/pyside6/PySide6/QtQuick3D/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtQuick3D/CMakeLists.txt
@@ -1,12 +1,19 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtQuick3D)
 
+set (QtQuick3D_DROPPED_ENTRIES)
+
 set(QtQuick3D_SRC
 ${QtQuick3D_GEN_DIR}/qquick3d_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dobject_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dgeometry_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dgeometry_attribute_wrapper.cpp
+${QtQuick3D_GEN_DIR}/qquick3dgeometry_targetattribute_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dinstancing_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dinstancing_instancetableentry_wrapper.cpp
+${QtQuick3D_GEN_DIR}/qquick3drenderextension_wrapper.cpp
 ${QtQuick3D_GEN_DIR}/qquick3dtexturedata_wrapper.cpp
 # module is always needed
 ${QtQuick3D_GEN_DIR}/qtquick3d_module_wrapper.cpp
@@ -17,7 +24,6 @@ set(QtQuick3D_include_dirs  ${QtQuick3D_SOURCE_DIR}
                           ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Core_PRIVATE_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
-                          ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Network_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
                           ${Qt${QT_MAJOR_VERSION}Qml_PRIVATE_INCLUDE_DIRS}
@@ -25,7 +31,6 @@ set(QtQuick3D_include_dirs  ${QtQuick3D_SOURCE_DIR}
                           ${Qt${QT_MAJOR_VERSION}Quick3D_INCLUDE_DIRS}
                           ${libpyside_SOURCE_DIR}
                           ${QtGui_GEN_DIR}
-                          ${QtOpenGL_GEN_DIR}
                           ${QtCore_GEN_DIR}
                           ${QtNetwork_GEN_DIR}
                           ${QtQml_GEN_DIR}
@@ -33,19 +38,17 @@ set(QtQuick3D_include_dirs  ${QtQuick3D_SOURCE_DIR}
                           ${QtQuick3D_GEN_DIR})
 
 set(QtQuick3D_libraries pyside6
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Quick_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Quick3D_LIBRARIES})
+                        ${Qt${QT_MAJOR_VERSION}Quick3D_LIBRARIES})
+
+set(QtQuick3D_deps QtGui QtNetwork QtQml QtQuick)
 
-set(QtQuick3D_deps QtGui QtOpenGL QtNetwork QtQml QtQuick)
+check_qt_opengl("Quick3D" QtQuick3D_include_dirs QtQuick3D_deps
+                QtQuick3D_DROPPED_ENTRIES)
 
 create_pyside_module(NAME QtQuick3D
     INCLUDE_DIRS QtQuick3D_include_dirs
     LIBRARIES QtQuick3D_libraries
     DEPS QtQuick3D_deps
     TYPESYSTEM_PATH QtQuick3D_SOURCE_DIR
-    SOURCES QtQuick3D_SRC)
+    SOURCES QtQuick3D_SRC
+    DROPPED_ENTRIES QtQuick3D_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/QtQuick3D/typesystem_quick3d.xml b/sources/pyside6/PySide6/QtQuick3D/typesystem_quick3d.xml
index d2a145df7..fe8f4e700 100644
--- a/sources/pyside6/PySide6/QtQuick3D/typesystem_quick3d.xml
+++ b/sources/pyside6/PySide6/QtQuick3D/typesystem_quick3d.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtQuick3D">
+<typesystem package="PySide6.QtQuick3D"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtQuick/typesystem_quick.xml" generate="no"/>
 
     <object-type name="QQuick3D"/>
@@ -16,6 +17,7 @@
             <enum-type name="Semantic"/>
             <enum-type name="ComponentType"/>
         </value-type>
+        <value-type name="TargetAttribute" since="6.6"/>
         <enum-type name="PrimitiveType"/>
     </object-type>
     <object-type name="QQuick3DInstancing">
@@ -24,4 +26,5 @@
     <object-type name="QQuick3DTextureData">
         <enum-type name="Format"/>
     </object-type>
+    <object-type name="QQuick3DRenderExtension" since="6.7"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtQuickControls2/CMakeLists.txt b/sources/pyside6/PySide6/QtQuickControls2/CMakeLists.txt
index d5f35050d..9951d2e1e 100644
--- a/sources/pyside6/PySide6/QtQuickControls2/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtQuickControls2/CMakeLists.txt
@@ -1,7 +1,13 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtQuickControls2)
 
+set (QtQuickControls2_DROPPED_ENTRIES)
+
 set(QtQuickControls2_SRC
 ${QtQuickControls2_GEN_DIR}/qquickstyle_wrapper.cpp
+${QtQuickControls2_GEN_DIR}/qquickattachedpropertypropagator_wrapper.cpp
 # module is always needed
 ${QtQuickControls2_GEN_DIR}/qtquickcontrols2_module_wrapper.cpp
 )
@@ -11,14 +17,12 @@ set(QtQuickControls2_include_dirs ${QtQuickControls2_SOURCE_DIR}
                                   ${QtQml_SOURCE_DIR}
                                   ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                                   ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
-                                  ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
                                   ${Qt${QT_MAJOR_VERSION}Network_INCLUDE_DIRS}
                                   ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
                                   ${Qt${QT_MAJOR_VERSION}Quick_INCLUDE_DIRS}
                                   ${Qt${QT_MAJOR_VERSION}QuickControls2_INCLUDE_DIRS}
                                   ${libpyside_SOURCE_DIR}
                                   ${QtGui_GEN_DIR}
-                                  ${QtOpenGL_GEN_DIR}
                                   ${QtCore_GEN_DIR}
                                   ${QtNetwork_GEN_DIR}
                                   ${QtQml_GEN_DIR}
@@ -26,19 +30,17 @@ set(QtQuickControls2_include_dirs ${QtQuickControls2_SOURCE_DIR}
                                   ${QtQuickControls2_GEN_DIR})
 
 set(QtQuickControls2_libraries pyside6
-                      ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}Quick_LIBRARIES}
-                      ${Qt${QT_MAJOR_VERSION}QuickControls2_LIBRARIES})
+                               ${Qt${QT_MAJOR_VERSION}QuickControls2_LIBRARIES})
+
+set(QtQuickControls2_deps QtGui QtNetwork QtQml QtQuick)
 
-set(QtQuickControls2_deps QtGui QtOpenGL QtNetwork QtQml QtQuick)
+check_qt_opengl("QuickControls2" QtQuickControls2_include_dirs QtQuickControls2_deps
+                QtQuickControls2_DROPPED_ENTRIES)
 
 create_pyside_module(NAME QtQuickControls2
                      INCLUDE_DIRS QtQuickControls2_include_dirs
                      LIBRARIES QtQuickControls2_libraries
                      DEPS QtQuickControls2_deps
                      TYPESYSTEM_PATH QtQuickControls2_SOURCE_DIR
-                     SOURCES QtQuickControls2_SRC)
+                     SOURCES QtQuickControls2_SRC
+                     DROPPED_ENTRIES QtQuickControls2_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/QtQuickControls2/typesystem_quickcontrols2.xml b/sources/pyside6/PySide6/QtQuickControls2/typesystem_quickcontrols2.xml
index fa886b06f..72fc05226 100644
--- a/sources/pyside6/PySide6/QtQuickControls2/typesystem_quickcontrols2.xml
+++ b/sources/pyside6/PySide6/QtQuickControls2/typesystem_quickcontrols2.xml
@@ -3,9 +3,11 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtQuickControls2">
+<typesystem package="PySide6.QtQuickControls2"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtQuick/typesystem_quick.xml" generate="no"/>
 
     <object-type name="QQuickStyle"/>
+    <object-type name="QQuickAttachedPropertyPropagator"/>
 
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtQuickTest/CMakeLists.txt b/sources/pyside6/PySide6/QtQuickTest/CMakeLists.txt
new file mode 100644
index 000000000..8e3fb4d57
--- /dev/null
+++ b/sources/pyside6/PySide6/QtQuickTest/CMakeLists.txt
@@ -0,0 +1,44 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+project(QtQuickTest)
+
+set (QtQuickTest_DROPPED_ENTRIES)
+
+set(QtQuickTest_SRC
+# module is always needed
+${QtQuickTest_GEN_DIR}/qtquicktest_module_wrapper.cpp
+)
+
+set(QtQuickTest_include_dirs ${QtQuickTest_SOURCE_DIR}
+                             ${QtQml_SOURCE_DIR}
+                             ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
+                             ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
+                             ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
+                             ${Qt${QT_MAJOR_VERSION}Network_INCLUDE_DIRS}
+                             ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
+                             ${Qt${QT_MAJOR_VERSION}Quick_INCLUDE_DIRS}
+                             ${libpyside_SOURCE_DIR}
+                             ${QtGui_GEN_DIR}
+                             ${QtOpenGL_GEN_DIR}
+                             ${QtCore_GEN_DIR}
+                             ${QtNetwork_GEN_DIR}
+                             ${QtQml_GEN_DIR}
+                             ${QtQuick_GEN_DIR}
+                             ${QtQuickTest_GEN_DIR})
+
+set(QtQuickTest_libraries pyside6
+                          ${Qt${QT_MAJOR_VERSION}QuickTest_LIBRARIES})
+
+set(QtQuickTest_deps QtGui QtNetwork QtQml QtQuick)
+
+check_qt_opengl("QuickTest" QtQuickTest_include_dirs QtQuickTest_deps
+                QtQuickTest_DROPPED_ENTRIES)
+
+create_pyside_module(NAME QtQuickTest
+                     INCLUDE_DIRS QtQuickTest_include_dirs
+                     LIBRARIES QtQuickTest_libraries
+                     DEPS QtQuickTest_deps
+                     TYPESYSTEM_PATH QtQuickTest_SOURCE_DIR
+                     SOURCES QtQuickTest_SRC
+                     DROPPED_ENTRIES QtQuickTest_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/QtQuickTest/typesystem_quicktest.xml b/sources/pyside6/PySide6/QtQuickTest/typesystem_quicktest.xml
new file mode 100644
index 000000000..b6ef754e7
--- /dev/null
+++ b/sources/pyside6/PySide6/QtQuickTest/typesystem_quicktest.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+-->
+<typesystem package="PySide6.QtQuickTest"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
+    <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
+
+    <extra-includes>
+        <include file-name="QtQuickTest/quicktest.h" location="global"/>
+        <include file-name="QtCore/QDir" location="global"/>
+        <include file-name="pysideqobject.h" location="global"/>
+        <include file-name="vector" location="global"/>
+    </extra-includes>
+    <inject-code class="native" position="beginning"
+                 file="../glue/qtquicktest.cpp" snippet="call-quick-test-main"/>
+
+    <add-function signature="QUICK_TEST_MAIN(QString@name@,QStringList@argv@={},QString@dir@={})"
+                  return-type="int">
+        <inject-code file="../glue/qtquicktest.cpp" snippet="quick-test-main"/>
+        <inject-documentation format="target" mode="append"
+                              file="../doc/qtquicktest.rst"
+                              snippet="quick_test_main_documentation"/>
+    </add-function>
+    <add-function signature="QUICK_TEST_MAIN_WITH_SETUP(QString@name@,PyTypeObject*@setup@,QStringList@argv@={},QString@dir@={})"
+                  return-type="int">
+        <inject-code file="../glue/qtquicktest.cpp" snippet="quick-test-main_with_setup"/>
+        <inject-documentation format="target" mode="append"
+                              file="../doc/qtquicktest.rst"
+                              snippet="quick_test_main_with_setup_documentation"/>
+    </add-function>
+</typesystem>
diff --git a/sources/pyside6/PySide6/QtQuickWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtQuickWidgets/CMakeLists.txt
index 0c6f18bad..883010bee 100644
--- a/sources/pyside6/PySide6/QtQuickWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtQuickWidgets/CMakeLists.txt
@@ -1,5 +1,10 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtQuickWidgets)
 
+set (QtQuickWidgets_DROPPED_ENTRIES)
+
 set(QtQuickWidgets_SRC
 ${QtQuickWidgets_GEN_DIR}/qquickwidget_wrapper.cpp
 # module is always needed
@@ -27,20 +32,17 @@ set(QtQuickWidgets_include_dirs  ${QtQuickWidgets_SOURCE_DIR}
                                  ${QtQuickWidgets_GEN_DIR})
 
 set(QtQuickWidgets_libraries pyside6
-                             ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}OpenGL_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Quick_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES}
                              ${Qt${QT_MAJOR_VERSION}QuickWidgets_LIBRARIES})
 
-set(QtQuickWidgets_deps QtGui QtOpenGL QtQml QtQuick QtWidgets QtNetwork)
+set(QtQuickWidgets_deps QtGui QtQml QtQuick QtWidgets QtNetwork)
+
+check_qt_opengl("QuickWidgets" QtQuickWidgets_include_dirs QtQuickWidgets_deps
+                QtQuickWidgets_DROPPED_ENTRIES)
 
 create_pyside_module(NAME QtQuickWidgets
                      INCLUDE_DIRS QtQuickWidgets_include_dirs
                      LIBRARIES QtQuickWidgets_libraries
                      DEPS QtQuickWidgets_deps
                      TYPESYSTEM_PATH QtQuickWidgets_SOURCE_DIR
-                     SOURCES QtQuickWidgets_SRC)
+                     SOURCES QtQuickWidgets_SRC
+                     DROPPED_ENTRIES QtQuickWidgets_DROPPED_ENTRIES)
diff --git a/sources/pyside6/PySide6/QtQuickWidgets/typesystem_quickwidgets.xml b/sources/pyside6/PySide6/QtQuickWidgets/typesystem_quickwidgets.xml
index 2768e73d8..4f4484cb0 100644
--- a/sources/pyside6/PySide6/QtQuickWidgets/typesystem_quickwidgets.xml
+++ b/sources/pyside6/PySide6/QtQuickWidgets/typesystem_quickwidgets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtQuickWidgets">
+<typesystem package="PySide6.QtQuickWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <load-typesystem name="QtQuick/typesystem_quick.xml" generate="no"/>
diff --git a/sources/pyside6/PySide6/QtRemoteObjects/CMakeLists.txt b/sources/pyside6/PySide6/QtRemoteObjects/CMakeLists.txt
index 33e21a64c..07835b2f6 100644
--- a/sources/pyside6/PySide6/QtRemoteObjects/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtRemoteObjects/CMakeLists.txt
@@ -1,7 +1,11 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtRemoteObjects)
 
 set(QtRemoteObjects_SRC
 ${QtRemoteObjects_GEN_DIR}/qabstractitemmodelreplica_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qconnectionabstractserver_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectabstractpersistedstore_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectdynamicreplica_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjecthost_wrapper.cpp
@@ -12,9 +16,14 @@ ${QtRemoteObjects_GEN_DIR}/qremoteobjectpendingcallwatcher_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectregistry_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectregistryhost_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectreplica_wrapper.cpp
-# ${QtRemoteObjects_GEN_DIR}/qtremoteobjects_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtremoteobjects_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectsettingsstore_wrapper.cpp
 ${QtRemoteObjects_GEN_DIR}/qremoteobjectsourcelocationinfo_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtroclientfactory_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtroclientiodevice_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtroiodevicebase_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtroserverfactory_wrapper.cpp
+${QtRemoteObjects_GEN_DIR}/qtroserveriodevice_wrapper.cpp
 
 # module is always needed
 ${QtRemoteObjects_GEN_DIR}/qtremoteobjects_module_wrapper.cpp
@@ -26,11 +35,10 @@ set(QtRemoteObjects_include_dirs ${QtRemoteObjects_SOURCE_DIR}
                                  ${SHIBOKEN_INCLUDE_DIR}
                                  ${libpyside_SOURCE_DIR}
                                  ${SHIBOKEN_PYTHON_INCLUDE_DIR}
-                                 ${QtCore_GEN_DIR})
+                                 ${QtCore_GEN_DIR}
+                                 ${QtNetwork_GEN_DIR})
 
 set(QtRemoteObjects_libraries    pyside6
-                                 ${SHIBOKEN_PYTHON_LIBRARIES}
-                                 ${SHIBOKEN_LIBRARY}
                                  ${Qt${QT_MAJOR_VERSION}RemoteObjects_LIBRARIES})
 
 set(QtRemoteObjects_deps QtCore QtNetwork)
diff --git a/sources/pyside6/PySide6/QtRemoteObjects/typesystem_remoteobjects.xml b/sources/pyside6/PySide6/QtRemoteObjects/typesystem_remoteobjects.xml
index db8ab3a1f..86e4d9093 100644
--- a/sources/pyside6/PySide6/QtRemoteObjects/typesystem_remoteobjects.xml
+++ b/sources/pyside6/PySide6/QtRemoteObjects/typesystem_remoteobjects.xml
@@ -3,18 +3,21 @@
 // Copyright (C) 2019 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtRemoteObjects">
+<typesystem package="PySide6.QtRemoteObjects"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="templates/core_common.xml" generate="no"/>
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
+    <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
+
+    <rejection class="QRemoteObjectStringLiterals"/>
     <rejection class="*" function-name="getTypeNameAndMetaobjectFromClassInfo"/>
-<!-- Exclude namespace due to Q_NAMESPACE link errors on Windows (QTBUG-68014)
     <rejection class="QtRemoteObjects" field-name="staticMetaObject"/>
     <namespace-type name="QtRemoteObjects">
         <enum-type name="InitialAction"/>
         <enum-type name="QRemoteObjectPacketTypeEnum"/>
     </namespace-type>
--->
     <object-type name="QAbstractItemModelReplica"/>
+    <object-type name="QConnectionAbstractServer"/>
     <object-type name="QRemoteObjectAbstractPersistedStore"/>
     <object-type name="QRemoteObjectDynamicReplica"/>
     <object-type name="QRemoteObjectHost"/>
@@ -36,9 +39,18 @@
     </object-type>
     <object-type name="QRemoteObjectSettingsStore"/>
     <value-type name="QRemoteObjectSourceLocationInfo"/>
+    <object-type name="QtROClientFactory"/>
+    <object-type name="QtROClientIoDevice"/>
+    <object-type name="QtROIoDeviceBase"/>
+    <object-type name="QtROServerFactory"/>
+    <object-type name="QtROServerIoDevice"/>
 
     <suppress-warning text="^.*Typedef used on signal QRemoteObject.*$"/>
     <suppress-warning text="^QRemoteObjectPendingCallWatcher inherits from a non polymorphic type.*$"/>
-    <suppress-warning text="Enum 'QRemoteObjectReplica::ConstructorType' (class: QRemoteObjectReplica) does not have a type entry"/>
-    <suppress-warning text="skipping field 'QRemoteObjectReplica::d_impl' with unmatched type 'QSharedPointer'"/>
+    <suppress-warning text="^Enum 'QRemoteObjectReplica::ConstructorType'.*does not have a type entry.*$"/>
+    <suppress-warning text="Stripping argument #1 of void QRemoteObjectReplica::QRemoteObjectReplica(QRemoteObjectReplica::ConstructorType) due to unmatched type &quot;QRemoteObjectReplica::ConstructorType&quot; with default expression &quot;DefaultConstructor&quot;."/>
+    <suppress-warning text="skipping protected field 'QRemoteObjectReplica::d_impl' with unmatched type 'QSharedPointer'"/>
+    <!-- QtNetwork is pulled in via QtRemoteObjectsDepends. -->
+    <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtScxml/CMakeLists.txt b/sources/pyside6/PySide6/QtScxml/CMakeLists.txt
index 5eaa40a43..1b0eab0ce 100644
--- a/sources/pyside6/PySide6/QtScxml/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtScxml/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtScxml)
 
 set(QtScxml_OPTIONAL_SRC )
diff --git a/sources/pyside6/PySide6/QtScxml/typesystem_scxml.xml b/sources/pyside6/PySide6/QtScxml/typesystem_scxml.xml
index c10037e1b..ba8820570 100644
--- a/sources/pyside6/PySide6/QtScxml/typesystem_scxml.xml
+++ b/sources/pyside6/PySide6/QtScxml/typesystem_scxml.xml
@@ -3,15 +3,18 @@
 // Copyright (C) 2018 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtScxml">
+<typesystem package="PySide6.QtScxml"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <object-type name="QScxmlCompiler">
         <object-type name="Loader"/>
     </object-type>
     <object-type name="QScxmlCppDataModel"/>
-    <object-type name="QScxmlEvent">
+    <!-- PYSIDE-2340: Force value conversion for QScxmlStateMachine::connectToEvent()
+         which expects "func(const QScxmlEvent &)" -->
+    <value-type name="QScxmlEvent">
         <enum-type name="EventType"/>
-    </object-type>
+    </value-type>
     <object-type name="QScxmlDynamicScxmlServiceFactory"/>
     <object-type name="QScxmlInvokableService"/>
     <object-type name="QScxmlInvokableServiceFactory"/>
diff --git a/sources/pyside6/PySide6/QtSensors/CMakeLists.txt b/sources/pyside6/PySide6/QtSensors/CMakeLists.txt
index 5970cbb05..0152d2884 100644
--- a/sources/pyside6/PySide6/QtSensors/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSensors/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSensors)
 
 set(QtSensors_OPTIONAL_SRC )
diff --git a/sources/pyside6/PySide6/QtSensors/typesystem_sensors.xml b/sources/pyside6/PySide6/QtSensors/typesystem_sensors.xml
index 924262f52..4efd08277 100644
--- a/sources/pyside6/PySide6/QtSensors/typesystem_sensors.xml
+++ b/sources/pyside6/PySide6/QtSensors/typesystem_sensors.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2018 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSensors">
+<typesystem package="PySide6.QtSensors"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 <!-- overrides QObject::metaObject() by private method
     <object-type name="QSensorGesture"/>
diff --git a/sources/pyside6/PySide6/QtSerialBus/CMakeLists.txt b/sources/pyside6/PySide6/QtSerialBus/CMakeLists.txt
index 13fcb54a0..310a8b0f0 100644
--- a/sources/pyside6/PySide6/QtSerialBus/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSerialBus/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSerialBus)
 
 set(QtSerialBus_OPTIONAL_SRC )
@@ -5,25 +8,35 @@ set(QtSerialBus_DROPPED_ENTRIES )
 
 set(QtSerialBus_SRC
     ${QtSerialBus_GEN_DIR}/qcanbus_wrapper.cpp
-    ${QtSerialBus_GEN_DIR}/qcanbusdevice_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qcanbusdevice_filter_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanbusdevice_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qcanbusdeviceinfo_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qcanbusfactory_wrapper.cpp
-    ${QtSerialBus_GEN_DIR}/qcanbusframe_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qcanbusframe_timestamp_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanbusframe_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcandbcfileparser_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanframeprocessor_parseresult_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanframeprocessor_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanmessagedescription_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcansignaldescription_multiplexvaluerange_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcansignaldescription_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qcanuniqueiddescription_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusclient_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusdataunit_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusdevice_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusdeviceidentification_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qmodbusexceptionresponse_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbuspdu_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusreply_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusrequest_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qmodbusresponse_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusrtuserialclient_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusrtuserialserver_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbusserver_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbustcpclient_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbustcpconnectionobserver_wrapper.cpp
     ${QtSerialBus_GEN_DIR}/qmodbustcpserver_wrapper.cpp
+    ${QtSerialBus_GEN_DIR}/qtcanbus_wrapper.cpp
 # module is always needed
     ${QtSerialBus_GEN_DIR}/qtserialbus_module_wrapper.cpp
 )
diff --git a/sources/pyside6/PySide6/QtSerialBus/typesystem_serialbus.xml b/sources/pyside6/PySide6/QtSerialBus/typesystem_serialbus.xml
index 57642f34c..fdd2b1483 100644
--- a/sources/pyside6/PySide6/QtSerialBus/typesystem_serialbus.xml
+++ b/sources/pyside6/PySide6/QtSerialBus/typesystem_serialbus.xml
@@ -4,11 +4,19 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.QtSerialBus">
+<typesystem package="PySide6.QtSerialBus"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
     <load-typesystem name="QtSerialPort/typesystem_serialport.xml" generate="no"/>
 
+    <namespace-type name="QtCanBus">
+        <enum-type name="DataSource"/>
+        <enum-type name="DataFormat"/>
+        <enum-type name="MultiplexState"/>
+        <enum-type name="UniqueId"/>
+    </namespace-type>
+
     <object-type name="QCanBus">
         <!-- Remove errorMessage argument, return tuple instead.  -->
         <modify-function signature="availableDevices(QString,QString*)const">
@@ -61,6 +69,18 @@
         <enum-type name="FrameError" flags="FrameErrors"/>
         <value-type name="TimeStamp"/>
     </value-type>
+    <object-type name="QCanDbcFileParser">
+        <enum-type name="Error"/>
+    </object-type>
+    <object-type name="QCanFrameProcessor">
+        <enum-type name="Error"/>
+        <value-type name="ParseResult"/>
+    </object-type>
+    <value-type name="QCanMessageDescription"/>
+    <value-type name="QCanSignalDescription">
+        <value-type name="MultiplexValueRange"/>
+    </value-type>
+    <value-type name="QCanUniqueIdDescription"/>
     <object-type name="QModbusClient"/>
     <value-type name="QModbusDataUnit">
         <enum-type name="RegisterType"/>
@@ -81,6 +101,8 @@
         <enum-type name="FunctionCode"/>
         <modify-field name="ExceptionByte" remove="true"/> <!-- Link error -->
     </object-type>
+    <object-type name="QModbusExceptionResponse"/>
+    <object-type name="QModbusResponse"/>
     <object-type name="QModbusReply">
         <enum-type name="ReplyType"/>
     </object-type>
diff --git a/sources/pyside6/PySide6/QtSerialPort/CMakeLists.txt b/sources/pyside6/PySide6/QtSerialPort/CMakeLists.txt
index c0abdf999..564fc9969 100644
--- a/sources/pyside6/PySide6/QtSerialPort/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSerialPort/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSerialPort)
 
 set(QtSerialPort_OPTIONAL_SRC )
diff --git a/sources/pyside6/PySide6/QtSerialPort/typesystem_serialport.xml b/sources/pyside6/PySide6/QtSerialPort/typesystem_serialport.xml
index 929a8e909..0cbd3c7f7 100644
--- a/sources/pyside6/PySide6/QtSerialPort/typesystem_serialport.xml
+++ b/sources/pyside6/PySide6/QtSerialPort/typesystem_serialport.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSerialPort">
+<typesystem package="PySide6.QtSerialPort"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <object-type name="QSerialPort">
         <enum-type name="BaudRate" python-type="IntEnum"/>
diff --git a/sources/pyside6/PySide6/QtSpatialAudio/CMakeLists.txt b/sources/pyside6/PySide6/QtSpatialAudio/CMakeLists.txt
index 705df54b4..966c0ffe8 100644
--- a/sources/pyside6/PySide6/QtSpatialAudio/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSpatialAudio/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSpatialAudio)
 
 set(QtSpatialAudio_SRC
@@ -25,12 +28,8 @@ set(QtSpatialAudio_include_dirs ${QtSpatialAudio_SOURCE_DIR}
                                 ${QtMultimedia_GEN_DIR})
 
 set(QtSpatialAudio_libraries pyside6
-                             ${Qt${QT_MAJOR_VERSION}SpatialAudio_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                             ${Qt${QT_MAJOR_VERSION}Multimedia_LIBRARIES}
-                             )
+                             ${Qt${QT_MAJOR_VERSION}SpatialAudio_LIBRARIES})
+
 set(QtSpatialAudio_deps QtCore QtGui QtNetwork QtMultimedia)
 
 create_pyside_module(NAME QtSpatialAudio
diff --git a/sources/pyside6/PySide6/QtSpatialAudio/typesystem_spatialaudio.xml b/sources/pyside6/PySide6/QtSpatialAudio/typesystem_spatialaudio.xml
index 71f189b25..b9c2557af 100644
--- a/sources/pyside6/PySide6/QtSpatialAudio/typesystem_spatialaudio.xml
+++ b/sources/pyside6/PySide6/QtSpatialAudio/typesystem_spatialaudio.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSpatialAudio">
+<typesystem package="PySide6.QtSpatialAudio"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
diff --git a/sources/pyside6/PySide6/QtSql/CMakeLists.txt b/sources/pyside6/PySide6/QtSql/CMakeLists.txt
index ec6285926..fedebe642 100644
--- a/sources/pyside6/PySide6/QtSql/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSql/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSql)
 
 set(QtSql_SRC
@@ -32,13 +35,13 @@ set(QtSql_include_dirs  ${QtSql_SOURCE_DIR}
                         ${libpyside_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
                         ${QtGui_GEN_DIR}
-                        ${QtWidgets_GEN_DIR}
-                        )
+                        ${QtWidgets_GEN_DIR})
+
+# Link to QtWidgets to enable QSqlRelationalDelegate
 set(QtSql_libraries     pyside6
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
                         ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
                         ${Qt${QT_MAJOR_VERSION}Sql_LIBRARIES})
+
 set(QtSql_deps QtWidgets)
 
 create_pyside_module(NAME QtSql
diff --git a/sources/pyside6/PySide6/QtSql/typesystem_sql.xml b/sources/pyside6/PySide6/QtSql/typesystem_sql.xml
index c7b1d58b0..70c3e6f69 100644
--- a/sources/pyside6/PySide6/QtSql/typesystem_sql.xml
+++ b/sources/pyside6/PySide6/QtSql/typesystem_sql.xml
@@ -3,12 +3,12 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSql">
+<typesystem package="PySide6.QtSql"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
 
   <rejection class="QSqlDriverCreator"/>
   <rejection class="QSqlDriverPlugin"/>
-  <rejection class="QSqlDriverFactoryInterface"/>
 
   <namespace-type name="QSql">
     <enum-type name="Location"/>
@@ -123,6 +123,14 @@
         <include file-name="QStringList" location="global"/>
         <include file-name="QSize" location="global"/>
     </extra-includes>
+    <!-- FIXME: PYSIDE7: Handle setQuery(QSqlQuery&&) in some way?
+         QTBUG-91766/PYSIDE-2394. allow-thread for PYSIDE-1931 -->
+    <modify-function signature="setQuery(QSqlQuery)" allow-thread="yes"
+                     deprecated="false"/>
+    <modify-function signature="setQuery(QString,QSqlDatabase)" allow-thread="yes"/>
+    <!-- FIXME: PYSIDE7: Probably needs a fix, make QSqlQuery an object type?
+         QTBUG-105048/PYSIDE-2300 -->
+    <declare-function signature="query()" return-type="QSqlQuery"/>
   </object-type>
   <object-type name="QSqlRelationalTableModel">
     <enum-type name="JoinMode"/>
@@ -130,6 +138,7 @@
         <include file-name="QStringList" location="global"/>
         <include file-name="QSize" location="global"/>
     </extra-includes>
+    <modify-function signature="select()" allow-thread="yes"/> <!-- PYSIDE-1931 -->
   </object-type>
   <object-type name="QSqlResult">
       <enum-type name="BindingSyntax"/>
@@ -162,6 +171,7 @@
         <include file-name="QStringList" location="global"/>
         <include file-name="QSize" location="global"/>
     </extra-includes>
+    <modify-function signature="select()" allow-thread="yes"/> <!-- PYSIDE-1931 -->
   </object-type>
   <object-type name="QSqlDriverCreatorBase">
     <extra-includes>
diff --git a/sources/pyside6/PySide6/QtStateMachine/CMakeLists.txt b/sources/pyside6/PySide6/QtStateMachine/CMakeLists.txt
index 204a126b6..2b4cc348d 100644
--- a/sources/pyside6/PySide6/QtStateMachine/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtStateMachine/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtStateMachine)
 
 set(QtStateMachine_SRC
@@ -23,13 +26,11 @@ set(QtStateMachine_include_dirs  ${QtStateMachine_SOURCE_DIR}
                             ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
                             ${libpyside_SOURCE_DIR}
                             ${QtCore_GEN_DIR}
-                            ${QtGui_GEN_DIR}
-                            )
+                            ${QtGui_GEN_DIR})
+
 set(QtStateMachine_libraries pyside6
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}StateMachine_LIBRARIES}
-                        )
+                             ${Qt${QT_MAJOR_VERSION}StateMachine_LIBRARIES})
+
 set(QtStateMachine_deps QtGui)
 
 create_pyside_module(NAME QtStateMachine
diff --git a/sources/pyside6/PySide6/QtStateMachine/typesystem_statemachine.xml b/sources/pyside6/PySide6/QtStateMachine/typesystem_statemachine.xml
index cc9b3f6c7..0e29f240f 100644
--- a/sources/pyside6/PySide6/QtStateMachine/typesystem_statemachine.xml
+++ b/sources/pyside6/PySide6/QtStateMachine/typesystem_statemachine.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtStateMachine">
+<typesystem package="PySide6.QtStateMachine"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
 
   <object-type name="QAbstractState">
@@ -124,10 +125,15 @@ s1.addTransition(button.clicked, s1h)&lt;/code>
       </modify-argument>
     </modify-function>
 
+    <modify-function signature="assignProperty(QObject*,const char*,QVariant)">
+        <modify-argument index="2" pyi-type="str"/>
+    </modify-function>
+
     <modify-function signature="addTransition(const QObject*,const char*,QAbstractState*)">
       <modify-argument index="return">
         <parent index="this" action="add"/>
       </modify-argument>
+      <modify-argument index="2" pyi-type="str"/>
       <inject-code class="target" position="beginning" file="../glue/qtstatemachine.cpp"
                    snippet="qstate-addtransition-1"/>
     </modify-function>
diff --git a/sources/pyside6/PySide6/QtSvg/CMakeLists.txt b/sources/pyside6/PySide6/QtSvg/CMakeLists.txt
index 748c8355c..5451380cc 100644
--- a/sources/pyside6/PySide6/QtSvg/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSvg/CMakeLists.txt
@@ -1,8 +1,12 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSvg)
 
 set(QtSvg_SRC
 ${QtSvg_GEN_DIR}/qsvggenerator_wrapper.cpp
 ${QtSvg_GEN_DIR}/qsvgrenderer_wrapper.cpp
+${QtSvg_GEN_DIR}/qtsvg_wrapper.cpp
 # module is always needed
 ${QtSvg_GEN_DIR}/qtsvg_module_wrapper.cpp
 )
@@ -14,13 +18,12 @@ set(QtSvg_include_dirs  ${QtSvg_SOURCE_DIR}
                         ${Qt${QT_MAJOR_VERSION}Svg_INCLUDE_DIRS}
                         ${libpyside_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
-                        ${QtGui_GEN_DIR}
-                        )
+                        ${QtGui_GEN_DIR})
+
 set(QtSvg_libraries     pyside6
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Svg_LIBRARIES}
-                        )
+                        ${Qt${QT_MAJOR_VERSION}Svg_LIBRARIES})
+
+
 set(QtSvg_deps QtGui)
 
 create_pyside_module(NAME QtSvg
diff --git a/sources/pyside6/PySide6/QtSvg/typesystem_svg.xml b/sources/pyside6/PySide6/QtSvg/typesystem_svg.xml
index afc70824f..4803f4d93 100644
--- a/sources/pyside6/PySide6/QtSvg/typesystem_svg.xml
+++ b/sources/pyside6/PySide6/QtSvg/typesystem_svg.xml
@@ -3,12 +3,17 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSvg">
+<typesystem package="PySide6.QtSvg"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
 
   <object-type name="QSvgRenderer"/>
+  <namespace-type name="QtSvg" since="6.7">
+      <enum-type name="Option" flags="Options"/>
+  </namespace-type>
 
   <object-type name="QSvgGenerator">
+    <enum-type name="SvgVersion" since="6.5"/>
     <modify-function signature="setOutputDevice(QIODevice*)">
       <modify-argument index="1">
           <reference-count action="set"/>
diff --git a/sources/pyside6/PySide6/QtSvgWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtSvgWidgets/CMakeLists.txt
index 6922f877d..6bd3aedc1 100644
--- a/sources/pyside6/PySide6/QtSvgWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtSvgWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtSvgWidgets)
 
 set(QtSvgWidgets_SRC
@@ -18,16 +21,10 @@ set(QtSvgWidgets_include_dirs ${QtSvgWidgets_SOURCE_DIR}
                               ${QtCore_GEN_DIR}
                               ${QtGui_GEN_DIR}
                               ${QtWidgets_GEN_DIR}
-                              ${QtSvg_GEN_DIR}
-                              )
+                              ${QtSvg_GEN_DIR})
 
 set(QtSvgWidgets_libraries pyside6
-                           ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}Svg_LIBRARIES}
-                           ${Qt${QT_MAJOR_VERSION}SvgWidgets_LIBRARIES}
-                           )
+                           ${Qt${QT_MAJOR_VERSION}SvgWidgets_LIBRARIES})
 
 set(QtSvgWidgets_deps QtSvg QtWidgets)
 
diff --git a/sources/pyside6/PySide6/QtSvgWidgets/typesystem_svgwidgets.xml b/sources/pyside6/PySide6/QtSvgWidgets/typesystem_svgwidgets.xml
index ce7a02c68..36bda1ea3 100644
--- a/sources/pyside6/PySide6/QtSvgWidgets/typesystem_svgwidgets.xml
+++ b/sources/pyside6/PySide6/QtSvgWidgets/typesystem_svgwidgets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtSvgWidgets">
+<typesystem package="PySide6.QtSvgWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtSvg/typesystem_svg.xml" generate="no"/>
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
 
diff --git a/sources/pyside6/PySide6/QtTest/CMakeLists.txt b/sources/pyside6/PySide6/QtTest/CMakeLists.txt
index 0e54461c1..86bb2a731 100644
--- a/sources/pyside6/PySide6/QtTest/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtTest/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtTest)
 
 set(QtTest_SRC
@@ -24,14 +27,15 @@ set(QtTest_include_dirs ${QtTest_SOURCE_DIR}
                         ${libpyside_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
                         ${QtGui_GEN_DIR}
-                        ${QtWidgets_GEN_DIR}
-                        )
+                        ${QtWidgets_GEN_DIR})
+
+# Link to QtGui/QtWidgets to enable gui/widget-specific inline functions
 set(QtTest_libraries    pyside6
                         ${Qt${QT_MAJOR_VERSION}Test_LIBRARIES}
                         ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
                         ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        )
+                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES})
+
 set(QtTest_deps  QtWidgets)
 
 create_pyside_module(NAME QtTest
diff --git a/sources/pyside6/PySide6/QtTest/typesystem_test.xml b/sources/pyside6/PySide6/QtTest/typesystem_test.xml
index c8c814992..2fc4f23cd 100644
--- a/sources/pyside6/PySide6/QtTest/typesystem_test.xml
+++ b/sources/pyside6/PySide6/QtTest/typesystem_test.xml
@@ -3,19 +3,16 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtTest">
+<typesystem package="PySide6.QtTest"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
 
-  <rejection class="QTest" function-name="qCompare&lt;char&gt;"/>
-  <rejection class="QTest" function-name="qCompare&lt;char*&gt;"/>
-  <rejection class="QTest" function-name="qCompare&lt;double&gt;"/>
-  <rejection class="QTest" function-name="qCompare&lt;float&gt;"/>
-  <rejection class="QTest" function-name="qCompare&lt;double,qreal&gt;"/>
-  <rejection class="QTest" function-name="qCompare&lt;qreal,double&gt;"/>
+  <rejection class="QTest::Internal"/>
+  <rejection class="QTestPrivate"/>
+
   <rejection class="QTest" function-name="qCompare"/>
-  <rejection class="QTest" function-name="qInit"/>
   <rejection class="QTest" function-name="qVerify"/>
   <rejection class="QTest" function-name="toHexRepresentation"/>
   <rejection class="QTest" function-name="qFail"/>
@@ -24,27 +21,11 @@
   <rejection class="QTest" function-name="qData"/>
   <rejection class="QTest" function-name="qWarn"/>
   <rejection class="QTest" function-name="toString"/>
-  <rejection class="QTest" function-name="toString&lt;bool>"/>
-  <rejection class="QTest" function-name="toString&lt;char>"/>
-  <rejection class="QTest" function-name="toString&lt;unsigned char>"/>
-  <rejection class="QTest" function-name="toString&lt;signed char>"/>
-  <rejection class="QTest" function-name="toString&lt;double>"/>
-  <rejection class="QTest" function-name="toString&lt;float>"/>
-  <rejection class="QTest" function-name="toString&lt;int>"/>
-  <rejection class="QTest" function-name="toString&lt;long>"/>
-  <rejection class="QTest" function-name="toString&lt;qint64>"/>
-  <rejection class="QTest" function-name="toString&lt;quint64>"/>
-  <rejection class="QTest" function-name="toString&lt;short>"/>
-  <rejection class="QTest" function-name="toString&lt;uint>"/>
-  <rejection class="QTest" function-name="toString&lt;ulong>"/>
-  <rejection class="QTest" function-name="toString&lt;ushort>"/>
   <rejection class="QTest" function-name="useVerifyThrowsException"/>
-  <rejection class="QTest" function-name="qt_snprintf"/>
 
   <rejection class="QTest" function-name="compare_helper"/>
   <rejection class="QTest" function-name="toPrettyUnicode"/>
 
-  <rejection class="QTest" field-name="lastMouseButton"/>
   <rejection class="QTest" field-name="lastMouseTimestamp"/>
 
   <!-- Qt5: this new stuff below belongs to QtGui. I keep it here for now, after a long odyssey.
@@ -91,11 +72,11 @@
     <enum-type name="MouseAction"/>
     <enum-type name="QBenchmarkMetric" since="4.7"/>
     <enum-type name="TestFailMode"/>
+    <enum-type name="ComparisonOperation" since="6.4"/>
     <extra-includes>
         <include file-name="QtTest" location="global"/>
     </extra-includes>
 
-    <rejection class="QTouchEventSequence"/>
     <object-type name="PySideQTouchEventSequence" target-lang-name="QTouchEventSequence" since="4.6" >
         <modify-function signature="press(int,const QPoint&amp;,QWidget*)">
             <modify-argument index="return">
diff --git a/sources/pyside6/PySide6/QtTextToSpeech/CMakeLists.txt b/sources/pyside6/PySide6/QtTextToSpeech/CMakeLists.txt
index 9b6b5eb0a..9f0bd2fc3 100644
--- a/sources/pyside6/PySide6/QtTextToSpeech/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtTextToSpeech/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtTextToSpeech)
 
 set(QtTextToSpeech_SRC
@@ -16,9 +19,7 @@ set(QtTextToSpeech_include_dirs ${QtTextToSpeech_SOURCE_DIR}
                                 ${QtCore_GEN_DIR})
 
 set(QtTextToSpeech_libraries    pyside6
-                                ${Qt${QT_MAJOR_VERSION}Multimedia_LIBRARIES}
-                                ${Qt${QT_MAJOR_VERSION}TextToSpeech_LIBRARIES}
-                                ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES})
+                                ${Qt${QT_MAJOR_VERSION}TextToSpeech_LIBRARIES})
 
 set(QtTextToSpeech_deps QtCore QtMultimedia)
 
diff --git a/sources/pyside6/PySide6/QtTextToSpeech/typesystem_texttospeech.xml b/sources/pyside6/PySide6/QtTextToSpeech/typesystem_texttospeech.xml
index 4a0b4482a..70751e9d9 100644
--- a/sources/pyside6/PySide6/QtTextToSpeech/typesystem_texttospeech.xml
+++ b/sources/pyside6/PySide6/QtTextToSpeech/typesystem_texttospeech.xml
@@ -3,13 +3,15 @@
 // Copyright (C) 2017 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtTextToSpeech">
+<typesystem package="PySide6.QtTextToSpeech"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 
   <object-type name="QTextToSpeech">
       <enum-type name="State"/>
       <enum-type name="BoundaryHint"/>
       <enum-type name="ErrorReason"/>
+      <enum-type name="Capability" flags="Capabilities" since="6.6"/>
   </object-type>
   <object-type name="QTextToSpeechEngine"/>
   <value-type name="QVoice">
diff --git a/sources/pyside6/PySide6/QtUiTools/CMakeLists.txt b/sources/pyside6/PySide6/QtUiTools/CMakeLists.txt
index df54114d3..e16d2d585 100644
--- a/sources/pyside6/PySide6/QtUiTools/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtUiTools/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtUiTools)
 
 set(QtUiTools_SRC
@@ -22,15 +25,12 @@ set(QtUiTools_include_dirs  ${QtUiTools_SOURCE_DIR}
                             ${plugins_SOURCE_DIR}
                             ${QtCore_GEN_DIR}
                             ${QtGui_GEN_DIR}
-                            ${QtWidgets_GEN_DIR}
-                            )
+                            ${QtWidgets_GEN_DIR})
+
 set(QtUiTools_libraries     pyside6
                             uiplugin
-                            ${Qt${QT_MAJOR_VERSION}UiTools_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                            )
+                            ${Qt${QT_MAJOR_VERSION}UiTools_LIBRARIES})
+
 set(QtUiTools_deps QtWidgets)
 
 configure_file("${QtUiTools_SOURCE_DIR}/QtUiTools_global.pre.h.in"
diff --git a/sources/pyside6/PySide6/QtUiTools/typesystem_uitools.xml b/sources/pyside6/PySide6/QtUiTools/typesystem_uitools.xml
index a67dd6f61..9cfa176c8 100644
--- a/sources/pyside6/PySide6/QtUiTools/typesystem_uitools.xml
+++ b/sources/pyside6/PySide6/QtUiTools/typesystem_uitools.xml
@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
 
-<typesystem package="PySide6.QtUiTools">
+<typesystem package="PySide6.QtUiTools"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
 
     <object-type name="QUiLoader">
@@ -14,38 +15,10 @@
       <inject-code class="native" position="beginning" file="../glue/qtuitools.cpp" snippet="uitools-loadui"/>
       <inject-code file="../glue/qtuitools.cpp" snippet="quiloader"/>
       <add-function signature="registerCustomWidget(PyObject*@customWidgetType@)" return-type="void">
-         <inject-documentation format="target" mode="append">
-         Registers a Python created custom widget to QUiLoader, so it can be recognized when
-         loading a `.ui` file. The custom widget type is passed via the ``customWidgetType`` argument.
-         This is needed when you want to override a virtual method of some widget in the interface,
-         since duck punching will not work with widgets created by QUiLoader based on the contents
-         of the `.ui` file.
-
-         (Remember that `duck punching virtual methods is an invitation for your own demise!
-         &lt;https://doc.qt.io/qtforpython/shiboken6/wordsofadvice.html#duck-punching-and-virtual-methods>`_)
-
-         Let's see an obvious example. If you want to create a new widget it's probable you'll end up
-         overriding :class:`~PySide6.QtGui.QWidget`'s :meth:`~PySide6.QtGui.QWidget.paintEvent` method.
-
-         .. code-block:: python
-
-            class Circle(QWidget):
-                def paintEvent(self, event):
-                    with QPainter(self) as painter:
-                        painter.setPen(self.pen)
-                        painter.setBrush(QBrush(self.color))
-                        painter.drawEllipse(event.rect().center(), 20, 20)
-
-            # ...
-
-            loader = QUiLoader()
-            loader.registerCustomWidget(Circle)
-            circle = loader.load('circle.ui')
-            circle.show()
-
-            # ...
-         </inject-documentation>
-         <inject-code class="target" position="beginning" file="../glue/qtuitools.cpp" snippet="quiloader-registercustomwidget"/>
+         <inject-documentation format="target" mode="append" file="../doc/qtuitools.rst"
+                               snippet="quiloader-registercustomwidget"/>
+         <inject-code class="target" position="beginning" file="../glue/qtuitools.cpp"
+                      snippet="quiloader-registercustomwidget"/>
       </add-function>
       <modify-function signature="createAction(QObject*,const QString&amp;)">
         <modify-argument index="return">
@@ -107,6 +80,8 @@
     -->
     <add-function signature="loadUiType(const QString&amp; @uifile@)" return-type="PyObject*">
       <inject-code file="../glue/qtuitools.cpp" snippet="loaduitype"/>
+      <inject-documentation format="target" mode="append" file="../doc/qtuitools.rst"
+                            snippet="loaduitype"/>
     </add-function>
 
 
diff --git a/sources/pyside6/PySide6/QtWebChannel/CMakeLists.txt b/sources/pyside6/PySide6/QtWebChannel/CMakeLists.txt
index b6b8d3e5e..4c06edd2f 100644
--- a/sources/pyside6/PySide6/QtWebChannel/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWebChannel/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWebChannel)
 
 set(QtWebChannel_SRC
@@ -12,12 +15,11 @@ set(QtWebChannel_include_dirs ${QtWebChannel_SOURCE_DIR}
                         ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
                         ${Qt${QT_MAJOR_VERSION}WebChannel_INCLUDE_DIRS}
                         ${libpyside_SOURCE_DIR}
-                        ${QtCore_GEN_DIR}
-                        )
-set(QtWebChannel_libraries    pyside6
-                        ${Qt${QT_MAJOR_VERSION}WebChannel_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        )
+                        ${QtCore_GEN_DIR})
+
+set(QtWebChannel_libraries pyside6
+                           ${Qt${QT_MAJOR_VERSION}WebChannel_LIBRARIES})
+
 set(QtWebChannel_deps QtCore)
 
 create_pyside_module(NAME QtWebChannel
diff --git a/sources/pyside6/PySide6/QtWebChannel/typesystem_webchannel.xml b/sources/pyside6/PySide6/QtWebChannel/typesystem_webchannel.xml
index a4c209bfc..c08a9b187 100644
--- a/sources/pyside6/PySide6/QtWebChannel/typesystem_webchannel.xml
+++ b/sources/pyside6/PySide6/QtWebChannel/typesystem_webchannel.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWebChannel">
+<typesystem package="PySide6.QtWebChannel"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
 
   <object-type name="QWebChannel"/>
@@ -16,4 +17,7 @@
        the QML module is not yet wrapped.
   <object-type name="QQmlWebChannel"/> -->
 
+  <!-- QtQml/QtNetwork are pulled in via QtQtWebChannelDepends. -->
+  <suppress-warning text="^Scoped enum 'Q(Ocsp)|(Dtls)|(Qml).*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtWebEngineCore/CMakeLists.txt b/sources/pyside6/PySide6/QtWebEngineCore/CMakeLists.txt
index 0da2c6c7b..0cdaf2f91 100644
--- a/sources/pyside6/PySide6/QtWebEngineCore/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWebEngineCore/CMakeLists.txt
@@ -1,17 +1,29 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWebEngineCore)
 
 set(QtWebEngineCore_SRC
 ${QtWebEngineCore_GEN_DIR}/qwebenginecertificateerror_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebengineclientcertificateselection_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebengineclientcertificatestore_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginecontextmenurequest_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginecookiestore_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginecookiestore_filterrequest_wrapper.cpp
+# FIXME ${QtWebEngineCore_GEN_DIR}/qwebenginedesktopmediarequest_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginedownloadrequest_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebenginefilesystemaccessrequest_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebenginefindtextresult_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginefullscreenrequest_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebengineglobalsettings_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebengineglobalsettings_dnsmode_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginehistory_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginehistoryitem_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginehistorymodel_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginehttprequest_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebenginenavigationrequest_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineloadinginfo_wrapper.cpp
+# FIXME ${QtWebEngineCore_GEN_DIR}/qwebenginemediasourcemodel_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginenewwindowrequest_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginenotification_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginepage_wrapper.cpp
@@ -21,12 +33,13 @@ ${QtWebEngineCore_GEN_DIR}/qwebengineregisterprotocolhandlerrequest_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginescript_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginescriptcollection_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebenginesettings_wrapper.cpp
-${QtWebEngineCore_GEN_DIR}/qwebenginefindtextresult_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineurlrequestinfo_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineurlrequestinterceptor_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineurlrequestjob_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineurlscheme_wrapper.cpp
 ${QtWebEngineCore_GEN_DIR}/qwebengineurlschemehandler_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebenginewebauthpinrequest_wrapper.cpp
+${QtWebEngineCore_GEN_DIR}/qwebenginewebauthuxrequest_wrapper.cpp
 # module is always needed
 ${QtWebEngineCore_GEN_DIR}/qtwebenginecore_module_wrapper.cpp
 )
@@ -46,17 +59,10 @@ set(QtWebEngineCore_include_dirs
                             ${QtWidgets_GEN_DIR}
                             ${QtNetwork_GEN_DIR}
                             ${QtPrintSupport_GEN_DIR}
-                            ${QtWebChannel_GEN_DIR}
-                            )
+                            ${QtWebChannel_GEN_DIR})
+
 set(QtWebEngineCore_libraries pyside6
-                            ${Qt${QT_MAJOR_VERSION}WebEngineCore_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}PrintSupport_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}WebChannel_LIBRARIES}
-                            )
+                              ${Qt${QT_MAJOR_VERSION}WebEngineCore_LIBRARIES})
 
 set(QtWebEngineCore_deps QtCore QtGui QtNetwork QtPrintSupport QtWebChannel)
 
diff --git a/sources/pyside6/PySide6/QtWebEngineCore/typesystem_webenginecore.xml b/sources/pyside6/PySide6/QtWebEngineCore/typesystem_webenginecore.xml
index 4bf710f04..da9259ccc 100644
--- a/sources/pyside6/PySide6/QtWebEngineCore/typesystem_webenginecore.xml
+++ b/sources/pyside6/PySide6/QtWebEngineCore/typesystem_webenginecore.xml
@@ -3,14 +3,26 @@
 // Copyright (C) 2018 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWebEngineCore">
+<typesystem package="PySide6.QtWebEngineCore"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
   <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
   <load-typesystem name="QtPrintSupport/typesystem_printsupport.xml" generate="no"/>
   <load-typesystem name="QtWebChannel/typesystem_webchannel.xml" generate="no"/>
 
+   <rejection class="extensions"/>
+
+  <function signature="qWebEngineChromiumVersion()"/>
+  <function signature="qWebEngineChromiumSecurityPatchVersion()"/>
+  <function signature="qWebEngineVersion()"/>
+
+  <value-type name="QWebEngineClientCertificateSelection"/>
+  <object-type name="QWebEngineClientCertificateStore"/>
+
   <object-type name="QWebEngineCookieStore">
+    <inject-code class="native" position="beginning" file="../glue/qtwebenginecore.cpp"
+                 snippet="qwebenginecookiestore-functor"/>
     <value-type name="FilterRequest" />
     <add-function signature="setCookieFilter(PyCallable* @filterCallback@)">
       <inject-code class="target" position="beginning" file="../glue/qtwebenginecore.cpp"
@@ -34,6 +46,13 @@
     <enum-type name="SavePageFormat"/>
   </object-type>
 
+  <value-type name="QWebEngineFileSystemAccessRequest">
+    <enum-type name="AccessFlag" flags="AccessFlags"/>
+    <enum-type name="HandleType"/>
+    <!-- No default constructor -->
+    <modify-function signature="swap(QWebEngineFileSystemAccessRequest&amp;)" remove="all"/>
+  </value-type>
+
   <value-type name="QWebEngineFullScreenRequest"/>
 
   <object-type name="QWebEngineHistory"/>
@@ -45,6 +64,11 @@
     <enum-type name="Roles"/>
   </object-type>
 
+  <object-type name="QWebEngineNavigationRequest">
+      <enum-type name="NavigationType"/>
+      <enum-type name="NavigationRequestAction"/>
+  </object-type>
+
   <object-type name="QWebEngineNotification"/>
 
   <object-type name="QWebEnginePage">
@@ -58,6 +82,16 @@
     <enum-type name="FileSelectionMode"/>
     <enum-type name="JavaScriptConsoleMessageLevel"/>
     <enum-type name="RenderProcessTerminationStatus"/>
+    <add-function signature="javaScriptPromptPyOverride(QUrl@securityOrigin@,QString@msg@,QString@defaultValue@)"
+                  return-type="std::pair&lt;bool,QString&gt;" python-override="true"/>
+    <modify-function signature="javaScriptPrompt(QUrl,QString,QString,QString*)">
+      <inject-code class="shell" position="override" file="../glue/qtwebenginecore.cpp"
+                   snippet="qwebenginepage-javascriptprompt-virtual-redirect"/>
+      <modify-argument index="return" pyi-type="Tuple[bool, str]"/>
+      <modify-argument index="4"><remove-default-expression/><remove-argument/></modify-argument>
+      <inject-code class="target" position="beginning" file="../glue/qtwebenginecore.cpp"
+                   snippet="qwebenginepage-javascriptprompt-return"/>
+    </modify-function>
     <add-function signature="findText(const QString &amp;,QWebEnginePage::FindFlags,PyObject*)">
         <inject-code class="target" position="beginning" file="../glue/qtwebenginewidgets.cpp" snippet="qwebenginepage-findtext"/>
     </add-function>
@@ -76,6 +110,8 @@
     <extra-includes>
         <include file-name="QtWebEngineCore/QWebEngineNotification" location="global"/>
     </extra-includes>
+    <inject-code class="native" position="beginning" file="../glue/qtwebenginecore.cpp"
+                 snippet="qwebengineprofile-functor"/>
     <enum-type name="HttpCacheType"/>
     <enum-type name="PersistentCookiesPolicy"/>
     <add-function signature="setNotificationPresenter(PyCallable* @notificationPresenter@)">
@@ -110,7 +146,7 @@
     <enum-type name="LoadStatus"/>
   </value-type>
 
-  <object-type name="QWebEngineRegisterProtocolHandlerRequest"/>
+  <value-type name="QWebEngineRegisterProtocolHandlerRequest"/>
 
   <value-type name="QWebEngineFindTextResult"/>
 
@@ -134,4 +170,23 @@
 
   <object-type name="QWebEngineUrlSchemeHandler"/>
 
+  <!-- FIXME  not in snapshot yet
+  <value-type name="QWebEngineDesktopMediaRequest" since="6.7"/>
+  <object-type name="QWebEngineMediaSourceModel" since="6.7"/>
+  -->
+  <value-type name="QWebEngineWebAuthPinRequest" since="6.7"/>
+  <object-type name="QWebEngineWebAuthUxRequest" since="6.7">
+      <enum-type name="WebAuthUxState"/>
+      <enum-type name="PinEntryReason"/>
+      <enum-type name="PinEntryError"/>
+      <enum-type name="RequestFailureReason"/>
+  </object-type>
+  <namespace-type name="QWebEngineGlobalSettings">
+      <enum-type name="SecureDnsMode"/>
+      <value-type name="DnsMode"/>
+  </namespace-type>
+
+  <!-- QtQml is pulled in via QtWebEngineCoreDepends. -->
+  <suppress-warning text="^Scoped enum 'QQml.*' does not have a type entry.*$"/>
+
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtWebEngineQuick/CMakeLists.txt b/sources/pyside6/PySide6/QtWebEngineQuick/CMakeLists.txt
index 1f3b7d9af..d87dc55a4 100644
--- a/sources/pyside6/PySide6/QtWebEngineQuick/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWebEngineQuick/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWebEngineQuick)
 
 set(QtWebEngineQuick_SRC
@@ -11,22 +14,26 @@ set(QtWebEngineQuick_include_dirs
                             ${QtWebEngineQuick_SOURCE_DIR}
                             ${QtWebEngineQuick_BINARY_DIR}
                             ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
+                            ${Qt${QT_MAJOR_VERSION}Gui_INCLUDE_DIRS}
+                            ${Qt${QT_MAJOR_VERSION}Widgets_INCLUDE_DIRS}
                             ${Qt${QT_MAJOR_VERSION}Network_INCLUDE_DIRS}
+                            ${Qt${QT_MAJOR_VERSION}PrintSupport_INCLUDE_DIRS}
                             ${Qt${QT_MAJOR_VERSION}Qml_INCLUDE_DIRS}
+                            ${Qt${QT_MAJOR_VERSION}WebChannel_INCLUDE_DIRS}
                             ${libpyside_SOURCE_DIR}
                             ${QtCore_GEN_DIR}
+                            ${QtGui_GEN_DIR}
+                            ${QtWidgets_GEN_DIR}
                             ${QtNetwork_GEN_DIR}
+                            ${QtWebEngineCore_GEN_DIR}
+                            ${QtPrintSupport_GEN_DIR}
                             ${QtQml_GEN_DIR}
-                            )
+                            ${QtWebChannel_GEN_DIR})
 
 set(QtWebEngineQuick_libraries pyside6
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Qml_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}WebEngineQuick_LIBRARIES}
-                            )
+                               ${Qt${QT_MAJOR_VERSION}WebEngineQuick_LIBRARIES})
 
-set(QtWebEngineQuick_deps QtQml QtNetwork QtCore)
+set(QtWebEngineQuick_deps QtQml QtWebEngineCore)
 
 create_pyside_module(NAME QtWebEngineQuick
                      INCLUDE_DIRS QtWebEngineQuick_include_dirs
diff --git a/sources/pyside6/PySide6/QtWebEngineQuick/typesystem_webenginequick.xml b/sources/pyside6/PySide6/QtWebEngineQuick/typesystem_webenginequick.xml
index 72a31deb2..2e7d22334 100644
--- a/sources/pyside6/PySide6/QtWebEngineQuick/typesystem_webenginequick.xml
+++ b/sources/pyside6/PySide6/QtWebEngineQuick/typesystem_webenginequick.xml
@@ -3,8 +3,10 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWebEngineQuick">
+<typesystem package="PySide6.QtWebEngineQuick"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtQml/typesystem_qml.xml" generate="no"/>
+    <load-typesystem name="QtWebEngineCore/typesystem_webenginecore.xml" generate="no"/>
 
     <namespace-type name="QtWebEngineQuick"/> <!-- initialize() -->
 
diff --git a/sources/pyside6/PySide6/QtWebEngineWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtWebEngineWidgets/CMakeLists.txt
index c43be68f1..9da97243c 100644
--- a/sources/pyside6/PySide6/QtWebEngineWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWebEngineWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWebEngineWidgets)
 
 set(QtWebEngineWidgets_SRC
@@ -24,17 +27,10 @@ set(QtWebEngineWidgets_include_dirs
                             ${QtNetwork_GEN_DIR}
                             ${QtWebEngineCore_GEN_DIR}
                             ${QtPrintSupport_GEN_DIR}
-                            ${QtWebChannel_GEN_DIR}
-                            )
-set(QtWebEngineWidgets_libraries      pyside6
-                            ${Qt${QT_MAJOR_VERSION}WebEngineWidgets_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}PrintSupport_LIBRARIES}
-                            ${Qt${QT_MAJOR_VERSION}WebChannel_LIBRARIES}
-                            )
+                            ${QtWebChannel_GEN_DIR})
+
+set(QtWebEngineWidgets_libraries pyside6
+                                 ${Qt${QT_MAJOR_VERSION}WebEngineWidgets_LIBRARIES})
 
 set(QtWebEngineWidgets_deps QtGui QtWidgets QtNetwork QtPrintSupport QtWebChannel QtWebEngineCore)
 
diff --git a/sources/pyside6/PySide6/QtWebEngineWidgets/typesystem_webenginewidgets.xml b/sources/pyside6/PySide6/QtWebEngineWidgets/typesystem_webenginewidgets.xml
index fb5e6d379..61874856b 100644
--- a/sources/pyside6/PySide6/QtWebEngineWidgets/typesystem_webenginewidgets.xml
+++ b/sources/pyside6/PySide6/QtWebEngineWidgets/typesystem_webenginewidgets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWebEngineWidgets">
+<typesystem package="PySide6.QtWebEngineWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
   <load-typesystem name="QtWidgets/typesystem_widgets.xml" generate="no"/>
diff --git a/sources/pyside6/PySide6/QtWebSockets/CMakeLists.txt b/sources/pyside6/PySide6/QtWebSockets/CMakeLists.txt
index 657554a5e..5ff07555b 100644
--- a/sources/pyside6/PySide6/QtWebSockets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWebSockets/CMakeLists.txt
@@ -1,20 +1,19 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWebSockets)
 
 set(QtWebSockets_SRC
 ${QtWebSockets_GEN_DIR}/qmaskgenerator_wrapper.cpp
 ${QtWebSockets_GEN_DIR}/qwebsocket_wrapper.cpp
 ${QtWebSockets_GEN_DIR}/qwebsocketcorsauthenticator_wrapper.cpp
+${QtWebSockets_GEN_DIR}/qwebsockethandshakeoptions_wrapper.cpp
 ${QtWebSockets_GEN_DIR}/qwebsocketprotocol_wrapper.cpp
 ${QtWebSockets_GEN_DIR}/qwebsocketserver_wrapper.cpp
 # module is always needed
 ${QtWebSockets_GEN_DIR}/qtwebsockets_module_wrapper.cpp
 )
 
-if (Qt${QT_MAJOR_VERSION}WebSockets_VERSION VERSION_GREATER_EQUAL 6.4.0)
-    list(APPEND QtWebSockets_SRC
-         ${QtWebSockets_GEN_DIR}/qwebsockethandshakeoptions_wrapper.cpp)
-endif()
-
 set(QtWebSockets_include_dirs ${QtWebSockets_SOURCE_DIR}
                         ${QtWebSockets_BINARY_DIR}
                         ${Qt${QT_MAJOR_VERSION}Core_INCLUDE_DIRS}
@@ -23,13 +22,10 @@ set(QtWebSockets_include_dirs ${QtWebSockets_SOURCE_DIR}
                         ${libpyside_SOURCE_DIR}
                         ${QtCore_GEN_DIR}
                         ${QtWebSockets_GEN_DIR}
-                        ${QtNetwork_GEN_DIR}
-                        )
-set(QtWebSockets_libraries    pyside6
-                        ${Qt${QT_MAJOR_VERSION}WebSockets_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Network_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        )
+                        ${QtNetwork_GEN_DIR})
+
+set(QtWebSockets_libraries pyside6
+                           ${Qt${QT_MAJOR_VERSION}WebSockets_LIBRARIES})
 
 set(QtWebSockets_deps QtNetwork)
 
diff --git a/sources/pyside6/PySide6/QtWebSockets/typesystem_websockets.xml b/sources/pyside6/PySide6/QtWebSockets/typesystem_websockets.xml
index 914c8ce81..2d8d95898 100644
--- a/sources/pyside6/PySide6/QtWebSockets/typesystem_websockets.xml
+++ b/sources/pyside6/PySide6/QtWebSockets/typesystem_websockets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWebSockets">
+<typesystem package="PySide6.QtWebSockets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="QtCore/typesystem_core.xml" generate="no"/>
   <load-typesystem name="QtNetwork/typesystem_network.xml" generate="no"/>
 
diff --git a/sources/pyside6/PySide6/QtWidgets/CMakeLists.txt b/sources/pyside6/PySide6/QtWidgets/CMakeLists.txt
index 85d4cdfd2..1a77181f2 100644
--- a/sources/pyside6/PySide6/QtWidgets/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtWidgets)
 
 set(QtWidgets_SRC
@@ -113,6 +116,7 @@ ${QtWidgets_GEN_DIR}/qprogressdialog_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qproxystyle_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qpushbutton_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qradiobutton_wrapper.cpp
+${QtWidgets_GEN_DIR}/qrhiwidget_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qrubberband_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qscrollarea_wrapper.cpp
 ${QtWidgets_GEN_DIR}/qscrollbar_wrapper.cpp
@@ -206,13 +210,11 @@ set(QtWidgets_include_dirs  ${QtWidgets_SOURCE_DIR}
                             ${Qt${QT_MAJOR_VERSION}Widgets_INCLUDE_DIRS}
                             ${libpyside_SOURCE_DIR}
                             ${QtCore_GEN_DIR}
-                            ${QtGui_GEN_DIR}
-                            )
+                            ${QtGui_GEN_DIR})
+
 set(QtWidgets_libraries pyside6
-                        ${Qt${QT_MAJOR_VERSION}Core_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Gui_LIBRARIES}
-                        ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES}
-                        )
+                        ${Qt${QT_MAJOR_VERSION}Widgets_LIBRARIES})
+
 set(QtWidgets_deps QtGui)
 
 create_pyside_module(NAME QtWidgets
diff --git a/sources/pyside6/PySide6/QtWidgets/typesystem_widgets.xml b/sources/pyside6/PySide6/QtWidgets/typesystem_widgets.xml
index fabd87d22..93a7151fc 100644
--- a/sources/pyside6/PySide6/QtWidgets/typesystem_widgets.xml
+++ b/sources/pyside6/PySide6/QtWidgets/typesystem_widgets.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWidgets">
+<typesystem package="PySide6.QtWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtGui/typesystem_gui.xml" generate="no"/>
     <load-typesystem name="QtWidgets/typesystem_widgets_common.xml" generate="yes"/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtWidgets/typesystem_widgets_common.xml b/sources/pyside6/PySide6/QtWidgets/typesystem_widgets_common.xml
index f8d37dee0..b1188a514 100644
--- a/sources/pyside6/PySide6/QtWidgets/typesystem_widgets_common.xml
+++ b/sources/pyside6/PySide6/QtWidgets/typesystem_widgets_common.xml
@@ -3,7 +3,8 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtWidgets">
+<typesystem package="PySide6.QtWidgets"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
   <load-typesystem name="templates/core_common.xml" generate="no"/>
   <load-typesystem name="templates/widgets_common.xml" generate="no"/>
 
@@ -29,16 +30,8 @@
     enum 'QGraphicsPolygonItem::Type' does not have a type entry or is not an enum
   """
   -->
-  <rejection class="*" enum-name="enum_1"/>
-
   <rejection class="QMdi"/>
 
-  <!--
-    Event classes have a lot of non-documented protected fields, those fields
-    are removed from PySide because they are Qt implementation details,
-    besides the fact they are accessible by ordinary event methods.
-    -->
-
   <function signature="qDrawShadeLine(QPainter*,int,int,int,int,const QPalette&amp;,bool,int,int)"/>
   <function signature="qDrawShadeLine(QPainter*,const QPoint,const QPoint,const QPalette&amp;,bool,int,int)"/>
   <function signature="qDrawShadeRect(QPainter*,int,int,int,int,const QPalette&amp;,bool,int,int,const QBrush*)"/>
@@ -51,8 +44,10 @@
   <function signature="qDrawWinPanel(QPainter*,const QRect&amp;,const QPalette&amp;,bool,const QBrush*)"/>
   <function signature="qDrawPlainRect(QPainter*,int,int,int,int,const QColor&amp;,int,const QBrush*)"/>
   <function signature="qDrawPlainRect(QPainter*,const QRect&amp;,const QColor&amp;,int,const QBrush*)"/>
+  <function signature="qDrawPlainRoundedRect(QPainter*,int,int,int,int,qreal,qreal,const QColor&amp;,int,const QBrush*)" since="6.7"/>
+  <function signature="qDrawPlainRoundedRect(QPainter*,const QRect&amp;,qreal,qreal,const QColor&amp;,int,const QBrush *)" since="6.7"/>
 
-  <object-type name="QStyleOption" polymorphic-id-expression="%1-&gt;type == QStyleOption::SO_Default"
+  <object-type name="QStyleOption" polymorphic-id-expression="%B-&gt;type == QStyleOption::SO_Default"
                polymorphic-name-function="styleOptionType">
     <inject-code class="native" position="beginning" file="../glue/qtwidgets.cpp"
                  snippet="qstyleoption-typename"/>
@@ -60,45 +55,54 @@
     <enum-type name="StyleOptionType"/>
     <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionGraphicsItem" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionGraphicsItem *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionGraphicsItem"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionGraphicsItem *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionSizeGrip" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSizeGrip *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionSizeGrip"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSizeGrip *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionButton" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionButton *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionButton"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionButton *&gt;(%B) != nullptr">
       <enum-type name="ButtonFeature" flags="ButtonFeatures"/>
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionComboBox" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionComboBox *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionComboBox"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionComboBox *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionComplex" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionComplex *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionComplex"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionComplex *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionDockWidget" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionDockWidget *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionDockWidget"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionDockWidget *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionFocusRect" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionFocusRect *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionFocusRect" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionFocusRect *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionFrame" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionFrame *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionFrame"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionFrame *&gt;(%B) != nullptr">
       <enum-type name="FrameFeature" flags="FrameFeatures"/>
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionGroupBox" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionGroupBox *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionGroupBox"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionGroupBox *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionHeader" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionHeader *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionHeader"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionHeader *&gt;(%B) != nullptr">
       <enum-type name="SectionPosition"/>
       <enum-type name="SelectedPosition"/>
       <enum-type name="SortIndicator"/>
@@ -109,29 +113,35 @@
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionMenuItem" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionMenuItem *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionMenuItem"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionMenuItem *&gt;(%B) != nullptr">
       <enum-type name="CheckType"/>
       <enum-type name="MenuItemType"/>
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionProgressBar" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionProgressBar *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionProgressBar"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionProgressBar *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionRubberBand" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionRubberBand *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionRubberBand"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionRubberBand *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionSlider" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSlider *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionSlider"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSlider *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionSpinBox" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSpinBox *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionSpinBox"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionSpinBox *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionTab" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTab *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionTab"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTab *&gt;(%B) != nullptr">
       <enum-type name="CornerWidget" flags="CornerWidgets"/>
       <enum-type name="SelectedPosition"/>
       <enum-type name="StyleOptionType"/>
@@ -139,36 +149,41 @@
       <enum-type name="TabFeature" flags="TabFeatures"/>
       <enum-type name="TabPosition"/>
   </object-type>
-  <object-type name="QStyleOptionTabBarBase" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTabBarBase *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionTabBarBase"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTabBarBase *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionTabWidgetFrame" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTabWidgetFrame *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionTabWidgetFrame"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTabWidgetFrame *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionTitleBar" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTitleBar *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionTitleBar" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionTitleBar *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
   </object-type>
-  <object-type name="QStyleOptionToolBar" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolBar *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionToolBar"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolBar *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
       <enum-type name="ToolBarFeature" flags="ToolBarFeatures"/>
       <enum-type name="ToolBarPosition"/>
   </object-type>
-  <object-type name="QStyleOptionToolBox" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolBox *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionToolBox"
+               polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolBox *&gt;(%B) != nullptr">
       <enum-type name="SelectedPosition"/>
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
       <enum-type name="TabPosition"/>
   </object-type>
-  <object-type name="QStyleOptionToolButton" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolButton *&gt;(%1) != nullptr">
+  <object-type name="QStyleOptionToolButton" polymorphic-id-expression="qstyleoption_cast&lt;const QStyleOptionToolButton *&gt;(%B) != nullptr">
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
       <enum-type name="ToolButtonFeature" flags="ToolButtonFeatures"/>
   </object-type>
-  <value-type name="QStyleOptionViewItem" polymorphic-id-expression="%1-&gt;type == QStyleOptionViewItem::Type &amp;&amp; %1-&gt;version == QStyleOptionViewItem::Version">
+  <value-type name="QStyleOptionViewItem"
+              polymorphic-id-expression="%B-&gt;type == QStyleOptionViewItem::Type &amp;&amp; %B-&gt;version == QStyleOptionViewItem::Version">
       <enum-type name="Position"/>
       <enum-type name="StyleOptionType"/>
       <enum-type name="StyleOptionVersion"/>
@@ -318,7 +333,7 @@
       <modify-argument index="1">
         <remove-argument/>
       </modify-argument>
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[bool, PySide6.QtWidgets.QGraphicsItem]">
         <replace-type modified-type="(retval, blockingPanel)"/>
       </modify-argument>
       <inject-code class="target" position="beginning" file="../glue/qtwidgets.cpp" snippet="qgraphicsitem-isblockedbymodalpanel"/>
@@ -328,7 +343,7 @@
             <remove-argument />
             <remove-default-expression />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[PySide6.QtGui.QTransform, bool]">
             <replace-type modified-type="(QTransform, bool ok)"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -388,7 +403,7 @@
     <enum-type name="SelectionMode"/>
     <enum-type name="State"/>
     <modify-function signature="setModel(QAbstractItemModel*)">
-      <modify-argument index="1">
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtCore.QAbstractItemModel]">
         <reference-count action="set"/>
       </modify-argument>
     </modify-function>
@@ -476,7 +491,9 @@
   <object-type name="QDateEdit"/>
   <object-type name="QDialog">
     <enum-type name="DialogCode" python-type="IntEnum"/>
-    <modify-function signature="exec()" allow-thread="yes"/>
+    <modify-function signature="exec()" allow-thread="yes">
+        <inject-code file="../glue/qtwidgets.cpp" snippet="qdialog-exec-remove-parent-relation"/>
+    </modify-function>
     <add-function signature="exec_()" return-type="int">
         <inject-code file="../glue/qtwidgets.cpp" snippet="qapplication-exec"/>
     </add-function>
@@ -520,12 +537,23 @@
     </modify-function>
   </object-type>
   <object-type name="QWizardPage">
+    <extra-includes>
+        <include file-name="pysidesignal.h" location="global"/>
+    </extra-includes>
     <modify-function signature="wizard()const">
       <modify-argument index="this">
         <parent index="return" action="add"/>
       </modify-argument>
     </modify-function>
-    <modify-function signature="registerField(const QString&amp;,QWidget*,const char*,const char*)" allow-thread="yes"/>
+    <modify-function signature="registerField(const QString&amp;,QWidget*,const char*,const char*)" allow-thread="yes">
+        <modify-argument index="3" pyi-type="str" rename="property"/>
+        <modify-argument index="4" pyi-type="str" rename="changed_signal"/>
+    </modify-function>
+    <add-function signature="registerField(const QString&amp;@name@,QWidget*@widget@,const char*@property@,PySideSignalInstance@changedSignal@)">
+        <modify-argument index="3" pyi-type="str"/>
+            <inject-code class="target" position="beginning" file="../glue/qtwidgets.cpp"
+                         snippet="qwizardpage-registerfield"/>
+        </add-function>
   </object-type>
   <object-type name="QFocusFrame">
     <modify-function signature="setWidget(QWidget*)">
@@ -543,7 +571,7 @@
         <modify-argument index="1">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[bool, PySide6.QtGui.QFont]">
             <replace-type modified-type="PyTuple"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -554,7 +582,7 @@
         <modify-argument index="1">
             <remove-argument />
         </modify-argument>
-        <modify-argument index="return">
+        <modify-argument index="return" pyi-type="Tuple[bool, PySide6.QtGui.QFont]">
             <replace-type modified-type="PyTuple"/>
         </modify-argument>
         <inject-code class="target" position="beginning">
@@ -1063,12 +1091,14 @@
       </modify-argument>
     </modify-function>
   </object-type>
-  <object-type name="QWidgetItem" polymorphic-id-expression="%1-&gt;widget()"/>
+  <object-type name="QWidgetItem" polymorphic-id-expression="%B-&gt;widget()"/>
 
-  <object-type name="QGraphicsSceneContextMenuEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneContextMenu">
+  <object-type name="QGraphicsSceneContextMenuEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneContextMenu">
       <enum-type name="Reason"/>
   </object-type>
-  <object-type name="QGraphicsSceneDragDropEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneDragEnter || %1-&gt;type() == QEvent::GraphicsSceneDragLeave || %1-&gt;type() == QEvent::GraphicsSceneDragMove || %1-&gt;type() == QEvent::GraphicsSceneDrop" >
+  <object-type name="QGraphicsSceneDragDropEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneDragEnter || %B-&gt;type() == QEvent::GraphicsSceneDragLeave || %B-&gt;type() == QEvent::GraphicsSceneDragMove || %B-&gt;type() == QEvent::GraphicsSceneDrop" >
     <!-- ### "setMimeData(const QMimeData*)" is an internal method. -->
     <modify-function signature="setMimeData(const QMimeData*)" remove="all"/>
     <!-- ### "setSource(QWidget*)" is an internal method. -->
@@ -1079,14 +1109,21 @@
     <!-- ### "setWidget(QWidget*)" is an internal method. -->
     <modify-function signature="setWidget(QWidget*)" remove="all"/>
   </object-type>
-  <object-type name="QGraphicsSceneMoveEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneMove"/>
-  <object-type name="QGraphicsSceneResizeEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneResize"/>
-  <object-type name="QGraphicsSceneHelpEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneHelp"/>
-  <object-type name="QGraphicsSceneHoverEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneHoverEnter || %1-&gt;type() == QEvent::GraphicsSceneHoverLeave || %1-&gt;type() == QEvent::GraphicsSceneHoverMove"/>
-  <object-type name="QGraphicsSceneMouseEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneMouseDoubleClick || %1-&gt;type() == QEvent::GraphicsSceneMouseMove || %1-&gt;type() == QEvent::GraphicsSceneMousePress || %1-&gt;type() == QEvent::GraphicsSceneMouseRelease"/>
-  <object-type name="QGraphicsSceneWheelEvent" copyable="false" polymorphic-id-expression="%1-&gt;type() == QEvent::GraphicsSceneWheel"/>
-
-  <object-type name="QGestureEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Gesture || %1-&gt;type() == QEvent::GestureOverride" since="4.6">
+  <object-type name="QGraphicsSceneMoveEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneMove"/>
+  <object-type name="QGraphicsSceneResizeEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneResize"/>
+  <object-type name="QGraphicsSceneHelpEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneHelp"/>
+  <object-type name="QGraphicsSceneHoverEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneHoverEnter || %B-&gt;type() == QEvent::GraphicsSceneHoverLeave || %B-&gt;type() == QEvent::GraphicsSceneHoverMove"/>
+  <object-type name="QGraphicsSceneMouseEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneMouseDoubleClick || %B-&gt;type() == QEvent::GraphicsSceneMouseMove || %B-&gt;type() == QEvent::GraphicsSceneMousePress || %B-&gt;type() == QEvent::GraphicsSceneMouseRelease"/>
+  <object-type name="QGraphicsSceneWheelEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::GraphicsSceneWheel"/>
+
+  <object-type name="QGestureEvent"
+               polymorphic-id-expression="%B-&gt;type() == QEvent::Gesture || %B-&gt;type() == QEvent::GestureOverride" since="4.6">
     <modify-function signature="activeGestures()const">
       <modify-argument index="return">
         <define-ownership owner="default"/>
@@ -1168,7 +1205,7 @@
     <modify-function signature="getColor(const QColor&amp;,QWidget*,const QString&amp;,QFlags&lt;QColorDialog::ColorDialogOption>)" allow-thread="yes"/>
   </object-type>
 
-  <object-type name="QLayout">
+  <object-type name="QLayout" polymorphic-base="true">
     <inject-code class="native" position="beginning" file="../glue/qtwidgets.cpp"
                  snippet="qwidget-retrieveobjectname"/>
     <inject-code class="native" position="beginning" file="../glue/qtwidgets.cpp" snippet="qlayout-help-functions"/>
@@ -1178,7 +1215,8 @@
       <modify-argument index="return">
         <define-ownership owner="default"/>
       </modify-argument>
-      <inject-code class="target" position="end" file="../glue/qtwidgets.cpp" snippet="addownership-0"/>
+      <inject-code class="target" position="end" file="../glue/qtwidgets.cpp"
+                   snippet="addownership-item-at"/>
     </modify-function>
 
     <modify-function signature="removeWidget(QWidget*)">
@@ -1312,7 +1350,8 @@
       <modify-argument index="return">
         <define-ownership owner="default"/>
       </modify-argument>
-      <inject-code class="target" position="end" file="../glue/qtwidgets.cpp" snippet="addownership-0"/>
+      <inject-code class="target" position="end" file="../glue/qtwidgets.cpp"
+                   snippet="addownership-item-at"/>
     </modify-function>
     <modify-function signature="addWidget(QWidget*,int,int,QFlags&lt;Qt::AlignmentFlag&gt;)">
       <modify-argument index="4">
@@ -1382,7 +1421,7 @@
     <enum-type name="ViewportAnchor"/>
     <enum-type name="ViewportUpdateMode"/>
     <modify-function signature="setScene(QGraphicsScene*)">
-      <modify-argument index="1">
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtWidgets.QGraphicsScene]">
         <reference-count action="set"/>
       </modify-argument>
     </modify-function>
@@ -1941,9 +1980,12 @@
     <modify-function signature="removeItemWidget(QListWidgetItem*)" allow-thread="yes"/>
   </object-type>
 
-  <object-type name="QWidget" delete-in-main-thread="true">
+  <object-type name="QWidget" delete-in-main-thread="true" polymorphic-base="true">
     <!-- see QWindow::nativeEvent(), QAbstractNativeEventFilter::nativeEventFilter() -->
     <inject-code class="native" position="beginning" file="../glue/qtwidgets.cpp" snippet="qwidget-addaction-glue"/>
+    <inject-code class="native" position="beginning">
+    #include &lt;QtWidgets/qapplication.h&gt;
+    </inject-code>
     <modify-function signature="nativeEvent(const QByteArray &amp;,void*,qintptr*)">
       <modify-argument index="3">
         <remove-argument/>
@@ -1979,18 +2021,17 @@
       <modify-argument index="this">
         <parent index="1" action="add"/>
       </modify-argument>
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtWidgets.QWidget]"/>
     </modify-function>
 
     <modify-function signature="setParent(QWidget*,QFlags&lt;Qt::WindowType&gt;)">
       <modify-argument index="this">
         <parent index="1" action="add"/>
       </modify-argument>
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtWidgets.QWidget]"/>
     </modify-function>
 
     <modify-function signature="parentWidget()const">
-        <modify-argument index="this">
-          <parent index="return" action="add"/>
-        </modify-argument>
         <modify-argument index="return">
           <define-ownership class="target" owner="default"/>
         </modify-argument>
@@ -2245,6 +2286,7 @@
       <modify-argument index="this">
         <parent index="1" action="add"/>
       </modify-argument>
+      <modify-argument index="1" pyi-type="Optional[PySide6.QtWidgets.QWidget]"/>
     </modify-function>
 
     <modify-function signature="window()const">
@@ -2258,6 +2300,7 @@
     <enum-type name="ButtonRole"/>
     <enum-type name="Icon"/>
     <enum-type name="StandardButton" python-type="IntFlag" flags="StandardButtons"/>
+    <enum-type name="Option" flags="Options" since="6.6"/>
     <modify-function signature="removeButton(QAbstractButton*)">
       <modify-argument index="1">
         <parent index="this" action="add"/>
@@ -2431,7 +2474,7 @@
     <modify-function signature="getExistingDirectory(QWidget*,const QString&amp;,const QString&amp;,QFlags&lt;QFileDialog::Option>)" allow-thread="yes"/>
     <modify-function signature="getExistingDirectoryUrl(QWidget*,const QString&amp;,const QUrl&amp;,QFlags&lt;QFileDialog::Option>,const QStringList&amp;)" allow-thread="yes"/>
     <modify-function signature="getOpenFileName(QWidget*,const QString&amp;,const QString&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return"  pyi-type="Tuple[str, str]">
         <replace-type modified-type="(fileName, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2441,7 +2484,7 @@
       <inject-code class="target" position="end" file="../glue/qtwidgets.cpp" snippet="qfiledialog-return" />
     </modify-function>
     <modify-function signature="getOpenFileNames(QWidget*,const QString&amp;,const QString&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[List[str], str]">
         <replace-type modified-type="(fileNames, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2452,7 +2495,7 @@
     </modify-function>
 
     <modify-function signature="getOpenFileUrl(QWidget*,const QString&amp;,const QUrl&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;,const QStringList&amp;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[PySide6.QtCore.QUrl, str]">
         <replace-type modified-type="(fileName, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2463,7 +2506,7 @@
     </modify-function>
 
     <modify-function signature="getOpenFileUrls(QWidget*,const QString&amp;,const QUrl&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;,const QStringList&amp;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[List[PySide6.QtCore.QUrl], str]">
         <replace-type modified-type="(fileName, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2474,7 +2517,7 @@
     </modify-function>
 
     <modify-function signature="getSaveFileName(QWidget*,const QString&amp;,const QString&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[str, str]">
         <replace-type modified-type="(fileName, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2485,7 +2528,7 @@
     </modify-function>
 
     <modify-function signature="getSaveFileUrl(QWidget*,const QString&amp;,const QUrl&amp;,const QString&amp;,QString*,QFlags&lt;QFileDialog::Option&gt;,const QStringList&amp;)" allow-thread="yes">
-      <modify-argument index="return">
+      <modify-argument index="return" pyi-type="Tuple[PySide6.QtCore.QUrl, str]">
         <replace-type modified-type="(fileName, selectedFilter)"/>
       </modify-argument>
       <modify-argument index="5">
@@ -2875,7 +2918,7 @@
 
   <object-type name="QCommandLinkButton"/>
   <!-- FIXME PYSIDE7: Move to QtGui -->
-  <object-type name="QFileSystemModel" polymorphic-id-expression="qobject_cast&lt;QFileSystemModel*&gt;(%1)">
+  <object-type name="QFileSystemModel" polymorphic-id-expression="qobject_cast&lt;QFileSystemModel*&gt;(%B)">
     <enum-type name="Roles" python-type="IntEnum"/>
     <enum-type name="Option" flags="Options"/>
     <modify-function signature="setIconProvider(QAbstractFileIconProvider*)">
@@ -3300,6 +3343,16 @@
   </object-type>
   <object-type name="QGestureRecognizer" since="4.6">
       <enum-type name="ResultFlag" flags="Result"/>
+      <modify-function signature="create(QObject*)">
+        <modify-argument index="return">
+            <define-ownership owner="c++"/>
+        </modify-argument>
+      </modify-function>
+      <modify-function signature="registerRecognizer(QGestureRecognizer*)">
+        <modify-argument index="1">
+            <define-ownership owner="c++"/>
+        </modify-argument>
+      </modify-function>
   </object-type>
   <object-type name="QTapAndHoldGesture" since="4.6"/>
   <object-type name="QTapGesture" since="4.6"/>
@@ -3325,6 +3378,12 @@
   <object-type name="QPinchGesture" since="4.6">
       <enum-type name="ChangeFlag" flags="ChangeFlags"/>
   </object-type>
+
+  <object-type name="QRhiWidget" since="6.7">
+      <enum-type name="Api"/>
+      <enum-type name="TextureFormat"/>
+  </object-type>
+
   <object-type name="QSwipeGesture" since="4.6">
       <enum-type name="SwipeDirection"/>
   </object-type>
@@ -3356,21 +3415,6 @@
 
   <!-- The above entries may be present in the system or not. Keep this section organized. -->
 
-  <!-- This enum is present on QtCore -->
-  <suppress-warning text="enum 'QCoreApplication::ApplicationFlags' is specified in typesystem, but not declared"/>
-  <suppress-warning text="QGraphicsEllipseItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsItemGroup::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsItem::UserType' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsLineItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsPathItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsPixmapItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsPolygonItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsProxyWidget::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsRectItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsSimpleTextItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsSvgItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsTextItem::Type' does not have a type entry or is not an enum"/>
-  <suppress-warning text="QGraphicsWidget::Type' does not have a type entry or is not an enum"/>
   <suppress-warning text="signal 'activated' in class 'QCompleter' is overloaded."/>
   <suppress-warning text="signal 'highlighted' in class 'QCompleter' is overloaded."/>
 </typesystem>
diff --git a/sources/pyside6/PySide6/QtXml/CMakeLists.txt b/sources/pyside6/PySide6/QtXml/CMakeLists.txt
index ffb073f69..b0e4630dd 100644
--- a/sources/pyside6/PySide6/QtXml/CMakeLists.txt
+++ b/sources/pyside6/PySide6/QtXml/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(QtXml)
 
 set(QtXml_SRC
@@ -6,6 +9,7 @@ ${QtXml_GEN_DIR}/qdomcdatasection_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomcharacterdata_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomcomment_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomdocument_wrapper.cpp
+${QtXml_GEN_DIR}/qdomdocument_parseresult_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomdocumentfragment_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomdocumenttype_wrapper.cpp
 ${QtXml_GEN_DIR}/qdomelement_wrapper.cpp
diff --git a/sources/pyside6/PySide6/QtXml/typesystem_xml.xml b/sources/pyside6/PySide6/QtXml/typesystem_xml.xml
index 4645f7b91..3661a67bf 100644
--- a/sources/pyside6/PySide6/QtXml/typesystem_xml.xml
+++ b/sources/pyside6/PySide6/QtXml/typesystem_xml.xml
@@ -3,14 +3,12 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 -->
-<typesystem package="PySide6.QtXml">
+<typesystem package="PySide6.QtXml"
+            namespace-begin="QT_BEGIN_NAMESPACE" namespace-end="QT_END_NAMESPACE">
     <load-typesystem name="QtCore/typesystem_core.xml" generate="no" />
     <load-typesystem name="templates/core_common.xml" generate="no" />
 
-    <rejection class="QXmlAttributes::Attribute"/>
     <rejection class="QDomNode" field-name="impl"/>
-    <rejection class="QXmlInputSource" field-name="EndOfData"/>
-    <rejection class="QXmlInputSource" field-name="EndOfDocument"/>
 
     <value-type name="QDomAttr"/>
     <value-type name="QDomCDATASection"/>
@@ -19,7 +17,11 @@
 
 
     <value-type name="QDomDocument">
+        <enum-type name="ParseOption" flags="ParseOptions" since="6.5"/>
         <!-- will be replaced in inject code -->
+
+        <value-type name="ParseResult"/>
+
         <modify-function signature="setContent(const QByteArray&amp;,bool,QString*,int*,int*)">
             <modify-argument index="3">
                 <remove-argument/>
@@ -33,7 +35,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -51,7 +53,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -69,7 +71,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -87,7 +89,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -105,7 +107,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -123,7 +125,7 @@
                 <remove-argument/>
                 <remove-default-expression/>
             </modify-argument>
-            <modify-argument index="return">
+            <modify-argument index="return" pyi-type="Tuple[bool, str, int, int]">
                 <replace-type modified-type="(retval, errorMsg, errorLine, errorColumn)"/>
             </modify-argument>
             <inject-code class="target" position="beginning" file="../glue/qtxml.cpp" snippet="qdomdocument-setcontent" />
@@ -167,12 +169,5 @@
         <modify-function signature="setAttribute(const QString&amp;, qulonglong)" remove="all"/>
     </value-type>
 
-    <object-type name="QXmlContentHandler">
-        <modify-function signature="setDocumentLocator(QXmlLocator*)">
-            <modify-argument index="1">
-                <define-ownership owner="c++"/>
-            </modify-argument>
-        </modify-function>
-    </object-type>
 </typesystem>
 
diff --git a/sources/pyside6/PySide6/_config.py.in b/sources/pyside6/PySide6/_config.py.in
index 740e9a001..27ee0789b 100644
--- a/sources/pyside6/PySide6/_config.py.in
+++ b/sources/pyside6/PySide6/_config.py.in
@@ -14,3 +14,4 @@ version_info = (@BINDING_API_MAJOR_VERSION@, @BINDING_API_MINOR_VERSION@, @BINDI
 @PACKAGE_BUILD_COMMIT_HASH_DESCRIBED@
 @PACKAGE_SETUP_PY_PACKAGE_TIMESTAMP_ASSIGNMENT@
 @PACKAGE_SETUP_PY_PACKAGE_VERSION_ASSIGNMENT@
+@QT_MACOS_DEPLOYMENT_TARGET@
diff --git a/sources/pyside6/PySide6/doc/qtqml_functions.rst b/sources/pyside6/PySide6/doc/qtqml_functions.rst
new file mode 100644
index 000000000..31801b245
--- /dev/null
+++ b/sources/pyside6/PySide6/doc/qtqml_functions.rst
@@ -0,0 +1,152 @@
+// @snippet qmlregistersingletoninstance
+.. py:function:: qmlRegisterSingletonInstance(pytype: type,\
+                                              uri: str,\
+                                              versionMajor: int,\
+                                              versionMinor: int,\
+                                              typeName: str,\
+                                              instanceObject: object) -> int
+
+   :param type pytype: Python class
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str typeName: name exposed to QML
+   :param object instanceObject: singleton object to be registered
+   :return: int (the QML type id)
+
+This function registers a singleton Python object *instanceObject*, with a
+particular *uri* and *typeName*. Its version is a combination of *versionMajor*
+and *versionMinor*. Use this function to register an object of the given type
+*pytype* as a singleton type.
+// @snippet qmlregistersingletoninstance
+
+// @snippet qmlregistersingletontype_qobject_nocallback
+.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str) -> int
+
+   :param type pytype: Python class
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str typeName: name exposed to QML
+   :return: int (the QML type id)
+
+This function registers a Python type as a singleton in the QML system.
+
+Alternatively, the :ref:`QmlSingleton` decorator can be used.
+// @snippet qmlregistersingletontype_qobject_nocallback
+
+// @snippet qmlregistersingletontype_qobject_callback
+.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int
+
+   :param type pytype: Python class
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str typeName: name exposed to QML
+   :param object callback: Python callable (to handle Python type)
+   :return: int (the QML type id)
+
+This function registers a Python type as a singleton in the QML system using
+the provided callback (which gets a QQmlEngine as a parameter) to generate the
+singleton.
+// @snippet qmlregistersingletontype_qobject_callback
+
+// @snippet qmlregistersingletontype_qjsvalue
+.. py:function:: qmlRegisterSingletonType(uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int
+
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str typeName: name exposed to QML
+   :param object callback: Python callable (to handle QJSValue)
+   :return: int (the QML type id)
+
+This function registers a QJSValue as a singleton in the QML system using the
+provided callback (which gets a QQmlEngine as a parameter) to generate the
+singleton.
+// @snippet qmlregistersingletontype_qjsvalue
+
+// @snippet qmlregistertype
+.. py:function:: qmlRegisterType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str) -> int
+
+   :param type pytype: Python class
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str qmlName: name exposed to QML
+   :return: int (the QML type id)
+
+This function registers the Python *type* in the QML system with the name
+*qmlName*, in the library imported from *uri* having the version number
+composed from *versionMajor* and *versionMinor*. For example, this registers a
+Python class 'MySliderItem' as a QML type named 'Slider' for version '1.0' of a
+module called 'com.mycompany.qmlcomponents':
+
+   ::
+
+       qmlRegisterType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider")
+
+Once this is registered, the type can be used in QML by importing the specified
+module name and version number:
+
+   ::
+
+       import com.mycompany.qmlcomponents 1.0
+
+       Slider { ... }
+
+Note that it's perfectly reasonable for a library to register types to older
+versions than the actual version of the library. Indeed, it is normal for the
+new library to allow QML written to previous versions to continue to work, even
+if more advanced versions of some of its types are available.
+// @snippet qmlregistertype
+
+// @snippet qmlregisteruncreatabletype
+.. py:function:: qmlRegisterUncreatableType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str, noCreationReason: str) -> int
+
+   :param type pytype: Python class
+   :param str uri: uri to use while importing the component in QML
+   :param int versionMajor: major version
+   :param int versionMinor: minor version
+   :param str qmlName: name exposed to QML
+   :param str noCreationReason: Error message shown when trying to create the QML type
+   :return: int (the QML type id)
+
+This function registers the Python *type* in the QML system as an uncreatable
+type with the name *qmlName*, in the library imported from *uri* having the
+version number composed from *versionMajor* and *versionMinor*, showing
+*noCreationReason* as an error message when creating the type is attempted. For
+example, this registers a Python class 'MySliderItem' as a QML type named
+'Slider' for version '1.0' of a module called 'com.mycompany.qmlcomponents':
+
+   ::
+       qmlRegisterUncreatableType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider", "Slider cannot be created.")
+
+Note that it's perfectly reasonable for a library to register types to older
+versions than the actual version of the library. Indeed, it is normal for the
+new library to allow QML written to previous versions to continue to work, even
+if more advanced versions of some of its types are available.
+
+Alternatively, the :ref:`QmlUncreatable` decorator can be used.
+// @snippet qmlregisteruncreatabletype
+
+// @snippet qqmlengine-singletoninstance-qmltypeid
+Returns the instance of a singleton type that was registered under qmlTypeId.
+For ``QObject``-derived singleton types, the ``QObject`` instance is returned,
+otherwise a ``QJSValue`` or ``None``.
+
+It is recommended to store the QML type id, e.g. as a static member in the
+singleton class. The lookup via qmlTypeId() is costly.
+// @snippet qqmlengine-singletoninstance-qmltypeid
+
+// @snippet qqmlengine-singletoninstance-typename Returns the instance of a
+singleton type named typeName from the module specified by uri.
+For ``QObject``-derived singleton types, the ``QObject`` instance is returned,
+otherwise a ``QJSValue`` or ``None``.
+
+This method can be used as an alternative to calling qmlTypeId followed by the
+id based overload of singletonInstance. This is convenient when one only needs
+to do a one time setup of a singleton; if repeated access to the singleton is
+required, caching its typeId will allow faster subsequent access via the
+type-id based overload.
+// @snippet qqmlengine-singletoninstance-typename
diff --git a/sources/pyside6/PySide6/doc/qtquicktest.rst b/sources/pyside6/PySide6/doc/qtquicktest.rst
new file mode 100644
index 000000000..9df2af071
--- /dev/null
+++ b/sources/pyside6/PySide6/doc/qtquicktest.rst
@@ -0,0 +1,62 @@
+// @snippet quick_test_main_documentation
+
+Sets up the entry point for a Qt Quick Test application.
+The ``name`` argument uniquely identifies this set of tests.
+
+``sys.argv`` should be passed to the ``argv`` argument to ensure
+propagation of the command line arguments.
+
+.. note:: The function assumes that your test sources are in the current
+          directory, unless the ``QUICK_TEST_SOURCE_DIR`` environment
+          variable is set or a directory is passed in ``dir``.
+
+The following snippet demonstrates the use of this function:
+
+.. code-block:: Python
+
+    import sys
+    from PySide6.QtQuickTest import QUICK_TEST_MAIN
+
+    ex = QUICK_TEST_MAIN("example", sys.argv)
+    sys.exit(ex)
+
+
+// @snippet quick_test_main_documentation
+
+// @snippet quick_test_main_with_setup_documentation
+
+Sets up the entry point for a Qt Quick Test application.
+The ``name`` argument uniquely identifies this set of tests.
+
+``sys.argv`` should be passed to the ``argv`` argument to ensure
+propagation of the command line arguments.
+
+This function is identical to ``QUICK_TEST_MAIN()``, except that it takes an
+additional argument ``setup``, the type of a ``QObject``-derived
+class which will be instantiated. With this class, it is possible to define
+additional setup code to execute before running the QML test.
+
+The following snippet demonstrates the use of this function:
+
+.. code-block:: Python
+
+    import sys
+    from PySide6.QtQuickTest import QUICK_TEST_MAIN_WITH_SETUP
+
+    class CustomTestSetup(QObject):
+        def __init__(self, parent=None):
+            super().__init__(parent)
+
+        @Slot(QQmlEngine)
+        def qmlEngineAvailable(self, qmlEngine):
+            pass
+
+    ex = QUICK_TEST_MAIN_WITH_SETUP("qquicktestsetup", CustomTestSetup, sys.argv)
+    sys.exit(ex)
+
+
+.. note:: The function assumes that your test sources are in the current
+          directory, unless the ``QUICK_TEST_SOURCE_DIR`` environment
+          variable is set or a directory is passed in ``dir``.
+
+// @snippet quick_test_main_with_setup_documentation
diff --git a/sources/pyside6/PySide6/doc/qtuitools.rst b/sources/pyside6/PySide6/doc/qtuitools.rst
new file mode 100644
index 000000000..a8856f1af
--- /dev/null
+++ b/sources/pyside6/PySide6/doc/qtuitools.rst
@@ -0,0 +1,68 @@
+// @snippet quiloader-registercustomwidget
+Registers a Python created custom widget to QUiLoader, so it can be recognized
+when loading a `.ui` file. The custom widget type is passed via the
+``customWidgetType`` argument. This is needed when you want to override a
+virtual method of some widget in the interface, since duck punching will not
+work with widgets created by QUiLoader based on the contents of the `.ui` file.
+
+(Remember that
+`duck punching virtual methods is an invitation for your own demise! <https://doc.qt.io/qtforpython/shiboken6/wordsofadvice.html#duck-punching-and-virtual-methods>`_)
+
+Let's see an obvious example. If you want to create a new widget it's probable you'll end up
+overriding :class:`~PySide6.QtGui.QWidget`'s :meth:`~PySide6.QtGui.QWidget.paintEvent` method.
+
+.. code-block:: python
+
+   class Circle(QWidget):
+       def paintEvent(self, event):
+           with QPainter(self) as painter:
+               painter.setPen(self.pen)
+               painter.setBrush(QBrush(self.color))
+               painter.drawEllipse(event.rect().center(), 20, 20)
+
+   # ...
+
+   loader = QUiLoader()
+   loader.registerCustomWidget(Circle)
+   circle = loader.load('circle.ui')
+   circle.show()
+
+   # ...
+// @snippet quiloader-registercustomwidget
+
+// @snippet loaduitype
+.. currentmodule:: PySide6.QtUiTools
+
+loadUiType
+***********
+.. py:function:: loadUiType(uifile: str) -> tuple(object, object)
+
+   :param str uifile: The name of the `.ui` file
+   :return: tuple(object, object)
+
+This function generates and loads a `.ui` file at runtime, and it returns
+a `tuple` containing the reference to the Python class, and the base class.
+
+We recommend not to use this approach as the workflow should be to generate a Python file
+from the `.ui` file, and then import and load it to use it, but we do understand that
+there are some corner cases when such functionality is required.
+
+The internal process relies on `uic` being in the PATH.
+The `pyside6-uic` wrapper uses a shipped `uic` that is located in the
+`site-packages/PySide6/uic`, so PATH needs to be updated to use that if there
+is no `uic` in the system.
+
+A simple use case is::
+
+    from PySide6.QtUiTools import loadUiType
+
+    generated_class, base_class = loadUiType("themewidget.ui")
+    # the values will be:
+    #  (<class '__main__.Ui_ThemeWidgetForm'>, <class 'PySide6.QtWidgets.QWidget'>)
+
+    widget = base_class()
+    form = generated_class()
+    form.setupUi(widget)
+    # form.a_widget_member.a_method_of_member()
+    widget.show()
+// @snippet loaduitype
diff --git a/sources/pyside6/PySide6/glue/qtcore.cpp b/sources/pyside6/PySide6/glue/qtcore.cpp
index 0f4816bbb..0c206db72 100644
--- a/sources/pyside6/PySide6/glue/qtcore.cpp
+++ b/sources/pyside6/PySide6/glue/qtcore.cpp
@@ -11,6 +11,10 @@
 #include "glue/core_snippets_p.h"
 // @snippet include-pyside
 
+// @snippet core-snippets-p-h
+#include "glue/core_snippets_p.h"
+// @snippet core-snippets-p-h
+
 // @snippet qarg_helper
 
 // Helper for the Q_ARG/Q_RETURN_ARG functions, creating a meta type
@@ -56,6 +60,115 @@ QArgData qArgDataFromPyType(PyObject *t)
 }
 // @snippet qarg_helper
 
+// @snippet settings-value-helpers
+// Convert a QVariant to a desired primitive type
+static PyObject *convertToPrimitiveType(const QVariant &out, int metaTypeId)
+{
+    switch (metaTypeId) {
+    case QMetaType::QByteArray:
+        return PyBytes_FromString(out.toByteArray().constData());
+    case QMetaType::QString:
+        return PyUnicode_FromString(out.toByteArray().constData());
+    case QMetaType::Short:
+    case QMetaType::Long:
+    case QMetaType::LongLong:
+    case QMetaType::UShort:
+    case QMetaType::ULong:
+    case QMetaType::ULongLong:
+    case QMetaType::Int:
+    case QMetaType::UInt:
+        return PyLong_FromDouble(out.toFloat());
+    case QMetaType::Double:
+    case QMetaType::Float:
+    case QMetaType::Float16:
+        return PyFloat_FromDouble(out.toFloat());
+    case QMetaType::Bool:
+        if (out.toBool()) {
+            Py_RETURN_TRUE;
+        }
+        Py_RETURN_FALSE;
+    default:
+        break;
+    }
+    return nullptr;
+}
+
+// Helper for QSettings::value() to convert a value to the desired type
+static PyObject *settingsTypeCoercion(const QVariant &out, PyTypeObject *typeObj)
+{
+    if (typeObj == &PyList_Type) {
+        // Convert any string, etc, to a list of 1 element
+        if (auto *primitiveValue = convertToPrimitiveType(out, out.typeId())) {
+            PyObject *list = PyList_New(1);
+            PyList_SET_ITEM(list, 0, primitiveValue);
+            return list;
+        }
+
+        const QByteArray out_ba = out.toByteArray();
+        if (out_ba.isEmpty())
+            return PyList_New(0);
+
+        const QByteArrayList valuesList = out_ba.split(',');
+        const Py_ssize_t valuesSize = valuesList.size();
+        PyObject *list = PyList_New(valuesSize);
+        for (Py_ssize_t i = 0; i < valuesSize; ++i) {
+            PyObject *item = PyUnicode_FromString(valuesList.at(i).constData());
+            PyList_SET_ITEM(list, i, item);
+        }
+        return list;
+    }
+
+    if (typeObj == &PyBytes_Type)
+        return convertToPrimitiveType(out, QMetaType::QByteArray);
+    if (typeObj == &PyUnicode_Type)
+        return convertToPrimitiveType(out, QMetaType::QString);
+    if (typeObj == &PyLong_Type)
+        return convertToPrimitiveType(out, QMetaType::Int);
+    if (typeObj == &PyFloat_Type)
+        return convertToPrimitiveType(out, QMetaType::Double);
+    if (typeObj == &PyBool_Type)
+        return convertToPrimitiveType(out, QMetaType::Bool);
+
+    // TODO: PyDict_Type and PyTuple_Type
+    PyErr_SetString(PyExc_TypeError,
+                    "Invalid type parameter.\n"
+                    "\tUse 'list', 'bytes', 'str', 'int', 'float', 'bool', "
+                    "or a Qt-derived type");
+    return nullptr;
+}
+
+static bool isEquivalentSettingsType(PyTypeObject *typeObj, int metaTypeId)
+{
+    switch (metaTypeId) {
+    case QMetaType::QVariantList:
+    case QMetaType::QStringList:
+        return typeObj == &PyList_Type;
+    case QMetaType::QByteArray:
+        return typeObj == &PyBytes_Type;
+    case QMetaType::QString:
+        return typeObj == &PyUnicode_Type;
+    case QMetaType::Short:
+    case QMetaType::Long:
+    case QMetaType::LongLong:
+    case QMetaType::UShort:
+    case QMetaType::ULong:
+    case QMetaType::ULongLong:
+    case QMetaType::Int:
+    case QMetaType::UInt:
+        return typeObj == &PyLong_Type;
+    case QMetaType::Double:
+    case QMetaType::Float:
+    case QMetaType::Float16:
+        return typeObj == &PyFloat_Type;
+    case QMetaType::Bool:
+        return typeObj == &PyBool_Type;
+    default:
+        break;
+    }
+    return false;
+}
+// @snippet settings-value-helpers
+
 // @snippet qsettings-value
 // If we enter the kwds, means that we have a defaultValue or
 // at least a type.
@@ -76,61 +189,15 @@ if ((kwds && PyDict_Size(kwds) > 0) || numArgs > 1) {
 
 PyTypeObject *typeObj = reinterpret_cast<PyTypeObject*>(%PYARG_3);
 
-if (typeObj && !Shiboken::ObjectType::checkType(typeObj)) {
-    if (typeObj == &PyList_Type) {
-        QByteArray out_ba = out.toByteArray();
-        if (!out_ba.isEmpty()) {
-            QByteArrayList valuesList = out_ba.split(',');
-            const Py_ssize_t valuesSize = valuesList.size();
-            if (valuesSize > 0) {
-                PyObject *list = PyList_New(valuesSize);
-                for (Py_ssize_t i = 0; i < valuesSize; ++i) {
-                    PyObject *item = PyUnicode_FromString(valuesList.at(i).constData());
-                    PyList_SET_ITEM(list, i, item);
-                }
-                %PYARG_0 = list;
-
-            } else {
-                %PYARG_0 = %CONVERTTOPYTHON[QVariant](out);
-            }
-        } else {
-            %PYARG_0 = PyList_New(0);
-        }
-    } else if (typeObj == &PyBytes_Type) {
-        QByteArray asByteArray = out.toByteArray();
-        %PYARG_0 = PyBytes_FromString(asByteArray.constData());
-    } else if (typeObj == &PyUnicode_Type) {
-        QByteArray asByteArray = out.toByteArray();
-        %PYARG_0 = PyUnicode_FromString(asByteArray.constData());
-    } else if (typeObj == &PyLong_Type) {
-        float asFloat = out.toFloat();
-        pyResult = PyLong_FromDouble(asFloat);
-    } else if (typeObj == &PyFloat_Type) {
-        float asFloat = out.toFloat();
-        %PYARG_0 = PyFloat_FromDouble(asFloat);
-    } else if (typeObj == &PyBool_Type) {
-        if (out.toBool()) {
-            Py_INCREF(Py_True);
-            %PYARG_0 = Py_True;
-        } else {
-            Py_INCREF(Py_False);
-            %PYARG_0 = Py_False;
-        }
+if (typeObj && !Shiboken::ObjectType::checkType(typeObj)
+    && !isEquivalentSettingsType(typeObj, out.typeId())) {
+    %PYARG_0 = settingsTypeCoercion(out, typeObj);
+} else {
+    if (out.isValid()) {
+        %PYARG_0 = %CONVERTTOPYTHON[QVariant](out);
     } else {
-        // TODO: PyDict_Type and PyTuple_Type
-        PyErr_SetString(PyExc_TypeError,
-                        "Invalid type parameter.\n"
-                        "\tUse 'list', 'bytes', 'str', 'int', 'float', 'bool', "
-                        "or a Qt-derived type");
-        return nullptr;
-    }
-}
-else {
-    if (!out.isValid()) {
         Py_INCREF(Py_None);
         %PYARG_0 = Py_None;
-    } else {
-        %PYARG_0 = %CONVERTTOPYTHON[QVariant](out);
     }
 }
 
@@ -141,11 +208,7 @@ else {
 // @snippet metatype-from-type
 
 // @snippet metatype-from-metatype-type
-Shiboken::AutoDecRef intArg;
-if (usingNewEnum())
-    intArg.reset(PyObject_GetAttrString(%PYARG_1, "value"));
-else
-    intArg.reset(PyObject_CallMethod(%PYARG_1, "__int__", nullptr));
+Shiboken::AutoDecRef intArg(PyObject_GetAttrString(%PYARG_1, "value"));
 %0 = new %TYPE(PyLong_AsLong(intArg));
 // @snippet metatype-from-metatype-type
 
@@ -167,7 +230,7 @@ static QVariant QVariant_convertToVariantMap(PyObject *map)
     Py_ssize_t pos = 0;
     Shiboken::AutoDecRef keys(PyDict_Keys(map));
     if (!QVariant_isStringList(keys))
-        return QVariant();
+        return {};
     PyObject *key;
     PyObject *value;
     QMap<QString,QVariant> ret;
@@ -191,7 +254,7 @@ static QVariant QVariant_convertToVariantList(PyObject *list)
     if (PySequence_Size(list) < 0) {
         // clear the error if < 0 which means no length at all
         PyErr_Clear();
-        return QVariant();
+        return {};
     }
 
     QList<QVariant> lst;
@@ -204,6 +267,30 @@ static QVariant QVariant_convertToVariantList(PyObject *list)
     }
     return QVariant(lst);
 }
+
+using SpecificConverter = Shiboken::Conversions::SpecificConverter;
+
+static std::optional<SpecificConverter> converterForQtType(const char *typeNameC)
+{
+    // Fix typedef "QGenericMatrix<3,3,float>" -> QMatrix3x3". The reverse
+    // conversion happens automatically in QMetaType::fromName() in
+    // QVariant_resolveMetaType().
+    QByteArrayView typeNameV(typeNameC);
+    if (typeNameV.startsWith("QGenericMatrix<") && typeNameV.endsWith(",float>")) {
+        QByteArray typeName = typeNameV.toByteArray();
+        typeName.remove(1, 7);
+        typeName.remove(7, 1); // '<'
+        typeName.chop(7);
+        typeName.replace(',', 'x');
+        SpecificConverter matrixConverter(typeName.constData());
+        if (matrixConverter)
+            return matrixConverter;
+    }
+    SpecificConverter converter(typeNameC);
+    if (converter)
+        return converter;
+    return std::nullopt;
+}
 // @snippet qvariant-conversion
 
 // @snippet qt-qabs
@@ -219,6 +306,18 @@ PySide::addPostRoutine(%1);
 qAddPostRoutine(PySide::globalPostRoutineCallback);
 // @snippet qt-qaddpostroutine
 
+// @snippet qcompress-buffer
+auto *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1));
+QByteArray compressed = %FUNCTION_NAME(ptr, %2, %3);
+%PYARG_0 = %CONVERTTOPYTHON[QByteArray](compressed);
+// @snippet qcompress-buffer
+
+// @snippet quncompress-buffer
+auto *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1));
+QByteArray uncompressed = %FUNCTION_NAME(ptr, %2);
+%PYARG_0 = %CONVERTTOPYTHON[QByteArray](uncompressed);
+// @snippet quncompress-buffer
+
 // @snippet qt-version
 QList<QByteArray> version = QByteArray(qVersion()).split('.');
 PyObject *pyQtVersion = PyTuple_New(3);
@@ -256,6 +355,12 @@ PyModule_AddStringConstant(module, "__version__", qVersion());
 %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
 // @snippet qobject-connect-4
 
+// @snippet qobject-connect-4-context
+// %FUNCTION_NAME() - disable generation of function call.
+%RETURN_TYPE %0 = PySide::qobjectConnectCallback(%1, %2, %3, %PYARG_4, %5);
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+// @snippet qobject-connect-4-context
+
 // @snippet qobject-connect-5
 // %FUNCTION_NAME() - disable generation of function call.
 %RETURN_TYPE %0 = PySide::qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3);
@@ -312,10 +417,10 @@ PySide::Feature::init();
 // @snippet qt-init-feature
 
 // @snippet qt-pysideinit
-Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], "unicode");
-Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], "str");
-Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QTCORE_QLIST_QVARIANT_IDX], "QVariantList");
-Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QTCORE_QMAP_QSTRING_QVARIANT_IDX], "QVariantMap");
+Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], "unicode");
+Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], "str");
+Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QtCore_QList_QVariant_IDX], "QVariantList");
+Shiboken::Conversions::registerConverterName(SbkPySide6_QtCoreTypeConverters[SBK_QtCore_QMap_QString_QVariant_IDX], "QVariantMap");
 
 PySide::registerInternalQtConf();
 PySide::init(module);
@@ -365,8 +470,7 @@ if (%PYARG_0 == Py_None)
 namespace PySide {
     template<> inline Py_ssize_t hash(const QLine &l)
     {
-        const int v[4] = {l.x1(), l.y1(), l.x2(), l.y2()};
-        return qHashRange(v, v + 4);
+        return qHashMulti(0, l.x1(), l.y1(), l.x2(), l.y2());
     }
 };
 // @snippet qline-hash
@@ -438,31 +542,6 @@ if (!PyDateTimeAPI)
 %PYARG_0 = PyDateTime_FromDateAndTime(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec()*1000);
 // @snippet qdatetime-topython
 
-// @snippet qpoint
-namespace PySide {
-    template<> inline Py_ssize_t hash(const QPoint &v) {
-        return qHash(qMakePair(v.x(), v.y()));
-    }
-};
-// @snippet qpoint
-
-// @snippet qrect
-namespace PySide {
-    template<> inline Py_ssize_t hash(const QRect &r) {
-        const int v[4] = {r.x(), r.y(), r.width(), r.height()};
-        return qHashRange(v, v + 4);
-    }
-};
-// @snippet qrect
-
-// @snippet qsize
-namespace PySide {
-    template<> inline Py_ssize_t hash(const QSize &v) {
-        return qHash(qMakePair(v.width(), v.height()));
-    }
-};
-// @snippet qsize
-
 // @snippet qtime-topython
 if (!PyDateTimeAPI)
     PyDateTime_IMPORT;
@@ -536,32 +615,31 @@ const QString result = qObjectTr(reinterpret_cast<PyTypeObject *>(%PYSELF), %1,
 %PYARG_0 = %CONVERTTOPYTHON[QString](result);
 // @snippet qobject-tr
 
-// @snippet qobject-receivers
-// Avoid return +1 because SignalManager connect to "destroyed()" signal to control object timelife
-int ret = %CPPSELF.%FUNCTION_NAME(%1);
-if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0)))
-    ret -= PySide::SignalManager::instance().countConnectionsWith(%CPPSELF);
-
-%PYARG_0 = %CONVERTTOPYTHON[int](ret);
-// @snippet qobject-receivers
+// @snippet qobject-sender
+// Retrieve the sender from a dynamic property set by GlobalReceiverV2 in case of a
+// non-C++ slot (Python callback).
+auto *ret = %CPPSELF.%FUNCTION_NAME();
+if (ret == nullptr) {
+    auto senderV = %CPPSELF.property("_q_pyside_sender");
+    if (senderV.typeId() == QMetaType::QObjectStar)
+        ret = senderV.value<QObject *>();
+}
+%PYARG_0 = %CONVERTTOPYTHON[QObject*](ret);
+// @snippet qobject-sender
 
 // @snippet qbytearray-mgetitem
-if (PepIndex_Check(_key)) {
+if (PyIndex_Check(_key)) {
     const Py_ssize_t _i = PyNumber_AsSsize_t(_key, PyExc_IndexError);
-    if (_i < 0 || _i >= %CPPSELF.size()) {
-        PyErr_SetString(PyExc_IndexError, "index out of bounds");
-        return nullptr;
-    }
+    if (_i < 0 || _i >= %CPPSELF.size())
+        return PyErr_Format(PyExc_IndexError, "index out of bounds");
     char res[2] = {%CPPSELF.at(_i), '\0'};
     return PyBytes_FromStringAndSize(res, 1);
 }
 
-if (PySlice_Check(_key) == 0) {
-    PyErr_Format(PyExc_TypeError,
+if (PySlice_Check(_key) == 0)
+    return PyErr_Format(PyExc_TypeError,
                  "list indices must be integers or slices, not %.200s",
                  Py_TYPE(_key)->tp_name);
-    return nullptr;
-}
 
 Py_ssize_t start, stop, step, slicelength;
 if (PySlice_GetIndicesEx(_key, %CPPSELF.size(), &start, &stop, &step, &slicelength) < 0)
@@ -587,7 +665,8 @@ return %CONVERTTOPYTHON[QByteArray](ba);
 // @snippet qbytearray-mgetitem
 
 // @snippet qbytearray-msetitem
-if (PepIndex_Check(_key)) {
+// PYSIDE-2404: Usage of the `get()` function not necessary, the type exists.
+if (PyIndex_Check(_key)) {
     Py_ssize_t _i = PyNumber_AsSsize_t(_key, PyExc_IndexError);
     if (_i == -1 && PyErr_Occurred())
         return -1;
@@ -611,7 +690,8 @@ if (PepIndex_Check(_key)) {
             PyErr_SetString(PyExc_ValueError, "bytearray must be of size 1");
             return -1;
         }
-    } else if (Py_TYPE(_value) == reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX])) {
+    } else if (Py_TYPE(_value) == reinterpret_cast<PyTypeObject *>(
+            SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX].type)) {
         if (PyObject_Length(_value) != 1) {
             PyErr_SetString(PyExc_ValueError, "QByteArray must be of size 1");
             return -1;
@@ -648,7 +728,7 @@ if (PySlice_GetIndicesEx(_key, %CPPSELF.size(), &start, &stop, &step, &sliceleng
 Py_ssize_t value_length = 0;
 if (_value != nullptr && _value != Py_None) {
     if (!(PyBytes_Check(_value) || PyByteArray_Check(_value)
-          || Py_TYPE(_value) == reinterpret_cast<PyTypeObject *>(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX]))) {
+          || Py_TYPE(_value) == SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX].type)) {
            PyErr_Format(PyExc_TypeError, "bytes, bytearray or QByteArray is required, not %.200s",
                         Py_TYPE(_value)->tp_name);
            return -1;
@@ -705,10 +785,10 @@ static int SbkQByteArray_getbufferproc(PyObject *obj, Py_buffer *view, int flags
     view->len = cppSelf->size();
     view->readonly = 0;
     view->itemsize = 1;
-    view->format = const_cast<char *>("c");
+    view->format = (flags & PyBUF_FORMAT) == PyBUF_FORMAT ? const_cast<char *>("B") : nullptr;
     view->ndim = 1;
     view->shape = (flags & PyBUF_ND) == PyBUF_ND ? &(view->len) : nullptr;
-    view->strides = &view->itemsize;
+    view->strides = (flags & PyBUF_STRIDES) == PyBUF_STRIDES ? &(view->itemsize) : nullptr;
     view->suboffsets = nullptr;
     view->internal = nullptr;
 
@@ -874,6 +954,13 @@ uchar *ptr = reinterpret_cast<uchar *>(Shiboken::Buffer::getPointer(%PYARG_1));
 %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1, %2, %3), %2, Shiboken::Buffer::ReadWrite);
 // @snippet qfiledevice-map
 
+// @snippet qiodevice-bufferedread
+Py_ssize_t bufferLen;
+auto *data = reinterpret_cast<char*>(Shiboken::Buffer::getPointer(%PYARG_1, &bufferLen));
+%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(data, PyLong_AsLongLong(%PYARG_2));
+return PyLong_FromLong(%0);
+// @snippet qiodevice-bufferedread
+
 // @snippet qiodevice-readdata
 QByteArray ba(1 + qsizetype(%2), char(0));
 %CPPSELF.%FUNCTION_NAME(ba.data(), qint64(%2));
@@ -921,62 +1008,126 @@ auto *ptr = reinterpret_cast<uchar *>(Shiboken::Buffer::getPointer(%PYARG_1, &si
 %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
 // @snippet qtranslator-load
 
-// @snippet qtimer-singleshot-1
-// %FUNCTION_NAME() - disable generation of c++ function call
-(void) %2; // remove warning about unused variable
-Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
-auto *timerType = Shiboken::SbkType<QTimer>();
-auto *pyTimer = timerType->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, nullptr);
-timerType->tp_init(pyTimer, emptyTuple, nullptr);
-
-auto timer = %CONVERTTOCPP[QTimer *](pyTimer);
-Shiboken::AutoDecRef result(
-    PyObject_CallMethod(pyTimer, "connect", "OsOs",
-                        pyTimer,
-                        SIGNAL(timeout()),
-                        %PYARG_2,
-                        %3)
-);
-Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(pyTimer));
-Py_XDECREF(pyTimer);
-timer->setSingleShot(true);
-timer->connect(timer, &QTimer::timeout, timer, &QObject::deleteLater);
-timer->start(%1);
-// @snippet qtimer-singleshot-1
-
-// @snippet qtimer-singleshot-2
-// %FUNCTION_NAME() - disable generation of c++ function call
+// @snippet qtimer-singleshot-functorclass
+struct QSingleShotTimerFunctor : public Shiboken::PyObjectHolder
+{
+public:
+    using Shiboken::PyObjectHolder::PyObjectHolder;
+
+    void operator()();
+};
+
+void QSingleShotTimerFunctor::operator()()
+{
+    Shiboken::GilState state;
+    Shiboken::AutoDecRef arglist(PyTuple_New(0));
+    Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
+    if (Shiboken::Errors::occurred())
+        Shiboken::Errors::storeErrorOrPrint();
+    release(); // single shot
+}
+// @snippet qtimer-singleshot-functorclass
+
+// @snippet qtimer-singleshot-direct-mapping
 Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
-auto *timerType = Shiboken::SbkType<QTimer>();
-auto *pyTimer = timerType->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, nullptr);
-timerType->tp_init(pyTimer, emptyTuple, nullptr);
-QTimer * timer = %CONVERTTOCPP[QTimer *](pyTimer);
-timer->setSingleShot(true);
-
-if (PyObject_TypeCheck(%2, PySideSignalInstance_TypeF())) {
-    PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance *>(%2);
-    Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
-    Shiboken::AutoDecRef result(
-        PyObject_CallMethod(pyTimer, "connect", "OsOO",
-                            pyTimer,
-                            SIGNAL(timeout()),
-                            PySide::Signal::getObject(signalInstance),
-                            signalSignature.object())
-    );
+%CPPSELF.%FUNCTION_NAME(%1, %2, %3);
+// @snippet qtimer-singleshot-direct-mapping
+
+// @snippet qtimer-singleshot-functor
+auto msec = %1;
+if (msec == 0) {
+    if (PyObject_TypeCheck(%2, PySideSignalInstance_TypeF())) {
+        auto *signal = %PYARG_2;
+        auto cppCallback = [signal]()
+        {
+            Shiboken::GilState state;
+            Shiboken::AutoDecRef ret(PyObject_CallMethod(signal, "emit", "()"));
+            Py_DECREF(signal);
+        };
+
+        Py_INCREF(signal);
+        %CPPSELF.%FUNCTION_NAME(msec, cppCallback);
+    } else {
+        %CPPSELF.%FUNCTION_NAME(msec, QSingleShotTimerFunctor(%PYARG_2));
+    }
+} else {
+    // %FUNCTION_NAME() - disable generation of c++ function call
+    Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
+    auto *timerType = Shiboken::SbkType<QTimer>();
+    auto newFunc = reinterpret_cast<newfunc>(PepType_GetSlot(timerType, Py_tp_new));
+    auto initFunc = reinterpret_cast<initproc>(PepType_GetSlot(timerType, Py_tp_init));
+    auto *pyTimer = newFunc(Shiboken::SbkType<QTimer>(), emptyTuple, nullptr);
+    initFunc(pyTimer, emptyTuple, nullptr);
+
+    QTimer * timer = %CONVERTTOCPP[QTimer *](pyTimer);
+    timer->setSingleShot(true);
+
+    if (PyObject_TypeCheck(%2, PySideSignalInstance_TypeF())) {
+        PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance *>(%2);
+        Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
+        Shiboken::AutoDecRef result(
+            PyObject_CallMethod(pyTimer, "connect", "OsOO",
+                                pyTimer,
+                                SIGNAL(timeout()),
+                                PySide::Signal::getObject(signalInstance),
+                                signalSignature.object())
+        );
+    } else {
+        Shiboken::AutoDecRef result(
+            PyObject_CallMethod(pyTimer, "connect", "OsO",
+                                pyTimer,
+                                SIGNAL(timeout()),
+                                %PYARG_2)
+        );
+    }
+
+    timer->connect(timer, &QTimer::timeout, timer, &QObject::deleteLater, Qt::DirectConnection);
+    Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(pyTimer));
+    Py_XDECREF(pyTimer);
+    timer->start(msec);
+}
+// @snippet qtimer-singleshot-functor
+
+// @snippet qtimer-singleshot-functor-context
+auto msec = %1;
+if (msec == 0) {
+    Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
+    auto *callable = %PYARG_3;
+    auto cppCallback = [callable]()
+    {
+        Shiboken::GilState state;
+        Shiboken::AutoDecRef arglist(PyTuple_New(0));
+        Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
+        Py_DECREF(callable);
+    };
+
+    Py_INCREF(callable);
+    %CPPSELF.%FUNCTION_NAME(msec, %2, cppCallback);
 } else {
+    Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
+    auto *timerType = Shiboken::SbkType<QTimer>();
+    auto newFunc = reinterpret_cast<newfunc>(PepType_GetSlot(timerType, Py_tp_new));
+    auto initFunc = reinterpret_cast<initproc>(PepType_GetSlot(timerType, Py_tp_init));
+    auto *pyTimer = newFunc(Shiboken::SbkType<QTimer>(), emptyTuple, nullptr);
+    initFunc(pyTimer, emptyTuple, nullptr);
+
+    QTimer * timer = %CONVERTTOCPP[QTimer *](pyTimer);
+    timer->setSingleShot(true);
+
     Shiboken::AutoDecRef result(
-        PyObject_CallMethod(pyTimer, "connect", "OsO",
+        PyObject_CallMethod(pyTimer, "connect", "OsOO",
                             pyTimer,
                             SIGNAL(timeout()),
-                            %PYARG_2)
+                            %PYARG_2,
+                            %PYARG_3)
     );
-}
 
-timer->connect(timer, &QTimer::timeout, timer, &QObject::deleteLater, Qt::DirectConnection);
-Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(pyTimer));
-Py_XDECREF(pyTimer);
-timer->start(%1);
-// @snippet qtimer-singleshot-2
+    timer->connect(timer, &QTimer::timeout, timer, &QObject::deleteLater, Qt::DirectConnection);
+    Shiboken::Object::releaseOwnership(reinterpret_cast<SbkObject *>(pyTimer));
+    Py_XDECREF(pyTimer);
+    timer->start(msec);
+}
+// @snippet qtimer-singleshot-functor-context
 
 // @snippet qprocess-startdetached
 qint64 pid;
@@ -1042,6 +1193,16 @@ if (result == -1) {
 }
 // @snippet qdatastream-readrawdata
 
+// @snippet qdatastream-writerawdata-pybuffer
+int r = 0;
+Py_ssize_t bufferLen;
+auto *data = reinterpret_cast<const char*>(Shiboken::Buffer::getPointer(%PYARG_1, &bufferLen));
+Py_BEGIN_ALLOW_THREADS
+r = %CPPSELF.%FUNCTION_NAME(data, bufferLen);
+Py_END_ALLOW_THREADS
+%PYARG_0 = %CONVERTTOPYTHON[int](r);
+// @snippet qdatastream-writerawdata-pybuffer
+
 // @snippet qdatastream-writerawdata
 int r = 0;
 Py_BEGIN_ALLOW_THREADS
@@ -1180,7 +1341,7 @@ Py_END_ALLOW_THREADS
     if (atexit.isNull()) {
         qWarning("Module atexit not found for registering __moduleShutdown");
         PyErr_Clear();
-    }else{
+    } else {
         regFunc.reset(PyObject_GetAttrString(atexit, "register"));
         if (regFunc.isNull()) {
             qWarning("Function atexit.register not found for registering __moduleShutdown");
@@ -1318,7 +1479,7 @@ auto res = (*%CPPSELF) + cppArg0;
 
 // @snippet conversion-pystring-char
 char c = %CONVERTTOCPP[char](%in);
-%out = %OUTTYPE(c);
+%out = %OUTTYPE(static_cast<unsigned short>(c));
 // @snippet conversion-pystring-char
 
 // @snippet conversion-pyint
@@ -1352,15 +1513,23 @@ double in = %CONVERTTOCPP[double](%in);
 // @snippet conversion-sbkobject
 // a class supported by QVariant?
 const QMetaType metaType = QVariant_resolveMetaType(Py_TYPE(%in));
+bool ok = false;
 if (metaType.isValid()) {
     QVariant var(metaType);
-    Shiboken::Conversions::SpecificConverter converter(metaType.name());
-    converter.toCpp(pyIn, var.data());
-    %out = var;
-} else {
-    // If the type was not encountered, return a default PyObjectWrapper
-    %out = QVariant::fromValue(PySide::PyObjectWrapper(%in));
+    auto converterO = converterForQtType(metaType.name());
+    ok = converterO.has_value();
+    if (ok) {
+        converterO.value().toCpp(pyIn, var.data());
+        %out = var;
+    } else {
+        qWarning("%s: Cannot find a converter for \"%s\".",
+                 __FUNCTION__, metaType.name());
+    }
 }
+
+// If the type was not encountered, return a default PyObjectWrapper
+if (!ok)
+    %out = QVariant::fromValue(PySide::PyObjectWrapper(%in));
 // @snippet conversion-sbkobject
 
 // @snippet conversion-pydict
@@ -1446,10 +1615,40 @@ return PyLong_FromUnsignedLong(%in);
 #endif
 // @snippet return-pylong-quintptr
 
+// @snippet return-qfunctionpointer-pylong
+return PyLong_FromVoidPtr(reinterpret_cast<void *>(%in));
+// @snippet return-qfunctionpointer-pylong
+
+// @snippet conversion-pylong-qfunctionpointer
+%out = reinterpret_cast<QFunctionPointer>(PyLong_AsVoidPtr(%in));
+// @snippet conversion-pylong-qfunctionpointer
+
 // @snippet return-pyunicode
 return PySide::qStringToPyUnicode(%in);
 // @snippet return-pyunicode
 
+// @snippet return-pyunicode-from-qlatin1string
+#ifdef Py_LIMITED_API
+return PySide::qStringToPyUnicode(QString::fromLatin1(%in));
+#else
+return PyUnicode_FromKindAndData(PyUnicode_1BYTE_KIND, %in.constData(), %in.size());
+#endif
+// @snippet return-pyunicode-from-qlatin1string
+
+// @snippet qlatin1string-check
+static bool qLatin1StringCheck(PyObject *o)
+{
+    return PyUnicode_CheckExact(o) != 0
+        && _PepUnicode_KIND(o) == PepUnicode_1BYTE_KIND;
+}
+// @snippet qlatin1string-check
+
+// @snippet conversion-pystring-qlatin1string
+const char *data = reinterpret_cast<const char *>(_PepUnicode_DATA(%in));
+const Py_ssize_t len = PyUnicode_GetLength(%in);
+%out = QLatin1String(data, len);
+// @snippet conversion-pystring-qlatin1string
+
 // @snippet return-pyunicode-from-qanystringview
 return PySide::qStringToPyUnicode(%in.toString());
 // @snippet return-pyunicode-from-qanystringview
@@ -1488,11 +1687,10 @@ default:
     break;
 }
 
-Shiboken::Conversions::SpecificConverter converter(cppInRef.typeName());
-if (converter) {
-   void *ptr = cppInRef.data();
-   return converter.toPython(ptr);
-}
+auto converterO = converterForQtType(cppInRef.typeName());
+if (converterO.has_value())
+    return converterO.value().toPython(cppInRef.data());
+
 PyErr_Format(PyExc_RuntimeError, "Can't find converter for '%s'.", %in.typeName());
 return 0;
 // @snippet return-qvariant
@@ -1509,7 +1707,6 @@ return %CONVERTTOPYTHON[QVariant](ret);
 
 // @snippet qthread_pthread_cleanup
 #ifdef Q_OS_UNIX
-#  include <stdio.h>
 #  include <pthread.h>
 static void qthread_pthread_cleanup(void *arg)
 {
@@ -1536,13 +1733,17 @@ pthread_cleanup_pop(0);
 // @snippet qthread_pthread_cleanup_uninstall
 
 // @snippet qlibraryinfo_build
-#if defined(Py_LIMITED_API)
-auto suffix = PyUnicode_FromString(" [limited API]");
 auto oldResult = pyResult;
-pyResult = PyUnicode_Concat(pyResult, suffix);
-Py_DECREF(oldResult);
-Py_DECREF(suffix);
+const auto version = _PepRuntimeVersion();
+pyResult = PyUnicode_FromFormat(
+#ifdef Py_LIMITED_API
+                                "%U [Python limited API %d.%d.%d]",
+#else
+                                "%U [Python %d.%d.%d]",
 #endif
+                                oldResult, (version >> 16) & 0xFF,
+                                (version >> 8) & 0xFF, version & 0xFF);
+Py_DECREF(oldResult);
 // @snippet qlibraryinfo_build
 
 // @snippet qsharedmemory_data_readonly
@@ -1603,8 +1804,9 @@ if (dataChar == nullptr) {
 // @snippet qdatastream-read-bytes
 
 // @snippet qloggingcategory_to_cpp
+// PYSIDE-2404: Usage of the `get()` function not necessary, the type exists.
     QLoggingCategory *category{nullptr};
-    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtCoreTypes[SBK_QLOGGINGCATEGORY_IDX],
+    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtCoreTypeStructs[SBK_QLoggingCategory_IDX].type,
     pyArgs[0], &(category));
 // @snippet qloggingcategory_to_cpp
 
@@ -1654,90 +1856,114 @@ QtCoreHelper::QGenericReturnArgumentHolder result(qArgData.metaType, qArgData.da
 %PYARG_0 = %CONVERTTOPYTHON[QtCoreHelper::QGenericReturnArgumentHolder](result);
 // @snippet q_return_arg
 
-// invokeMethod(QObject *,const char *, QGenericArgument a0, a1, a2 )
-// @snippet qmetaobject-invokemethod-arg
-PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
-const bool result = %CPPSELF.invokeMethod(%1, %2, %3, %4, %5);
-PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
-%PYARG_0 = %CONVERTTOPYTHON[bool](result);
-// @snippet qmetaobject-invokemethod-arg
+// @snippet qmetamethod-invoke-helpers
+static InvokeMetaMethodFunc
+    createInvokeMetaMethodFunc(const QMetaMethod &method, QObject *object,
+                               Qt::ConnectionType type = Qt::AutoConnection)
+{
+    return [&method, object, type](QGenericArgument a0, QGenericArgument a1,
+                                   QGenericArgument a2, QGenericArgument a3,
+                                   QGenericArgument a4, QGenericArgument a5,
+                                   QGenericArgument a6, QGenericArgument a7,
+                                   QGenericArgument a8, QGenericArgument a9) -> bool
+    {
+        return method.invoke(object, type, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
+}
 
-// invokeMethod(QObject *,const char *,Qt::ConnectionType, QGenericArgument a0, a1, a2 )
-// @snippet qmetaobject-invokemethod-conn-type-arg
-PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
-const bool result = %CPPSELF.invokeMethod(%1, %2, %3, %4, %5, %6);
-PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
-%PYARG_0 = %CONVERTTOPYTHON[bool](result);
-// @snippet qmetaobject-invokemethod-conn-type-arg
+static InvokeMetaMethodFuncWithReturn
+    createInvokeMetaMethodFuncWithReturn(const QMetaMethod &method, QObject *object,
+                                         Qt::ConnectionType type = Qt::AutoConnection)
+{
+    return [&method, object, type](QGenericReturnArgument r,
+                                   QGenericArgument a0, QGenericArgument a1,
+                                   QGenericArgument a2, QGenericArgument a3,
+                                   QGenericArgument a4, QGenericArgument a5,
+                                   QGenericArgument a6, QGenericArgument a7,
+                                   QGenericArgument a8, QGenericArgument a9) -> bool
+    {
+        return method.invoke(object, type, r, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
+}
+// @snippet qmetamethod-invoke-helpers
 
-// @snippet qmetaobject-invokemethod-helpers
-static PyObject *invokeMethodHelper(QObject *obj, const char *member, Qt::ConnectionType type,
-                                    const QtCoreHelper::QGenericReturnArgumentHolder &returnArg,
-                                    const QtCoreHelper::QGenericArgumentHolder &v1,
-                                    const QtCoreHelper::QGenericArgumentHolder &v2,
-                                    const QtCoreHelper::QGenericArgumentHolder &v3)
+// @snippet qmetamethod-invoke-conn-type-return-arg
+%PYARG_0 = invokeMetaMethodWithReturn(createInvokeMetaMethodFuncWithReturn(*%CPPSELF, %1, %2),
+                                      %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13);
+// @snippet qmetamethod-invoke-conn-type-return-arg
 
+// @snippet qmetamethod-invoke-return-arg
+%PYARG_0 = invokeMetaMethodWithReturn(createInvokeMetaMethodFuncWithReturn(*%CPPSELF, %1),
+                                      %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12);
+// @snippet qmetamethod-invoke-return-arg
+
+// @snippet qmetamethod-invoke-conn-type
+%PYARG_0 = invokeMetaMethod(createInvokeMetaMethodFunc(*%CPPSELF, %1, %2),
+                            %3, %4, %5, %6, %7, %8, %9, %10, %11, %12);
+// @snippet qmetamethod-invoke-conn-type
+
+// @snippet qmetamethod-invoke
+%PYARG_0 = invokeMetaMethod(createInvokeMetaMethodFunc(*%CPPSELF, %1),
+                            %2, %3, %4, %5, %6, %7, %8, %9, %10, %11);
+// @snippet qmetamethod-invoke
+
+// @snippet qmetaobject-invokemethod-helpers
+static InvokeMetaMethodFunc
+    createInvokeMetaMethodFunc(QObject *object, const char *methodName,
+                               Qt::ConnectionType type = Qt::AutoConnection)
 {
-    PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
-    const bool callResult = QMetaObject::invokeMethod(obj, member, type,
-                                                      returnArg, v1, v2, v3);
-    PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
-    if (!callResult) {
-        PyErr_Format(PyExc_RuntimeError, "QMetaObject::invokeMethod(): Invocation of %s::%s() failed.",
-                     obj->metaObject()->className(), member);
-        return nullptr;
-    }
+    return [object, methodName, type](QGenericArgument a0, QGenericArgument a1,
+                                      QGenericArgument a2, QGenericArgument a3,
+                                      QGenericArgument a4, QGenericArgument a5,
+                                      QGenericArgument a6, QGenericArgument a7,
+                                      QGenericArgument a8, QGenericArgument a9) -> bool
+    {
+        return QMetaObject::invokeMethod(object, methodName, type,
+                                         a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
+}
 
-    PyObject *result = nullptr;
-    const void *retData = returnArg.data();
-    const QMetaType metaType = returnArg.metaType();
-    switch (metaType.id()) {
-    case QMetaType::Bool:
-        result = *reinterpret_cast<const bool *>(retData) ? Py_True : Py_False;
-        Py_INCREF(result);
-        break;
-    case QMetaType::Int:
-        result = PyLong_FromLong(*reinterpret_cast<const int *>(retData));
-        break;
-    case QMetaType::Double:
-        result = PyFloat_FromDouble(*reinterpret_cast<const double *>(retData));
-        break;
-    case QMetaType::QString:
-        result = PySide::qStringToPyUnicode(*reinterpret_cast<const QString *>(retData));
-        break;
-    default: {
-        Shiboken::Conversions::SpecificConverter converter(metaType.name());
-        const auto type = converter.conversionType();
-        if (type == Shiboken::Conversions::SpecificConverter::InvalidConversion) {
-            PyErr_Format(PyExc_RuntimeError, "%s: Unable to find converter for \"%s\".",
-                         __FUNCTION__, metaType.name());
-            return nullptr;
-        }
-        result = converter.toPython(retData);
-    }
-    }
-    return result;
+static InvokeMetaMethodFuncWithReturn
+    createInvokeMetaMethodFuncWithReturn(QObject *object, const char *methodName,
+                                         Qt::ConnectionType type = Qt::AutoConnection)
+{
+    return [object, methodName, type](QGenericReturnArgument r,
+                                      QGenericArgument a0, QGenericArgument a1,
+                                      QGenericArgument a2, QGenericArgument a3,
+                                      QGenericArgument a4, QGenericArgument a5,
+                                      QGenericArgument a6, QGenericArgument a7,
+                                      QGenericArgument a8, QGenericArgument a9) -> bool
+    {
+        return QMetaObject::invokeMethod(object, methodName, type,
+                                         r, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
 }
 // @snippet qmetaobject-invokemethod-helpers
 
+// invokeMethod(QObject *,const char *, QGenericArgument a0, a1, a2 )
+// @snippet qmetaobject-invokemethod-arg
+%PYARG_0 = invokeMetaMethod(createInvokeMetaMethodFunc(%1, %2),
+                            %3, %4, %5, %6, %7, %8, %9, %10, %11, %12);
+// @snippet qmetaobject-invokemethod-arg
+
+// invokeMethod(QObject *,const char *,Qt::ConnectionType, QGenericArgument a0, a1, a2 )
+// @snippet qmetaobject-invokemethod-conn-type-arg
+%PYARG_0 = invokeMetaMethod(createInvokeMetaMethodFunc(%1, %2, %3),
+                             %4, %5, %6, %7, %8, %9, %10, %11, %12, %13);
+// @snippet qmetaobject-invokemethod-conn-type-arg
+
 // invokeMethod(QObject *,const char *, Qt::ConnectionType, QGenericReturnArgument,QGenericArgument a0, a1, a2 )
 // @snippet qmetaobject-invokemethod-conn-type-return-arg
-%PYARG_0 = invokeMethodHelper(%1, %2, %3, %4, %5, %6, %7);
+%PYARG_0 = invokeMetaMethodWithReturn(createInvokeMetaMethodFuncWithReturn(%1, %2, %3),
+                                      %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14);
 // @snippet qmetaobject-invokemethod-conn-type-return-arg
 
 // invokeMethod(QObject *,const char *, QGenericReturnArgument,QGenericArgument a0, a1, a2 )
 // @snippet qmetaobject-invokemethod-return-arg
-%PYARG_0 = invokeMethodHelper(%1, %2, Qt::AutoConnection, %3, %4, %5, %6);
+%PYARG_0 = invokeMetaMethodWithReturn(createInvokeMetaMethodFuncWithReturn(%1, %2),
+                                      %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13);
 // @snippet qmetaobject-invokemethod-return-arg
 
-// @snippet qabstractitemmodel_data
-::QVariant %0;
-if (Shiboken::Enum::check(%PYARG_0))
-    %0 = QVariant(int(Shiboken::Enum::getValue(%PYARG_0)));
-else
-    pythonToCpp(pyResult, &cppResult);
-// @snippet qabstractitemmodel_data
-
 // @snippet keycombination-from-keycombination
 cptr = new ::%TYPE(%1);
 // @snippet keycombination-from-keycombination
@@ -1745,3 +1971,180 @@ cptr = new ::%TYPE(%1);
 // @snippet keycombination-from-modifier
 cptr = new ::%TYPE(%1, %2);
 // @snippet keycombination-from-modifier
+
+// @snippet qmetamethod-from-signal
+auto *signalInst = reinterpret_cast<PySideSignalInstance *>(%PYARG_1);
+const auto data = PySide::Signal::getEmitterData(signalInst);
+const auto result = data.methodIndex != -1
+    ? data.emitter->metaObject()->method(data.methodIndex)
+    : QMetaMethod{};
+%PYARG_0 = %CONVERTTOPYTHON[QMetaMethod](result);
+// @snippet qmetamethod-from-signal
+
+// @snippet qrunnable_create
+auto callable = %PYARG_1;
+auto callback = [callable]() -> void
+{
+    if (!PyCallable_Check(callable)) {
+        qWarning("Argument 1 of %FUNCTION_NAME must be a callable.");
+        return;
+    }
+    Shiboken::GilState state;
+    Shiboken::AutoDecRef ret(PyObject_CallObject(callable, nullptr));
+    Py_DECREF(callable);
+};
+Py_INCREF(callable);
+%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(callback);
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+// @snippet qrunnable_create
+
+// @snippet qlocale_system
+// For darwin systems, QLocale::system() involves looking at the Info.plist of the application
+// bundle to detect the system localization. In the case of Qt for Python, the application bundle
+// is the used Python framework. To enable retreival of localized string, the property list key
+// CFBunldeAllowMixedLocalizations should be set to True inside the Info.plist file. Otherwise,
+// CFBundleDevelopmentRegion will be used to find the language preference of the user, which in the
+// case of Python is always english.
+// This is a hack until CFBunldeAllowMixedLocalizations will be set in the Python framework
+// installation in darwin systems.
+// Upstream issue in CPython: https://github.com/python/cpython/issues/108269
+#ifdef Q_OS_DARWIN
+    Shiboken::AutoDecRef locale(PyImport_ImportModule("locale"));
+    Shiboken::AutoDecRef getLocale(PyObject_GetAttrString(locale, "getlocale"));
+    Shiboken::AutoDecRef systemLocale(PyObject_CallObject(getLocale, nullptr));
+    PyObject* localeCode = PyTuple_GetItem(systemLocale, 0);
+    %RETURN_TYPE %0;
+    if (localeCode != Py_None) {
+        QString localeCodeStr = PySide::pyStringToQString(localeCode);
+        %0 = QLocale(localeCodeStr);
+    } else {
+       // The default locale is 'C' locale as mentioned in
+       // https://docs.python.org/3/library/locale.html
+        %0 = ::QLocale::c();
+    }
+#else
+    %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME();
+#endif
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+// @snippet qlocale_system
+
+// @snippet qcoreapplication-requestpermission
+auto permission = %1;
+auto callable = %PYARG_3;
+
+// check if callable
+if (!PyCallable_Check(callable)) {
+    qWarning("Functor of %FUNCTION_NAME is not a callable");
+    return {};
+}
+
+// find the number of arguments of callable. It should either be empy or accept a QPermission
+// object
+int count = 0;
+PyObject* fc = nullptr;
+bool classMethod = false;
+Shiboken::AutoDecRef func_ob(PyObject_GetAttr(callable, Shiboken::PyMagicName::func()));
+
+if (func_ob.isNull() && PyObject_HasAttr(callable, Shiboken::PyMagicName::code())) {
+    // variable `callable` is a function
+    fc = PyObject_GetAttr(callable, Shiboken::PyMagicName::code());
+} else {
+    // variable `callable` is a class method
+    fc = PyObject_GetAttr(func_ob, Shiboken::PyMagicName::code());
+    classMethod = true;
+}
+
+if (fc) {
+    PyObject* ac = PyObject_GetAttrString(fc, "co_argcount");
+    if (ac) {
+        count = PyLong_AsLong(ac);
+        Py_DECREF(ac);
+    }
+    Py_DECREF(fc);
+}
+
+if ((classMethod && (count > 2)) || (!classMethod && (count > 1))) {
+    qWarning("Functor of %FUNCTION_NAME must either have QPermission object as argument or none."
+             "The QPermission object store the result of requestPermission()");
+    return {};
+}
+
+bool arg_qpermission = (classMethod && (count == 2)) || (!classMethod && (count == 1));
+
+auto callback = [callable, count, arg_qpermission](const QPermission &permission) -> void
+{
+    Shiboken::GilState state;
+    if (arg_qpermission) {
+        Shiboken::AutoDecRef arglist(PyTuple_New(1));
+        PyTuple_SET_ITEM(arglist.object(), 0, %CONVERTTOPYTHON[QPermission](permission));
+        Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
+    } else {
+        Shiboken::AutoDecRef ret(PyObject_CallObject(callable, nullptr));
+    }
+    Py_DECREF(callable);
+};
+Py_INCREF(callable);
+
+Py_BEGIN_ALLOW_THREADS
+%CPPSELF.%FUNCTION_NAME(permission, %2, callback);
+Py_END_ALLOW_THREADS
+// @snippet qcoreapplication-requestpermission
+
+// @snippet qlockfile-getlockinfo
+qint64 pid{};
+QString hostname, appname;
+%CPPSELF.%FUNCTION_NAME(&pid, &hostname, &appname);
+%PYARG_0 = PyTuple_New(3);
+PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[qint64](pid));
+PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](hostname));
+PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[QString](appname));
+// @snippet qlockfile-getlockinfo
+
+// @snippet darwin_permission_plugin
+#ifdef Q_OS_DARWIN
+#include<QtCore/qplugin.h>
+// register the static plugin and setup its metadata
+Q_IMPORT_PLUGIN(QDarwinCameraPermissionPlugin)
+Q_IMPORT_PLUGIN(QDarwinMicrophonePermissionPlugin)
+Q_IMPORT_PLUGIN(QDarwinBluetoothPermissionPlugin)
+Q_IMPORT_PLUGIN(QDarwinContactsPermissionPlugin)
+Q_IMPORT_PLUGIN(QDarwinCalendarPermissionPlugin)
+#endif
+// @snippet darwin_permission_plugin
+
+// @snippet qt-modifier
+PyObject *_inputDict = PyDict_New();
+// Note: The builtins line is no longer needed since Python 3.10. Undocumented!
+PyDict_SetItemString(_inputDict, "__builtins__", PyEval_GetBuiltins());
+PyDict_SetItemString(_inputDict, "QtCore", module);
+PyDict_SetItemString(_inputDict, "Qt", reinterpret_cast<PyObject *>(pyType));
+// Explicitly not dereferencing the result.
+PyRun_String(R"PY(if True:
+    from enum import Flag
+    from textwrap import dedent
+    from warnings import warn
+    # QtCore and Qt come as globals.
+
+    def func_or(self, other):
+        if isinstance(self, Flag) and isinstance(other, Flag):
+            # this is normal or-ing flags together
+            return Qt.KeyboardModifier(self.value | other.value)
+        return QtCore.QKeyCombination(self, other)
+
+    def func_add(self, other):
+        warn(dedent(f"""
+            The "+" operator is deprecated in Qt For Python 6.0 .
+            Please use "|" instead."""), stacklevel=2)
+        return func_or(self, other)
+
+    Qt.KeyboardModifier.__or__ = func_or
+    Qt.KeyboardModifier.__ror__ = func_or
+    Qt.Modifier.__or__ = func_or
+    Qt.Modifier.__ror__ = func_or
+    Qt.KeyboardModifier.__add__ = func_add
+    Qt.KeyboardModifier.__radd__ = func_add
+    Qt.Modifier.__add__ = func_add
+    Qt.Modifier.__radd__ = func_add
+
+)PY", Py_file_input, _inputDict, _inputDict);
+// @snippet qt-modifier
diff --git a/sources/pyside6/PySide6/glue/qtdatavisualization.cpp b/sources/pyside6/PySide6/glue/qtdatavisualization.cpp
index 049f9accc..3a179cb17 100644
--- a/sources/pyside6/PySide6/glue/qtdatavisualization.cpp
+++ b/sources/pyside6/PySide6/glue/qtdatavisualization.cpp
@@ -41,12 +41,21 @@ using ListType = decltype(%2);
 using ListType = decltype(%2);
 %CPPSELF.setRow(%1, new ListType(%2), %3);
 // @snippet dataproxy-setrow-string
-//
+
 // @snippet dataproxy-resetarray
 using ListType = decltype(%1);
 %CPPSELF.resetArray(new ListType(%1));
 // @snippet dataproxy-resetarray
 
+// @snippet dataproxy-resetarray2
+using ListType = decltype(%1);
+%CPPSELF.resetArray(new ListType(%1), %2, %3);
+// @snippet dataproxy-resetarray2
+
+// @snippet scatterdataproxy-resetarray
+%CPPSELF.resetArray(new QScatterDataArray(*%1));
+// @snippet scatterdataproxy-resetarray
+
 // @snippet qsurfacedataproxy-resetarraynp
 auto *data = QtDataVisualizationHelper::surfaceDataFromNp(%1, %2, %3, %4, %5);
 // %CPPSELF.%FUNCTION_NAME
diff --git a/sources/pyside6/PySide6/glue/qtgraphs.cpp b/sources/pyside6/PySide6/glue/qtgraphs.cpp
new file mode 100644
index 000000000..b5a5db799
--- /dev/null
+++ b/sources/pyside6/PySide6/glue/qtgraphs.cpp
@@ -0,0 +1,8 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+// @snippet graphs-qsurfacedataproxy-resetarraynp
+auto data = QtGraphsHelper::surfaceDataFromNp(%1, %2, %3, %4, %5);
+// %CPPSELF.%FUNCTION_NAME
+%CPPSELF.resetArray(data);
+// @snippet graphs-qsurfacedataproxy-resetarraynp
diff --git a/sources/pyside6/PySide6/glue/qtgui.cpp b/sources/pyside6/PySide6/glue/qtgui.cpp
index d610933ba..5c860a2bf 100644
--- a/sources/pyside6/PySide6/glue/qtgui.cpp
+++ b/sources/pyside6/PySide6/glue/qtgui.cpp
@@ -6,7 +6,9 @@
  ********************************************************************/
 
 // @snippet gui-declarations
+QT_BEGIN_NAMESPACE
 void qt_set_sequence_auto_mnemonic(bool);
+QT_END_NAMESPACE
 // @snippet gui-declarations
 
 // @snippet qaccessible-pysidefactory
@@ -313,10 +315,7 @@ if (_i < 0 || _i >= %CPPSELF.count()) {
     return 0;
 }
 QKeyCombination item = (*%CPPSELF)[_i];
-if (usingNewEnum())
-    return %CONVERTTOPYTHON[QKeyCombination](item);
-auto combined = item.toCombined();
-return %CONVERTTOPYTHON[int](combined);
+return %CONVERTTOPYTHON[QKeyCombination](item);
 // @snippet qkeysequence-getitem
 
 // @snippet qkeysequence-repr
@@ -374,6 +373,16 @@ const auto path = PySide::pyPathToQString(%PYARG_1);
 %CPPSELF->addPixmap(path);
 // @snippet qicon-addpixmap
 
+// @snippet qclipboard-setpixmap
+const auto path = PySide::pyPathToQString(%PYARG_1);
+%CPPSELF->setPixmap(QPixmap(path));
+// @snippet qclipboard-setpixmap
+
+// @snippet qclipboard-setimage
+const auto path = PySide::pyPathToQString(%PYARG_1);
+%CPPSELF->setImage(QImage(path));
+// @snippet qclipboard-setimage
+
 // @snippet qimage-decref-image-data
 static void imageDecrefDataHandler(void *data)
 {
@@ -774,12 +783,45 @@ auto *cppResult = new QtGuiHelper::QOverrideCursorGuard();
 Shiboken::Object::getOwnership(%PYARG_0); // Ensure the guard is removed
 // @snippet qguiapplication-setoverridecursor
 
+// @snippet qguiapplication-nativeInterface
+bool hasNativeApp = false;
+#if QT_CONFIG(xcb)
+if (auto *x11App = %CPPSELF.nativeInterface<QNativeInterface::QX11Application>()) {
+    hasNativeApp = true;
+    %PYARG_0 = %CONVERTTOPYTHON[QNativeInterface::QX11Application*](x11App);
+}
+#endif
+if (!hasNativeApp) {
+    Py_INCREF(Py_None);
+    %PYARG_0 = Py_None;
+}
+// @snippet qguiapplication-nativeInterface
+
 // @snippet qscreen-grabWindow
 WId id = %1;
 %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(id, %2, %3, %4, %5);
 %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval);
 // @snippet qscreen-grabWindow
 
+// @snippet qscreen-nativeInterface
+bool hasNativeScreen = false;
+#ifdef Q_OS_WIN
+if (auto *winScreen = %CPPSELF.nativeInterface<QNativeInterface::QWindowsScreen>()) {
+    hasNativeScreen = true;
+    %PYARG_0 = %CONVERTTOPYTHON[QNativeInterface::QWindowsScreen*](winScreen);
+}
+#endif
+if (!hasNativeScreen) {
+    Py_INCREF(Py_None);
+    %PYARG_0 = Py_None;
+}
+// @snippet qscreen-nativeInterface
+
+// @snippet qx11application-resource-ptr
+ auto *resource = %CPPSELF.%FUNCTION_NAME();
+%PYARG_0 = PyLong_FromVoidPtr(resource);
+// @snippet qx11application-resource-ptr
+
 // @snippet qwindow-fromWinId
 WId id = %1;
 %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(id);
@@ -847,20 +889,47 @@ else
 %PYARG_0 = %CONVERTTOPYTHON[int](cppResult);
 // @snippet qdrag-exec-arg2
 
+// @snippet qquaternion-getaxisandangle-vector3d-float
+QVector3D outVec{};
+float angle{};
+%CPPSELF.%FUNCTION_NAME(&outVec, &angle);
+%PYARG_0 = PyTuple_New(2);
+PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QVector3D](outVec));
+PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[float](angle));
+// @snippet qquaternion-getaxisandangle-vector3d-float
+
+// @snippet qquaternion-geteulerangles
+float pitch{}, yaw{}, roll{};
+%CPPSELF.%FUNCTION_NAME(&pitch, &yaw, &roll);
+%PYARG_0 = PyTuple_New(3);
+PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[float](pitch));
+PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[float](yaw));
+PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[float](roll));
+// @snippet qquaternion-geteulerangles
+
 // @snippet qregion-len
 return %CPPSELF.rectCount();
 // @snippet qregion-len
 
 // @snippet qregion-getitem
-if (_i < 0 || _i >= %CPPSELF.rectCount()) {
-    PyErr_SetString(PyExc_IndexError, "index out of bounds");
-    return nullptr;
-}
+if (_i < 0 || _i >= %CPPSELF.rectCount())
+    return PyErr_Format(PyExc_IndexError, "index out of bounds");
 
 const QRect cppResult = *(%CPPSELF.cbegin() + _i);
 return %CONVERTTOPYTHON[QRect](cppResult);
 // @snippet qregion-getitem
 
+// Some RHI functions take a std::initializer_list<>. Add functions
+// to convert from list.
+
+// @snippet qrhi-initializer-list
+%CPPSELF.%FUNCTION_NAME(%1.cbegin(), %1.cend());
+// @snippet qrhi-initializer-list
+
+// @snippet qrhi-commandbuffer-setvertexinput
+%CPPSELF.%FUNCTION_NAME(%1, %2.size(), %2.constData(), %3, %4, %5);
+// @snippet qrhi-commandbuffer-setvertexinput
+
 /*********************************************************************
  * CONVERSIONS
  ********************************************************************/
diff --git a/sources/pyside6/PySide6/glue/qtmultimedia.cpp b/sources/pyside6/PySide6/glue/qtmultimedia.cpp
index 3d46619fd..ac8434b97 100644
--- a/sources/pyside6/PySide6/glue/qtmultimedia.cpp
+++ b/sources/pyside6/PySide6/glue/qtmultimedia.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 // @snippet qvideoframe-bits
+#include "object.h"
 %BEGIN_ALLOW_THREADS
 %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1);
 %END_ALLOW_THREADS
@@ -20,3 +21,8 @@ const unsigned char *data = %CPPSELF.%FUNCTION_NAME<unsigned char>();
 const auto size = %CPPSELF.byteCount();
 %PYARG_0 = Shiboken::Buffer::newObject(data, size);
 // @snippet qaudiobuffer-const-data
+
+// @snippet qtaudio-namespace-compatibility-alias
+Py_INCREF(pyType);
+PyModule_AddObject(module, "QtAudio", reinterpret_cast<PyObject *>(pyType));
+// @snippet qtaudio-namespace-compatibility-alias
diff --git a/sources/pyside6/PySide6/glue/qtnetwork.cpp b/sources/pyside6/PySide6/glue/qtnetwork.cpp
index f00780b40..f635f4671 100644
--- a/sources/pyside6/PySide6/glue/qtnetwork.cpp
+++ b/sources/pyside6/PySide6/glue/qtnetwork.cpp
@@ -15,20 +15,28 @@ PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QHostAddress](ha));
 PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[quint16](port));
 // @snippet qudpsocket-readdatagram
 
-// @snippet qhostinfo-lookuphost-callable
-auto *callable = %PYARG_2;
-auto cppCallback = [callable](const QHostInfo &hostInfo)
+// @snippet qhostinfo-lookuphost-functor
+struct QHostInfoFunctor : public Shiboken::PyObjectHolder
+{
+public:
+    using Shiboken::PyObjectHolder::PyObjectHolder;
+
+    void operator()(const QHostInfo &hostInfo);
+};
+
+void QHostInfoFunctor::operator()(const QHostInfo &hostInfo)
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
     auto *pyHostInfo = %CONVERTTOPYTHON[QHostInfo](hostInfo);
     PyTuple_SET_ITEM(arglist.object(), 0, pyHostInfo);
-    Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
-    Py_DECREF(callable);
-};
+    Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
+    release(); // single shot
+}
+// @snippet qhostinfo-lookuphost-functor
 
-Py_INCREF(callable);
-%CPPSELF.%FUNCTION_NAME(%1, cppCallback);
+// @snippet qhostinfo-lookuphost-callable
+%CPPSELF.%FUNCTION_NAME(%1, QHostInfoFunctor(%PYARG_2));
 // @snippet qhostinfo-lookuphost-callable
 
 // @snippet qipv6address-len
@@ -58,3 +66,65 @@ quint8 item = %CONVERTTOCPP[quint8](_value);
 %CPPSELF.c[_i] = item;
 return 0;
 // @snippet qipv6address-setitem
+
+// @snippet qrestaccessmanager-functor
+class QRestFunctor
+{
+public:
+    explicit QRestFunctor(PyObject *callable) noexcept : m_callable(callable)
+    {
+        Py_INCREF(callable);
+    }
+
+    void operator()(QRestReply &restReply);
+
+private:
+    PyObject *m_callable;
+};
+
+void QRestFunctor::operator()(QRestReply &restReply)
+{
+    Q_ASSERT(m_callable);
+    Shiboken::GilState state;
+    Shiboken::AutoDecRef arglist(PyTuple_New(1));
+    auto *restReplyPtr = &restReply;
+    auto *pyRestReply = %CONVERTTOPYTHON[QRestReply*](restReplyPtr);
+    PyTuple_SET_ITEM(arglist.object(), 0, pyRestReply);
+    Shiboken::AutoDecRef ret(PyObject_CallObject(m_callable, arglist));
+    Py_DECREF(m_callable);
+    m_callable = nullptr;
+}
+// @snippet qrestaccessmanager-functor
+
+// @snippet qrestaccessmanager-callback
+auto *networkReply = %CPPSELF.%FUNCTION_NAME(%1, %2, QRestFunctor(%PYARG_3));
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](networkReply);
+// @snippet qrestaccessmanager-callback
+
+// @snippet qrestaccessmanager-data-callback
+auto *networkReply = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, QRestFunctor(%PYARG_4));
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](networkReply);
+// @snippet qrestaccessmanager-data-callback
+
+// @snippet qrestaccessmanager-method-data-callback
+auto *networkReply = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, QRestFunctor(%PYARG_5));
+%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](networkReply);
+// @snippet qrestaccessmanager-method-data-callback
+
+// @snippet qrestreply-readjson
+QJsonParseError jsonParseError;
+std::optional<QJsonDocument> documentOptional = %CPPSELF.%FUNCTION_NAME(&jsonParseError);
+
+PyObject *pyDocument{};
+if (documentOptional.has_value()) {
+    const auto &document = documentOptional.value();
+    pyDocument = %CONVERTTOPYTHON[QJsonDocument](document);
+} else {
+    pyDocument = Py_None;
+    Py_INCREF(Py_None);
+}
+
+%PYARG_0 = PyTuple_New(2);
+PyTuple_SetItem(%PYARG_0, 0, pyDocument);
+PyTuple_SetItem(%PYARG_0, 1, %CONVERTTOPYTHON[QJsonParseError](jsonParseError));
+// @snippet qrestreply-readjson
diff --git a/sources/pyside6/PySide6/glue/qtnetworkauth.cpp b/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
index e22569e2e..7877a8dd5 100644
--- a/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
+++ b/sources/pyside6/PySide6/glue/qtnetworkauth.cpp
@@ -1,12 +1,21 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-// @snippet qabstractoauth-setmodifyparametersfunction
-auto callable = %PYARG_1;
-auto callback = [callable](QAbstractOAuth::Stage stage, QMultiMap<QString, QVariant>* dictPointer) -> void
+// @snippet qabstractoauth-lookuphost-functor
+struct QAbstractOAuthModifyFunctor : public Shiboken::PyObjectHolder
+{
+public:
+    using Shiboken::PyObjectHolder::PyObjectHolder;
+
+    void operator()(QAbstractOAuth::Stage stage, QMultiMap<QString, QVariant>* dictPointer);
+};
+
+void QAbstractOAuthModifyFunctor::operator()(QAbstractOAuth::Stage stage,
+                                             QMultiMap<QString, QVariant>* dictPointer)
 {
+    auto *callable = object();
     if (!PyCallable_Check(callable)) {
-        qWarning("Argument 1 of %FUNCTION_NAME must be a callable.");
+        qWarning("Argument 1 of setModifyParametersFunction() must be a callable.");
         return;
     }
     Shiboken::GilState state;
@@ -16,20 +25,20 @@ auto callback = [callable](QAbstractOAuth::Stage stage, QMultiMap<QString, QVari
     PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[QMultiMap<QString, QVariant>](dict));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
 
-    PyObject *key;
-    PyObject *value;
-    Py_ssize_t pos = 0;
-    while (PyDict_Next(ret, &pos, &key, &value)) {
-        QString cppKey = %CONVERTTOCPP[QString](key);
-        QVariant cppValue = %CONVERTTOCPP[QVariant](value);
-        dictPointer->replace(cppKey, cppValue);
+    if (!ret.isNull() && PyDict_Check(ret.object()) != 0) {
+        PyObject *key{};
+        PyObject *value{};
+        Py_ssize_t pos = 0;
+        while (PyDict_Next(ret.object(), &pos, &key, &value)) {
+            QString cppKey = %CONVERTTOCPP[QString](key);
+            QVariant cppValue = %CONVERTTOCPP[QVariant](value);
+            dictPointer->replace(cppKey, cppValue);
+        }
     }
+}
+// @snippet qabstractoauth-lookuphost-functor
 
-    Py_DECREF(callable);
-    return;
-
-};
-Py_INCREF(callable);
-%CPPSELF.%FUNCTION_NAME(callback);
+// @snippet qabstractoauth-setmodifyparametersfunction
+%CPPSELF.%FUNCTION_NAME(QAbstractOAuthModifyFunctor(%PYARG_1));
 // @snippet qabstractoauth-setmodifyparametersfunction
 
diff --git a/sources/pyside6/PySide6/glue/qtpositioning.cpp b/sources/pyside6/PySide6/glue/qtpositioning.cpp
new file mode 100644
index 000000000..91c331c74
--- /dev/null
+++ b/sources/pyside6/PySide6/glue/qtpositioning.cpp
@@ -0,0 +1,14 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+/*********************************************************************
+ * INJECT CODE
+ ********************************************************************/
+
+// @snippet darwin_location_permission_plugin
+#ifdef Q_OS_DARWIN
+#include<QtCore/qplugin.h>
+// register the static plugin and setup its metadata
+Q_IMPORT_PLUGIN(QDarwinLocationPermissionPlugin)
+#endif
+// @snippet darwin_location_permission_plugin
diff --git a/sources/pyside6/PySide6/glue/qtqml.cpp b/sources/pyside6/PySide6/glue/qtqml.cpp
index 20bcfff45..a56db8de6 100644
--- a/sources/pyside6/PySide6/glue/qtqml.cpp
+++ b/sources/pyside6/PySide6/glue/qtqml.cpp
@@ -62,3 +62,29 @@ return %CONVERTTOPYTHON[%RETURN_TYPE](retval);
 // @snippet qmlsingleton
 %PYARG_0 = PySide::Qml::qmlSingletonMacro(%ARGUMENT_NAMES);
 // @snippet qmlsingleton
+
+// @snippet qqmlengine-singletoninstance-qmltypeid
+QJSValue instance = %CPPSELF.singletonInstance<QJSValue>(%1);
+if (instance.isNull()) {
+    Py_INCREF(Py_None);
+    %PYARG_0 = Py_None;
+} else if (instance.isQObject()) {
+    QObject *result = instance.toQObject();
+    %PYARG_0 = %CONVERTTOPYTHON[QObject *](result);
+} else  {
+    %PYARG_0 = %CONVERTTOPYTHON[QJSValue](instance);
+}
+// @snippet qqmlengine-singletoninstance-qmltypeid
+
+// @snippet qqmlengine-singletoninstance-typename
+QJSValue instance = %CPPSELF.singletonInstance<QJSValue>(%1, %2);
+if (instance.isNull()) {
+    Py_INCREF(Py_None);
+    %PYARG_0 = Py_None;
+} else if (instance.isQObject()) {
+    QObject *result = instance.toQObject();
+    %PYARG_0 = %CONVERTTOPYTHON[QObject *](result);
+} else  {
+    %PYARG_0 = %CONVERTTOPYTHON[QJSValue](instance);
+}
+// @snippet qqmlengine-singletoninstance-typename
diff --git a/sources/pyside6/PySide6/glue/qtquick.cpp b/sources/pyside6/PySide6/glue/qtquick.cpp
index 5b127ba24..060418faf 100644
--- a/sources/pyside6/PySide6/glue/qtquick.cpp
+++ b/sources/pyside6/PySide6/glue/qtquick.cpp
@@ -4,3 +4,24 @@
 // @snippet qtquick
 PySide::initQuickSupport(module);
 // @snippet qtquick
+
+// @snippet qsgeometry-vertexdataaspoint2d
+auto *points = %CPPSELF->vertexDataAsPoint2D();
+const Py_ssize_t vertexCount = %CPPSELF->vertexCount();
+%PYARG_0 = PyList_New(vertexCount);
+for (Py_ssize_t i = 0; i < vertexCount; ++i) {
+    QSGGeometry::Point2D p = points[i];
+    PyList_SET_ITEM(%PYARG_0, i, %CONVERTTOPYTHON[QSGGeometry::Point2D](p));
+}
+// @snippet qsgeometry-vertexdataaspoint2d
+
+// @snippet qsgeometry-setvertexdataaspoint2d
+const qsizetype vertexCount = %CPPSELF->vertexCount();
+if (vertexCount != %1.size()) {
+    PyErr_SetString(PyExc_RuntimeError, "size mismatch");
+    return {};
+}
+
+QSGGeometry::Point2D *points = %CPPSELF->vertexDataAsPoint2D();
+std::copy(%1.cbegin(), %1.cend(), points);
+// @snippet qsgeometry-setvertexdataaspoint2d
diff --git a/sources/pyside6/PySide6/glue/qtquicktest.cpp b/sources/pyside6/PySide6/glue/qtquicktest.cpp
new file mode 100644
index 000000000..f41735ddf
--- /dev/null
+++ b/sources/pyside6/PySide6/glue/qtquicktest.cpp
@@ -0,0 +1,50 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+/*********************************************************************
+ * INJECT CODE
+ ********************************************************************/
+
+// @snippet call-quick-test-main
+static int callQuickTestMain(const QString &name, QObject *setup,
+                             QStringList argv, QString dir)
+{
+    if (dir.isEmpty())
+        dir = QDir::currentPath();
+    if (argv.isEmpty())
+        argv.append(name);
+
+    std::vector<QByteArray> argvB;
+    std::vector<char *> argvC;
+    const auto argc = argv.size();
+    argvB.reserve(argc);
+    argvC.reserve(argc);
+    for (const auto &arg : argv) {
+        argvB.emplace_back(arg.toUtf8());
+        argvC.push_back(argvB.back().data());
+    }
+
+    return quick_test_main_with_setup(int(argc), argvC.data(),
+                                      name.toUtf8().constData(),
+                                      dir.toUtf8().constData(), setup);
+}
+// @snippet call-quick-test-main
+
+// @snippet quick-test-main
+const int exitCode = callQuickTestMain(%1, nullptr, %2, %3);
+%PYARG_0 = %CONVERTTOPYTHON[int](exitCode);
+// @snippet quick-test-main
+
+// @snippet quick-test-main_with_setup
+Shiboken::AutoDecRef pySetupObject(PyObject_CallObject(reinterpret_cast<PyObject *>(%2), nullptr));
+if (pySetupObject.isNull() || PyErr_Occurred() != nullptr)
+    return nullptr;
+
+/// Convenience to convert a PyObject to QObject
+QObject *setupObject = PySide::convertToQObject(pySetupObject.object(), true /* raiseError */);
+if (setupObject == nullptr)
+    return nullptr;
+
+const int exitCode = callQuickTestMain(%1, setupObject, %3, %4);
+%PYARG_0 = %CONVERTTOPYTHON[int](exitCode);
+// @snippet quick-test-main_with_setup
diff --git a/sources/pyside6/PySide6/glue/qtstatemachine.cpp b/sources/pyside6/PySide6/glue/qtstatemachine.cpp
index 2d4973a04..098200b14 100644
--- a/sources/pyside6/PySide6/glue/qtstatemachine.cpp
+++ b/sources/pyside6/PySide6/glue/qtstatemachine.cpp
@@ -39,8 +39,9 @@ if (PySide::SignalManager::registerMetaMethod(%1, signalName.constData(),
 // since it refers to a name very tied to the generator implementation.
 // Check bug #362 for more information on this
 // http://bugs.openbossa.org/show_bug.cgi?id=362
+// PYSIDE-2256: The label was removed
 if (!PyObject_TypeCheck(%1, PySideSignalInstance_TypeF()))
-    goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError;
+    return Shiboken::returnWrongArguments(args, fullName, errInfo);
 PySideSignalInstance *signalInstance = reinterpret_cast<PySideSignalInstance *>(%1);
 auto sender = %CONVERTTOCPP[QObject *](PySide::Signal::getObject(signalInstance));
 QSignalTransition *%0 = %CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance),%2);
diff --git a/sources/pyside6/PySide6/glue/qtuitools.cpp b/sources/pyside6/PySide6/glue/qtuitools.cpp
index 9e52436e7..1835ed096 100644
--- a/sources/pyside6/PySide6/glue/qtuitools.cpp
+++ b/sources/pyside6/PySide6/glue/qtuitools.cpp
@@ -45,7 +45,7 @@ static PyObject *QUiLoadedLoadUiFromDevice(QUiLoader *self, QIODevice *dev, QWid
     }
 
     if (!PyErr_Occurred())
-        PyErr_SetString(PyExc_RuntimeError, "Unable to open/read ui device");
+        PyErr_Format(PyExc_RuntimeError, "Unable to open/read ui device");
     return nullptr;
 }
 
@@ -62,7 +62,7 @@ Q_IMPORT_PLUGIN(PyCustomWidgets);
 
 // @snippet quiloader-registercustomwidget
 registerCustomWidget(%PYARG_1);
-%CPPSELF.addPluginPath(""); // force reload widgets
+%CPPSELF.addPluginPath(QString{}); // force reload widgets
 // @snippet quiloader-registercustomwidget
 
 // @snippet quiloader-load-1
@@ -87,38 +87,46 @@ char *arg1 = PyBytes_AsString(strObj);
 QByteArray uiFileName(arg1);
 Py_DECREF(strObj);
 
-QFile uiFile(uiFileName);
-
-if (!uiFile.exists()) {
-    qCritical().noquote() << "File" << uiFileName << "does not exists";
+if (uiFileName.isEmpty()) {
+    qCritical() << "Error converting the UI filename to QByteArray";
     Py_RETURN_NONE;
 }
 
-if (uiFileName.isEmpty()) {
-    qCritical() << "Error converting the UI filename to QByteArray";
+QFile uiFile(QString::fromUtf8(uiFileName));
+
+if (!uiFile.exists()) {
+    qCritical().noquote() << "File" << uiFileName << "does not exist";
     Py_RETURN_NONE;
 }
 
 // Use the 'pyside6-uic' wrapper instead of 'uic'
 // This approach is better than rely on 'uic' since installing
 // the wheels cover this case.
-QString uicBin("pyside6-uic");
+QString uicBin(QStringLiteral("pyside6-uic"));
 QStringList uicArgs = {QString::fromUtf8(uiFileName)};
 
 QProcess uicProcess;
 uicProcess.start(uicBin, uicArgs);
-if (!uicProcess.waitForFinished()) {
-    qCritical() << "Cannot run 'pyside6-uic': " << uicProcess.errorString() << " - "
-                << "Exit status " << uicProcess.exitStatus()
-                << " (" << uicProcess.exitCode() << ")\n"
-                << "Check if 'pyside6-uic' is in PATH";
+if (!uicProcess.waitForStarted()) {
+    qCritical().noquote() << "Cannot run '" << uicBin << "': "
+        << uicProcess.errorString() << " - Check if 'pyside6-uic' is in PATH";
+    Py_RETURN_NONE;
+}
+
+if (!uicProcess.waitForFinished()
+    || uicProcess.exitStatus() != QProcess::NormalExit
+    || uicProcess.exitCode() != 0) {
+    qCritical().noquote() << '\'' << uicBin << "' failed: "
+        << uicProcess.errorString() << " - Exit status " << uicProcess.exitStatus()
+        << " (" << uicProcess.exitCode() << ")\n";
     Py_RETURN_NONE;
 }
+
 QByteArray uiFileContent = uicProcess.readAllStandardOutput();
 QByteArray errorOutput = uicProcess.readAllStandardError();
 
 if (!errorOutput.isEmpty()) {
-    qCritical().noquote() << errorOutput;
+    qCritical().noquote() << '\'' << uicBin << "' failed: " << errorOutput;
     Py_RETURN_NONE;
 }
 
@@ -142,8 +150,8 @@ QXmlStreamReader reader(&uiFile);
 while (!reader.atEnd() && baseClassName.isEmpty() && className.isEmpty()) {
     auto token = reader.readNext();
     if (token == QXmlStreamReader::StartElement && reader.name() == u"widget") {
-        baseClassName = reader.attributes().value(QLatin1String("class")).toUtf8();
-        className = reader.attributes().value(QLatin1String("name")).toUtf8();
+        baseClassName = reader.attributes().value(QLatin1StringView("class")).toUtf8();
+        className = reader.attributes().value(QLatin1StringView("name")).toUtf8();
     }
 }
 
diff --git a/sources/pyside6/PySide6/glue/qtwebenginecore.cpp b/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
index a569e6c11..76a7c6d73 100644
--- a/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
+++ b/sources/pyside6/PySide6/glue/qtwebenginecore.cpp
@@ -1,36 +1,64 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-// @snippet qwebenginecookiestore-setcookiefilter
-auto callable = %PYARG_1;
-auto callback = [callable](const QWebEngineCookieStore::FilterRequest& filterRequest) -> bool
+// @snippet qwebenginecookiestore-functor
+struct QWebEngineCookieFilterFunctor : public Shiboken::PyObjectHolder
+{
+    using Shiboken::PyObjectHolder::PyObjectHolder;
+
+    bool operator()(const QWebEngineCookieStore::FilterRequest& filterRequest) const;
+};
+
+bool QWebEngineCookieFilterFunctor::operator()(const QWebEngineCookieStore::FilterRequest &
+                                               filterRequest) const
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
     PyTuple_SET_ITEM(arglist, 0,
-                    %CONVERTTOPYTHON[QWebEngineCookieStore::FilterRequest](filterRequest));
-    Py_INCREF(callable);
-    PyObject* ret = PyObject_CallObject(callable, arglist);
-    Py_DECREF(callable);
-    return ret;
+                     %CONVERTTOPYTHON[QWebEngineCookieStore::FilterRequest](filterRequest));
+    Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
+    return ret.object() == Py_True;
+}
+// @snippet qwebenginecookiestore-functor
 
-};
-%CPPSELF.%FUNCTION_NAME(callback);
+// @snippet qwebenginecookiestore-setcookiefilter
+%CPPSELF.%FUNCTION_NAME(QWebEngineCookieFilterFunctor(%PYARG_1));
 // @snippet qwebenginecookiestore-setcookiefilter
 
-// @snippet qwebengineprofile-setnotificationpresenter
-auto callable = %PYARG_1;
-auto callback = [callable](std::unique_ptr<QWebEngineNotification> webEngineNotification) -> void
+// @snippet qwebengineprofile-functor
+struct QWebEngineNotificationFunctor : public Shiboken::PyObjectHolder
+{
+    using Shiboken::PyObjectHolder::PyObjectHolder;
+
+    void operator()(std::unique_ptr<QWebEngineNotification> webEngineNotification);
+};
+
+void QWebEngineNotificationFunctor::operator()
+    (std::unique_ptr<QWebEngineNotification> webEngineNotification)
 {
     Shiboken::GilState state;
     Shiboken::AutoDecRef arglist(PyTuple_New(1));
+    auto *notification = webEngineNotification.release();
     PyTuple_SET_ITEM(arglist.object(), 0,
-                    Shiboken::Conversions::pointerToPython(
-                        SbkPySide6_QtWebEngineCoreTypes[SBK_QWEBENGINENOTIFICATION_IDX],
-                        webEngineNotification.release()));
-    Py_INCREF(callable);
-    PyObject_CallObject(callable, arglist);
-    Py_DECREF(callable);
+                     %CONVERTTOPYTHON[QWebEngineNotification*](notification));
+    Shiboken::AutoDecRef ret(PyObject_CallObject(object(), arglist));
 };
-%CPPSELF.%FUNCTION_NAME(callback);
+// @snippet qwebengineprofile-functor
+
+// @snippet qwebengineprofile-setnotificationpresenter
+%CPPSELF.%FUNCTION_NAME(QWebEngineNotificationFunctor(%PYARG_1));
 // @snippet qwebengineprofile-setnotificationpresenter
+
+// @snippet qwebenginepage-javascriptprompt-virtual-redirect
+std::pair<bool, QString> resultPair = javaScriptPromptPyOverride(gil, pyOverride.object(), securityOrigin, msg, defaultValue);
+result->assign(resultPair.second);
+return resultPair.first;
+// @snippet qwebenginepage-javascriptprompt-virtual-redirect
+
+// @snippet qwebenginepage-javascriptprompt-return
+QString str;
+%RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, &str);
+%PYARG_0 = PyTuple_New(2);
+PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
+PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](str));
+// @snippet qwebenginepage-javascriptprompt-return
diff --git a/sources/pyside6/PySide6/glue/qtwebenginewidgets.cpp b/sources/pyside6/PySide6/glue/qtwebenginewidgets.cpp
index 8fdd6b693..af15130a4 100644
--- a/sources/pyside6/PySide6/glue/qtwebenginewidgets.cpp
+++ b/sources/pyside6/PySide6/glue/qtwebenginewidgets.cpp
@@ -55,8 +55,8 @@ auto callback = [callable](const QString &text)
     PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QString](text));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
-
 };
+
 Py_INCREF(callable);
 %CPPSELF.%FUNCTION_NAME(callback);
 // @snippet qwebenginepage-convertto
@@ -95,8 +95,8 @@ auto callback = [callable](const QVariant &result)
    // PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[bool](found));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
-
 };
+
 Py_INCREF(callable);
 %CPPSELF.%FUNCTION_NAME(%1, %2, callback);
 // @snippet qwebenginepage-runjavascript
@@ -114,8 +114,8 @@ auto callback = [callable](const QByteArray &pdf)
     PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QByteArray](pdf));
     Shiboken::AutoDecRef ret(PyObject_CallObject(callable, arglist));
     Py_DECREF(callable);
-
 };
+
 Py_INCREF(callable);
 %CPPSELF.%FUNCTION_NAME(callback, %2);
 // @snippet qwebenginepage-printtopdf
diff --git a/sources/pyside6/PySide6/glue/qtwidgets.cpp b/sources/pyside6/PySide6/glue/qtwidgets.cpp
index a70c0a6e1..f886106cf 100644
--- a/sources/pyside6/PySide6/glue/qtwidgets.cpp
+++ b/sources/pyside6/PySide6/glue/qtwidgets.cpp
@@ -20,7 +20,8 @@ Shiboken::Object::releaseOwnership(%PYARG_0);
 
 // @snippet qgraphicsitem
 PyObject *userTypeConstant =  PyLong_FromLong(QGraphicsItem::UserType);
-PyDict_SetItemString(Sbk_QGraphicsItem_TypeF()->tp_dict, "UserType", userTypeConstant);
+tpDict.reset(PepType_GetDict(Sbk_QGraphicsItem_TypeF()));
+PyDict_SetItemString(tpDict.object(), "UserType", userTypeConstant);
 // @snippet qgraphicsitem
 
 // @snippet qgraphicsitem-scene-return-parenting
@@ -74,7 +75,7 @@ PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QFormLayout::ItemRole](_role));
 %END_ALLOW_THREADS
 %PYARG_0 = PyTuple_New(2);
 PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_));
-PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG5_TYPE](%5));
+PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](%5));
 // @snippet qfiledialog-return
 
 // @snippet qwidget-addaction-glue
@@ -213,11 +214,24 @@ if (_widget) {
 // @snippet qtoolbox-removeitem
 
 // @snippet qlayout-help-functions
+#ifndef _QLAYOUT_HELP_FUNCTIONS_
+#define _QLAYOUT_HELP_FUNCTIONS_ // Guard for jumbo builds
+
+static const char msgInvalidParameterAdd[] =
+    "Invalid parameter None passed to addLayoutOwnership().";
+static const char msgInvalidParameterRemoval[] =
+    "Invalid parameter None passed to removeLayoutOwnership().";
+
 void addLayoutOwnership(QLayout *layout, QLayoutItem *item);
 void removeLayoutOwnership(QLayout *layout, QWidget *widget);
 
 inline void addLayoutOwnership(QLayout *layout, QWidget *widget)
 {
+    if (layout == nullptr || widget == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterAdd);
+        return;
+    }
+
     //transfer ownership to parent widget
     QWidget *lw = layout->parentWidget();
     QWidget *pw = widget->parentWidget();
@@ -244,6 +258,11 @@ inline void addLayoutOwnership(QLayout *layout, QWidget *widget)
 
 inline void addLayoutOwnership(QLayout *layout, QLayout *other)
 {
+    if (layout == nullptr || other == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterAdd);
+        return;
+    }
+
     //transfer all children widgets from other to layout parent widget
     QWidget *parent = layout->parentWidget();
     if (!parent) {
@@ -270,8 +289,11 @@ inline void addLayoutOwnership(QLayout *layout, QLayout *other)
 
 inline void addLayoutOwnership(QLayout *layout, QLayoutItem *item)
 {
-    if (!item)
+
+    if (layout == nullptr || item == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterAdd);
         return;
+    }
 
     if (QWidget *w = item->widget()) {
         addLayoutOwnership(layout, w);
@@ -287,6 +309,11 @@ inline void addLayoutOwnership(QLayout *layout, QLayoutItem *item)
 
 static void removeWidgetFromLayout(QLayout *layout, QWidget *widget)
 {
+    if (layout == nullptr || widget == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterRemoval);
+        return;
+    }
+
     if (QWidget *parent = widget->parentWidget()) {
         //give the ownership to parent
         Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](parent));
@@ -304,6 +331,11 @@ static void removeWidgetFromLayout(QLayout *layout, QWidget *widget)
 
 inline void removeLayoutOwnership(QLayout *layout, QLayoutItem *item)
 {
+    if (layout == nullptr || item == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterRemoval);
+        return;
+    }
+
     if (QWidget *w = item->widget()) {
         removeWidgetFromLayout(layout, w);
     } else {
@@ -319,8 +351,10 @@ inline void removeLayoutOwnership(QLayout *layout, QLayoutItem *item)
 
 inline void removeLayoutOwnership(QLayout *layout, QWidget *widget)
 {
-    if (!widget)
+    if (layout == nullptr || widget == nullptr) {
+        PyErr_SetString(PyExc_RuntimeError, msgInvalidParameterRemoval);
         return;
+    }
 
     for (int i = 0, i_max = layout->count(); i < i_max; ++i) {
         QLayoutItem *item = layout->itemAt(i);
@@ -330,15 +364,17 @@ inline void removeLayoutOwnership(QLayout *layout, QWidget *widget)
             removeLayoutOwnership(layout, item);
     }
 }
+#endif // _QLAYOUT_HELP_FUNCTIONS_
 // @snippet qlayout-help-functions
 
 // @snippet qlayout-setalignment
 %CPPSELF.setAlignment(%1);
 // @snippet qlayout-setalignment
 
-// @snippet addownership-0
-addLayoutOwnership(%CPPSELF, %0);
-// @snippet addownership-0
+// @snippet addownership-item-at
+if (%0 != nullptr)
+    addLayoutOwnership(%CPPSELF, %0);
+// @snippet addownership-item-at
 
 // @snippet addownership-1
 addLayoutOwnership(%CPPSELF, %1);
@@ -385,7 +421,7 @@ Shiboken::BindingManager &bm = Shiboken::BindingManager::instance();
 for (auto *item : items) {
     SbkObject *obj = bm.retrieveWrapper(item);
     if (obj) {
-        if (reinterpret_cast<PyObject *>(obj)->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway.
+        if (Py_REFCNT(reinterpret_cast<PyObject *>(obj)) > 1) // If the refcnt is 1 the object will vannish anyway.
             Shiboken::Object::invalidate(obj);
         Shiboken::Object::removeParent(obj);
     }
@@ -434,11 +470,14 @@ for (int i = 0, count = %CPPSELF.count(); i < count; ++i) {
 // @snippet qlistwidget-clear
 
 // @snippet qwidget-retrieveobjectname
+#ifndef _RETRIEVEOBJECTNAME_
+#define _RETRIEVEOBJECTNAME_ // Guard for jumbo builds
 static QByteArray retrieveObjectName(PyObject *obj)
 {
     Shiboken::AutoDecRef objName(PyObject_Str(obj));
     return Shiboken::String::toCString(objName);
 }
+#endif
 // @snippet qwidget-retrieveobjectname
 
 // @snippet qwidget-glue
@@ -508,15 +547,20 @@ Shiboken::Object::keepReference(reinterpret_cast<SbkObject *>(%PYSELF), "__style
 // @snippet qwidget-style
 QStyle *myStyle = %CPPSELF->style();
 if (myStyle && qApp) {
-%PYARG_0 = %CONVERTTOPYTHON[QStyle *](myStyle);
+    bool keepReference = true;
+    %PYARG_0 = %CONVERTTOPYTHON[QStyle *](myStyle);
     QStyle *appStyle = qApp->style();
     if (appStyle == myStyle) {
         Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication *](qApp));
-        Shiboken::Object::setParent(pyApp, %PYARG_0);
-        Shiboken::Object::releaseOwnership(%PYARG_0);
-    } else {
-        Shiboken::Object::keepReference(reinterpret_cast<SbkObject *>(%PYSELF), "__style__",  %PYARG_0);
+        // Do not set parentship when qApp is embedded
+        if (Shiboken::Object::wasCreatedByPython(reinterpret_cast<SbkObject *>(pyApp.object()))) {
+            Shiboken::Object::setParent(pyApp, %PYARG_0);
+            Shiboken::Object::releaseOwnership(%PYARG_0);
+            keepReference = false;
+        }
     }
+    if (keepReference)
+        Shiboken::Object::keepReference(reinterpret_cast<SbkObject *>(%PYSELF), "__style__",  %PYARG_0);
 }
 // @snippet qwidget-style
 
@@ -695,49 +739,49 @@ const char *styleOptionType(const QStyleOption *o)
     case QStyleOption::SO_Default:
         break;
     case QStyleOption::SO_FocusRect:
-        return "StyleOptionFocusRect";
+        return "QStyleOptionFocusRect";
     case QStyleOption::SO_Button:
-        return "StyleOptionButton";
+        return "QStyleOptionButton";
     case QStyleOption::SO_Tab:
-        return "StyleOptionTab";
+        return "QStyleOptionTab";
     case QStyleOption::SO_MenuItem:
-        return "StyleOptionMenuItem";
+        return "QStyleOptionMenuItem";
     case QStyleOption::SO_Frame:
-        return "StyleOptionFrame";
+        return "QStyleOptionFrame";
     case QStyleOption::SO_ProgressBar:
-        return "StyleOptionProgressBar";
+        return "QStyleOptionProgressBar";
     case QStyleOption::SO_ToolBox:
-        return "StyleOptionToolBox";
+        return "QStyleOptionToolBox";
     case QStyleOption::SO_Header:
-        return "StyleOptionHeader";
+        return "QStyleOptionHeader";
     case QStyleOption::SO_DockWidget:
-        return "StyleOptionDockWidget";
+        return "QStyleOptionDockWidget";
     case QStyleOption::SO_ViewItem:
-        return "StyleOptionViewItem";
+        return "QStyleOptionViewItem";
     case QStyleOption::SO_TabWidgetFrame:
-        return "StyleOptionTabWidgetFrame";
+        return "QStyleOptionTabWidgetFrame";
     case QStyleOption::SO_TabBarBase:
-        return "StyleOptionTabBarBase";
+        return "QStyleOptionTabBarBase";
     case QStyleOption::SO_RubberBand:
-        return "StyleOptionRubberBand";
+        return "QStyleOptionRubberBand";
     case QStyleOption::SO_ToolBar:
-        return "StyleOptionToolBar";
+        return "QStyleOptionToolBar";
     case QStyleOption::SO_GraphicsItem:
-        return "StyleOptionGraphicsItem";
+        return "QStyleOptionGraphicsItem";
     case QStyleOption::SO_Slider:
-        return "StyleOptionSlider";
+        return "QStyleOptionSlider";
     case QStyleOption::SO_SpinBox:
-        return "StyleOptionSpinBox";
+        return "QStyleOptionSpinBox";
     case QStyleOption::SO_ToolButton:
-        return "StyleOptionToolButton";
+        return "QStyleOptionToolButton";
     case QStyleOption::SO_ComboBox:
-        return "StyleOptionComboBox";
+        return "QStyleOptionComboBox";
     case QStyleOption::SO_TitleBar:
-        return "StyleOptionTitleBar";
+        return "QStyleOptionTitleBar";
     case QStyleOption::SO_GroupBox:
-        return "StyleOptionGroupBox";
+        return "QStyleOptionGroupBox";
     case QStyleOption::SO_SizeGrip:
-        return "StyleOptionSizeGrip";
+        return "QStyleOptionSizeGrip";
     default:
         break;
     }
@@ -745,6 +789,26 @@ const char *styleOptionType(const QStyleOption *o)
 }
 // @snippet qstyleoption-typename
 
+// @snippet qwizardpage-registerfield
+auto *signalInst = reinterpret_cast<PySideSignalInstance *>(%PYARG_4);
+const auto data = PySide::Signal::getEmitterData(signalInst);
+if (data.methodIndex == -1)
+    return PyErr_Format(PyExc_RuntimeError, "QWizardPage::registerField(): Unable to retrieve signal emitter.");
+const auto method = data.emitter->metaObject()->method(data.methodIndex);
+const QByteArray signature = QByteArrayLiteral("2") + method.methodSignature();
+%BEGIN_ALLOW_THREADS
+%CPPSELF.%FUNCTION_NAME(%1, %2, %3, signature.constData());
+%END_ALLOW_THREADS
+// @snippet qwizardpage-registerfield
+
+// The constructor heuristics generate setting a parent-child relationship
+// when creating a QDialog with parent. This causes the dialog to leak
+// when it synchronous exec() is used instead of asynchronous show().
+// In that case, remove the parent-child relationship.
+// @snippet qdialog-exec-remove-parent-relation
+Shiboken::Object::removeParent(reinterpret_cast<SbkObject *>(%PYSELF));
+// @snippet qdialog-exec-remove-parent-relation
+
 /*********************************************************************
  * CONVERSIONS
  ********************************************************************/
diff --git a/sources/pyside6/PySide6/pysidewtypes.h b/sources/pyside6/PySide6/pysidewtypes.h
index 4e6cf8263..f853949ac 100644
--- a/sources/pyside6/PySide6/pysidewtypes.h
+++ b/sources/pyside6/PySide6/pysidewtypes.h
@@ -4,12 +4,12 @@
 #ifndef __PYSIDEWTYPES__
 #define __PYSIDEWTYPES__
 
-typedef struct HWND__ *HWND;
-typedef unsigned UINT;
-typedef long LONG;
-typedef unsigned long DWORD;
-typedef UINT WPARAM;
-typedef LONG LPARAM;
+using HWND = struct HWND__ *;
+using UINT = unsigned;
+using LONG = long;
+using DWORD = unsigned long;
+using WPARAM = UINT;
+using LPARAM = LONG;
 
 struct POINT
 {
diff --git a/sources/pyside6/PySide6/qiopipe.h b/sources/pyside6/PySide6/qiopipe.h
new file mode 100644
index 000000000..6a325f184
--- /dev/null
+++ b/sources/pyside6/PySide6/qiopipe.h
@@ -0,0 +1,36 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QIOPIPE_H
+#define QIOPIPE_H
+
+#include <QtCore/qiodevicebase.h>
+#include <QtCore/qobject.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+
+namespace QtCoreHelper
+{
+
+class QIOPipePrivate;
+class QIOPipe : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QIOPipe)
+
+public:
+    QIOPipe(QObject *parent = nullptr);
+
+    bool open(QIODeviceBase::OpenMode mode);
+
+    QIODevice *end1() const;
+    QIODevice *end2() const;
+};
+
+} // namespace QtCoreHelper
+
+QT_END_NAMESPACE
+
+#endif // QIOPIPE_H
diff --git a/sources/pyside6/PySide6/qpydesignerextensions.h b/sources/pyside6/PySide6/qpydesignerextensions.h
index 04764c9a4..871fa8284 100644
--- a/sources/pyside6/PySide6/qpydesignerextensions.h
+++ b/sources/pyside6/PySide6/qpydesignerextensions.h
@@ -21,6 +21,10 @@ Q_DECLARE_INTERFACE(QDesignerTaskMenuExtension, "org.qt-project.Qt.Designer.Task
 Q_DECLARE_INTERFACE(QDesignerCustomWidgetCollectionInterface, "org.qt-project.Qt.QDesignerCustomWidgetCollectionInterface")
 #endif
 
+struct _object; // PyObject
+
+QT_BEGIN_NAMESPACE
+
 // Extension implementations need to inherit QObject which cannot be done in Python.
 // Provide a base class (cf QPyTextObject).
 
@@ -56,8 +60,6 @@ public:
     explicit QPyDesignerTaskMenuExtension(QObject *parent = nullptr) : QObject(parent) {}
 };
 
-struct _object; // PyObject
-
 class QPyDesignerCustomWidgetCollection : public QDesignerCustomWidgetCollectionInterface
 {
 public:
@@ -77,4 +79,6 @@ private:
     QList<QDesignerCustomWidgetInterface *> m_customWidgets;
 };
 
+QT_END_NAMESPACE
+
 #endif // QPYDESIGNEREXTENSIONS_H
diff --git a/sources/pyside6/PySide6/qpyqmlparserstatus.h b/sources/pyside6/PySide6/qpyqmlparserstatus.h
index 897ebfb5e..24dcdda75 100644
--- a/sources/pyside6/PySide6/qpyqmlparserstatus.h
+++ b/sources/pyside6/PySide6/qpyqmlparserstatus.h
@@ -11,6 +11,8 @@
 Q_DECLARE_INTERFACE(QQmlParserStatus, "org.qt-project.Qt.QQmlParserStatus")
 #endif
 
+QT_BEGIN_NAMESPACE
+
 // Inherit from QObject such that QQmlParserStatus can be found at
 // a fixed offset (RegisterType::parserStatusCast).
 class QPyQmlParserStatus : public QObject, public QQmlParserStatus
@@ -21,4 +23,6 @@ public:
     explicit QPyQmlParserStatus(QObject *parent = nullptr) : QObject(parent) {}
 };
 
+QT_END_NAMESPACE
+
 #endif // QPYQMLPARSERSTATUS_H
diff --git a/sources/pyside6/PySide6/qpyqmlpropertyvaluesource.h b/sources/pyside6/PySide6/qpyqmlpropertyvaluesource.h
index 8e8fc24c1..0b6a0b95c 100644
--- a/sources/pyside6/PySide6/qpyqmlpropertyvaluesource.h
+++ b/sources/pyside6/PySide6/qpyqmlpropertyvaluesource.h
@@ -10,6 +10,8 @@
 Q_DECLARE_INTERFACE(QQmlPropertyValueSource, "org.qt-project.Qt.QQmlPropertyValueSource")
 #endif
 
+QT_BEGIN_NAMESPACE
+
 // Inherit from QObject such that QQmlPropertyValueSource can be found at
 // a fixed offset (RegisterType::valueSourceCast).
 class QPyQmlPropertyValueSource : public QObject, public QQmlPropertyValueSource
@@ -20,4 +22,6 @@ public:
     explicit QPyQmlPropertyValueSource(QObject *parent = nullptr) : QObject(parent) {}
 };
 
+QT_END_NAMESPACE
+
 #endif // QPYQMLPROPERTYVALUESOURCE_H
diff --git a/sources/pyside6/PySide6/qpytextobject.h b/sources/pyside6/PySide6/qpytextobject.h
index c667b2980..45bb0bd52 100644
--- a/sources/pyside6/PySide6/qpytextobject.h
+++ b/sources/pyside6/PySide6/qpytextobject.h
@@ -13,6 +13,7 @@
 Q_DECLARE_INTERFACE(QTextObjectInterface, "org.qt-project.Qt.QTextObjectInterface")
 #endif
 
+QT_BEGIN_NAMESPACE
 class QPyTextObject : public QObject, public QTextObjectInterface
 {
     Q_OBJECT
@@ -20,6 +21,8 @@ class QPyTextObject : public QObject, public QTextObjectInterface
 public:
     QPyTextObject(QObject *parent = nullptr) : QObject(parent) {}
 };
+QT_END_NAMESPACE
+
 #endif
 
 
diff --git a/sources/pyside6/PySide6/qtcorehelper.h b/sources/pyside6/PySide6/qtcorehelper.h
index 522074cba..589d0b295 100644
--- a/sources/pyside6/PySide6/qtcorehelper.h
+++ b/sources/pyside6/PySide6/qtcorehelper.h
@@ -4,10 +4,12 @@
 #ifndef QTCOREHELPER_H
 #define QTCOREHELPER_H
 
-#include <QtCore/qsharedpointer.h>
 #include <QtCore/qmutex.h>
 #include <QtCore/qobjectdefs.h>
 
+#include <memory>
+
+QT_BEGIN_NAMESPACE
 
 namespace QtCoreHelper {
 
@@ -82,13 +84,13 @@ namespace QtCoreHelper {
         QGenericArgumentHolder &operator=(QGenericArgumentHolder &&);
         ~QGenericArgumentHolder();
 
-        operator QGenericArgument () const;
+        QGenericArgument toGenericArgument() const;
 
         QMetaType metaType() const;
         const void *data() const;
 
     private:
-        QSharedPointer<QGenericArgumentData> d;
+        std::shared_ptr<QGenericArgumentData> d;
     };
 
     class QGenericReturnArgumentData;
@@ -104,15 +106,17 @@ namespace QtCoreHelper {
         QGenericReturnArgumentHolder &operator=(QGenericReturnArgumentHolder &&);
         ~QGenericReturnArgumentHolder();
 
-        operator QGenericReturnArgument () const;
+        QGenericReturnArgument toGenericReturnArgument() const;
 
         QMetaType metaType() const;
         const void *data() const;
 
     private:
-        QSharedPointer<QGenericReturnArgumentData> d;
+        std::shared_ptr<QGenericReturnArgumentData> d;
     };
 
 } // namespace QtCoreHelper
 
+QT_END_NAMESPACE
+
 #endif // QTCOREHELPER_H
diff --git a/sources/pyside6/PySide6/qtdatavisualization_helper.h b/sources/pyside6/PySide6/qtdatavisualization_helper.h
index 6884900ee..8fee4492d 100644
--- a/sources/pyside6/PySide6/qtdatavisualization_helper.h
+++ b/sources/pyside6/PySide6/qtdatavisualization_helper.h
@@ -6,8 +6,8 @@
 
 #include <sbkpython.h>
 
-#include <QtDataVisualization/QSurfaceDataProxy>
-#include <QtCore/QList>
+#include <QtDataVisualization/qsurfacedataproxy.h>
+#include <QtCore/qlist.h>
 
 namespace QtDataVisualizationHelper {
 
diff --git a/sources/pyside6/PySide6/qtdbushelper.h b/sources/pyside6/PySide6/qtdbushelper.h
index b59d2db9c..7389ad815 100644
--- a/sources/pyside6/PySide6/qtdbushelper.h
+++ b/sources/pyside6/PySide6/qtdbushelper.h
@@ -8,6 +8,7 @@
 #include <QtDBus/qdbuspendingcall.h>
 #include <QtDBus/qdbusreply.h>
 
+QT_BEGIN_NAMESPACE
 namespace QtDBusHelper {
 
 // A Python-bindings friendly, non-template QDBusReply
@@ -56,4 +57,6 @@ inline QDBusReply::QDBusReply() = default;
 
 } // namespace QtDBusHelper
 
+QT_END_NAMESPACE
+
 #endif // QTDBUSHELPER_H
diff --git a/sources/pyside6/PySide6/qtgraphs_helper.h b/sources/pyside6/PySide6/qtgraphs_helper.h
new file mode 100644
index 000000000..e488fc7d3
--- /dev/null
+++ b/sources/pyside6/PySide6/qtgraphs_helper.h
@@ -0,0 +1,19 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTGRAPHS_HELPER_H
+#define QTGRAPHS_HELPER_H
+
+#include <sbkpython.h>
+
+#include <QtGraphs/qsurfacedataproxy.h>
+#include <QtCore/qlist.h>
+
+namespace QtGraphsHelper {
+
+QSurfaceDataArray surfaceDataFromNp(double x, double deltaX, double z, double deltaZ,
+                                    PyObject *data);
+
+} // namespace QtGraphsHelper
+
+#endif // QTGRAPHS_HELPER_H
diff --git a/sources/pyside6/PySide6/qtguihelper.h b/sources/pyside6/PySide6/qtguihelper.h
index dfb7b994a..e537cfefa 100644
--- a/sources/pyside6/PySide6/qtguihelper.h
+++ b/sources/pyside6/PySide6/qtguihelper.h
@@ -6,6 +6,7 @@
 
 #include <QtGui/QGuiApplication>
 
+QT_BEGIN_NAMESPACE
 namespace QtGuiHelper {
 
     class QOverrideCursorGuard
@@ -29,5 +30,6 @@ namespace QtGuiHelper {
     };
 
 } // namespace QtGuiHelper
+QT_END_NAMESPACE
 
 #endif // QTGUIHELPER_H
diff --git a/sources/pyside6/PySide6/support/deprecated.py b/sources/pyside6/PySide6/support/deprecated.py
index 449a5d2f0..263dd3ed7 100644
--- a/sources/pyside6/PySide6/support/deprecated.py
+++ b/sources/pyside6/PySide6/support/deprecated.py
@@ -13,85 +13,6 @@ Functions that are to be called for
 
 Note that this fixing code is run after all initializations, but before the
 import is finished. But that is no problem since the module is passed in.
-
-PYSIDE-1735: This is also used now for missing other functions (overwriting __or__
-             in Qt.(Keyboard)Modifier).
 """
 
-import inspect
-import sys
-import warnings
-from textwrap import dedent
-
-
-class PySideDeprecationWarningRemovedInQt6(Warning):
-    pass
-
-
-def constData(self):
-    cls = self.__class__
-    name = cls.__qualname__
-    warnings.warn(dedent(f"""
-        {name}.constData is unpythonic and will be removed in Qt For Python 6.0 .
-        Please use {name}.data instead."""), PySideDeprecationWarningRemovedInQt6, stacklevel=2)
-    return cls.data(self)
-
-
-# No longer needed but kept for reference.
-def _unused_fix_for_QtGui(QtGui):
-    for name, cls in QtGui.__dict__.items():
-        if name.startswith("QMatrix") and "data" in cls.__dict__:
-            cls.constData = constData
-
-# PYSIDE-1735: Fix for a special enum function
-def fix_for_QtCore(QtCore):
-    from enum import Flag
-    Qt = QtCore.Qt
-    flag_or = Flag.__or__
-
-    def func_or(self, other):
-        if isinstance(self, Flag) and isinstance(other, Flag):
-            # this is normal or-ing flags together
-            return Qt.KeyboardModifier(self.value | other.value)
-        return QtCore.QKeyCombination(self, other)
-
-    def func_add(self, other):
-        warnings.warn(dedent(f"""
-            The "+" operator is deprecated in Qt For Python 6.0 .
-            Please use "|" instead."""), PySideDeprecationWarningRemovedInQt6, stacklevel=2)
-        return func_or(self, other)
-
-    Qt.KeyboardModifier.__or__ = func_or
-    Qt.KeyboardModifier.__ror__ = func_or
-    Qt.Modifier.__or__ = func_or
-    Qt.Modifier.__ror__ = func_or
-    Qt.KeyboardModifier.__add__ = func_add
-    Qt.KeyboardModifier.__radd__ = func_add
-    Qt.Modifier.__add__ = func_add
-    Qt.Modifier.__radd__ = func_add
-
-    # PYSIDE-2101: Fix rlcompleter until we evict the __signature__ attribute
-    apply_rlcompleter_patch()
-
-
-def apply_rlcompleter_patch():
-
-    def _callable_postfix(self, val, word):
-        if callable(val):
-            word += "("
-            try:
-                if not inspect.signature(val).parameters:
-                    word += ")"
-            except ValueError:
-                pass
-            # PYSIDE-2101: this line is added because inspect.signature cannot handle lists
-            except TypeError:
-                pass
-
-        return word
-
-    if sys.version_info[:2] >= (3, 10):
-        from rlcompleter import Completer
-        Completer._callable_postfix = _callable_postfix
-
 # eof
diff --git a/sources/pyside6/PySide6/support/generate_pyi.py b/sources/pyside6/PySide6/support/generate_pyi.py
index 5a2cf05ee..92808e2a5 100644
--- a/sources/pyside6/PySide6/support/generate_pyi.py
+++ b/sources/pyside6/PySide6/support/generate_pyi.py
@@ -8,14 +8,14 @@ This script generates the .pyi files for all PySide modules.
 """
 
 import argparse
-import inspect
+import inspect  # noqa: F401
 import logging
 import os
 import sys
-import typing
+import typing  # noqa: F401
 
 from pathlib import Path
-from types import SimpleNamespace
+from types import SimpleNamespace  # noqa: F401
 
 # Can we use forward references?
 USE_PEP563 = sys.version_info[:2] >= (3, 7)
@@ -25,7 +25,7 @@ def generate_all_pyi(outpath, options):
     ps = os.pathsep
     if options.sys_path:
         # make sure to propagate the paths from sys_path to subprocesses
-        normpath = lambda x: os.fspath(Path(x).resolve())
+        normpath = lambda x: os.fspath(Path(x).resolve())  # noqa: E731
         sys_path = [normpath(_) for _ in options.sys_path]
         sys.path[0:0] = sys_path
         pypath = ps.join(sys_path)
@@ -63,15 +63,16 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(
         description="This script generates the .pyi file for all PySide modules.")
     parser.add_argument("modules", nargs="+",
-        help="'all' or the names of modules to build (QtCore QtGui etc.)")
+                        help="'all' or the names of modules to build (QtCore QtGui etc.)")
     parser.add_argument("--quiet", action="store_true", help="Run quietly")
-    parser.add_argument("--check", action="store_true", help="Test the output if on Python 3")
     parser.add_argument("--outpath",
-        help="the output directory (default = binary location)")
+                        help="the output directory (default = binary location)")
     parser.add_argument("--sys-path", nargs="+",
-        help="a list of strings prepended to sys.path")
+                        help="a list of strings prepended to sys.path")
     parser.add_argument("--feature", nargs="+", choices=["snake_case", "true_property"], default=[],
-        help="""a list of feature names. Example: `--feature snake_case true_property`""")
+                        help="""a list of feature names. """
+                        """Example: `--feature snake_case true_property`. """
+                        """Currently not available for PyPy.""")
     options = parser.parse_args()
 
     qtest_env = os.environ.get("QTEST_ENVIRONMENT", "")
diff --git a/sources/pyside6/PySide6/templates/core_common.xml b/sources/pyside6/PySide6/templates/core_common.xml
index 525e72643..07bafc6ff 100644
--- a/sources/pyside6/PySide6/templates/core_common.xml
+++ b/sources/pyside6/PySide6/templates/core_common.xml
@@ -284,13 +284,4 @@
     }
     </template>
 
-    <template name="pydatetime_importandcheck_function">
-        static bool PyDateTime_ImportAndCheck(PyObject *pyIn)
-        {
-            if (!PyDateTimeAPI)
-                PyDateTime_IMPORT;
-            return $DATETIMETYPE_Check(pyIn);
-        }
-    </template>
-
 </typesystem>
diff --git a/sources/pyside6/PySide6/templates/gui_common.xml b/sources/pyside6/PySide6/templates/gui_common.xml
index c059a2a3d..6a7404507 100644
--- a/sources/pyside6/PySide6/templates/gui_common.xml
+++ b/sources/pyside6/PySide6/templates/gui_common.xml
@@ -8,7 +8,7 @@
        int size = Shiboken::String::len(%PYARG_1);
        if (size == 1) {
            const char *str = Shiboken::String::toCString(%PYARG_1);
-           QChar ch(str[0]);
+           const QChar ch(static_cast&lt;unsigned short&gt;(str[0]));
            %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ch);
            %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
        } else {
diff --git a/sources/pyside6/cmake/Macros/PySideModules.cmake b/sources/pyside6/cmake/Macros/PySideModules.cmake
index cca66be8e..33b844f95 100644
--- a/sources/pyside6/cmake/Macros/PySideModules.cmake
+++ b/sources/pyside6/cmake/Macros/PySideModules.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 include(CMakeParseArguments)
 
 # A version of cmake_parse_arguments that makes sure all arguments are processed and errors out
@@ -18,6 +21,21 @@ macro(unmake_path varname)
    string(REPLACE "${PATH_SEP}" ";" ${varname} "${ARGN}")
 endmacro()
 
+# Check for presence of QtOpenGL and modify module variables
+# accordingly
+macro(check_qt_opengl module include_var deps_var dropped_entries_var)
+    if (Qt${QT_MAJOR_VERSION}OpenGL_FOUND)
+        message(STATUS "Qt${QT_MAJOR_VERSION}${module}: Building with OpenGL")
+        list(APPEND ${include_var} ${Qt${QT_MAJOR_VERSION}OpenGL_INCLUDE_DIRS}
+                                   ${QtOpenGL_GEN_DIR})
+        list(APPEND ${deps_var} QtOpenGL)
+    else()
+        message(STATUS "Qt${QT_MAJOR_VERSION}${module}: Dropping OpenGL")
+        # This is a dummy entry creating a conditional typesystem keyword
+        list(APPEND ${dropped_entries_var} "QtOpenGL")
+    endif()
+endmacro()
+
 # set size optimization flags for pyside6
 macro(append_size_optimization_flags _module_name)
     if(NOT QFP_NO_OVERRIDE_OPTIMIZATION_FLAGS)
@@ -48,7 +66,7 @@ macro(create_pyside_module)
         "create_pyside_module" # Macro name
         "" # Flags
         "NAME;TYPESYSTEM_PATH;TYPESYSTEM_NAME" # Single value
-        "INCLUDE_DIRS;LIBRARIES;DEPS;SOURCES;STATIC_SOURCES;DROPPED_ENTRIES;GLUE_SOURCES" # Multival
+        "INCLUDE_DIRS;LIBRARIES;DEPS;SOURCES;STATIC_SOURCES;DROPPED_ENTRIES;GLUE_SOURCES;ADDITIONAL_INCLUDE_DIRS" # Multival
         ${ARGN} # Number of arguments given when the macros is called
         )
 
@@ -105,10 +123,46 @@ macro(create_pyside_module)
                         INTERFACE_INCLUDE_DIRECTORIES)
     set(shiboken_include_dir_list ${pyside6_SOURCE_DIR} ${qt_platform_includes}
         ${qt_core_includes})
+    if(module_ADDITIONAL_INCLUDE_DIRS)
+        list(APPEND shiboken_include_dir_list ${${module_ADDITIONAL_INCLUDE_DIRS}})
+    endif()
 
     # Transform the path separators into something shiboken understands.
     make_path(shiboken_include_dirs ${shiboken_include_dir_list})
 
+    set(force_process_system_include_paths_list "")
+    # When building against system Qt (as it happens with yocto / Boot2Qt), the Qt headers are
+    # considered system headers by clang_Location_isInSystemHeader, and thus shiboken will not
+    # process them.
+    #
+    # We do want to process them.
+    #
+    # Tell shiboken to consider them as special typesystem system include paths, which ensures
+    # the types are processed and extracted.
+    #
+    # This option is opt-in because it might cause problems if there are other system headers
+    # installed in the same location as the Qt ones, resulting in processing more non-Qt system
+    # types that might not be supported by shiboken.
+    if(PYSIDE_TREAT_QT_INCLUDE_DIRS_AS_NON_SYSTEM)
+        list(APPEND force_process_system_include_paths_list
+            ${qt_platform_includes}
+            ${qt_core_includes})
+    endif()
+
+    # Allow passing extra non system inlcude dirs.
+    if(SHIBOKEN_FORCE_PROCESS_SYSTEM_INCLUDE_PATHS)
+        list(APPEND force_process_system_include_paths_list
+            ${SHIBOKEN_FORCE_PROCESS_SYSTEM_INCLUDE_PATHS})
+    endif()
+
+    # Transform the path separators into something shiboken understands.
+    make_path(force_process_system_include_paths ${force_process_system_include_paths_list})
+
+    if(force_process_system_include_paths)
+        set(force_process_system_include_paths
+            "--force-process-system-include-paths=${force_process_system_include_paths}")
+    endif()
+
     get_filename_component(pyside_binary_dir ${CMAKE_CURRENT_BINARY_DIR} DIRECTORY)
 
     # Install module glue files.
@@ -133,12 +187,42 @@ macro(create_pyside_module)
         $<TARGET_FILE:Shiboken6::shiboken6>
         ${GENERATOR_EXTRA_FLAGS}
         "--include-paths=${shiboken_include_dirs}"
+        "${force_process_system_include_paths}"
         "--typesystem-paths=${pyside_binary_dir}${PATH_SEP}${pyside6_SOURCE_DIR}${PATH_SEP}${${module_TYPESYSTEM_PATH}}"
         --output-directory=${CMAKE_CURRENT_BINARY_DIR}
         --license-file=${CMAKE_CURRENT_SOURCE_DIR}/../licensecomment.txt
         --lean-headers
         --api-version=${SUPPORTED_QT_VERSION})
 
+    # check if building for Android with a macOS host
+    # This is not needed for Linux because OpenGLES2 development binaries in
+    # linux can be installed by installing 'libgles2-mesa-dev' package which
+    # comes as a default requirement for building PySide6. As such for
+    # cross-compiling in linux, we use the clang compiler from the installed
+    # libclang itself.
+    if(CMAKE_ANDROID_ARCH_LLVM_TRIPLE AND CMAKE_HOST_APPLE)
+        message(STATUS "Building for Android with arch ${CMAKE_ANDROID_ARCH_LLVM_TRIPLE}")
+        list(APPEND shiboken_command "--clang-option=--target=${CMAKE_ANDROID_ARCH_LLVM_TRIPLE}")
+
+        # CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX does not contain the ANDROID_PLATFORM i.e. it ends with
+        # the form 'aarch64-linux-android-'. Remove the last '-' and add the corresponding clang
+        # based on ANDROID_PLATFORM making it 'aarch64-linux-android26-clang++'
+
+        # Get the length of the string
+        string(LENGTH "${CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX}" _length)
+
+        # Subtract 1 from the length to get the characters till '-'
+        math(EXPR _last_index "${_length} - 1")
+
+        # Get the substring from the start to the character before the last one
+        string(SUBSTRING "${CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX}" 0 "${_last_index}"
+               SHIBOKEN_ANDROID_COMPILER_PREFIX)
+
+        # use the compiler from the Android NDK
+        list(APPEND shiboken_command
+            "--compiler-path=${SHIBOKEN_ANDROID_COMPILER_PREFIX}${CMAKE_ANDROID_API}-clang++")
+    endif()
+
     if(CMAKE_HOST_APPLE)
         set(shiboken_framework_include_dir_list ${QT_FRAMEWORK_INCLUDE_DIR})
         make_path(shiboken_framework_include_dirs ${shiboken_framework_include_dir_list})
@@ -240,7 +324,7 @@ macro(create_pyside_module)
     # Don't generate the files when cross-building because the target python can not be executed
     # on the host machine (usually, unless you use some userspace qemu based mechanism).
     # TODO: Can we do something better here to still get pyi files?
-    if(NOT PYSIDE_IS_CROSS_BUILD)
+    if(NOT (PYSIDE_IS_CROSS_BUILD OR DISABLE_PYI))
         set(generate_pyi_options ${module_NAME} --sys-path
             "${pysidebindings_BINARY_DIR}"
             "${SHIBOKEN_PYTHON_MODULE_DIR}/..")     # use the layer above shiboken6
@@ -256,11 +340,7 @@ macro(create_pyside_module)
                               ${generate_pyi_options})
         add_dependencies("${module_NAME}_pyi" ${module_NAME})
 
-        file(GLOB hinting_stub_files
-             RELATIVE
-                 "${CMAKE_CURRENT_BINARY_DIR}/PySide6"
-                 "${CMAKE_CURRENT_BINARY_DIR}/PySide6/*.pyi")
-        install(FILES ${hinting_stub_files}
+        install(FILES "${CMAKE_CURRENT_BINARY_DIR}/../${module_NAME}.pyi"
                 DESTINATION "${PYTHON_SITE_PACKAGES}/PySide6")
     endif()
 
diff --git a/sources/pyside6/cmake/Macros/icecc.cmake b/sources/pyside6/cmake/Macros/icecc.cmake
index b2bf071aa..fa8d3b7cf 100644
--- a/sources/pyside6/cmake/Macros/icecc.cmake
+++ b/sources/pyside6/cmake/Macros/icecc.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 include (CMakeForceCompiler)
 option(ENABLE_ICECC "Enable icecc checking, for distributed compilation")
 if (ENABLE_ICECC)
diff --git a/sources/pyside6/cmake/PySideHelpers.cmake b/sources/pyside6/cmake/PySideHelpers.cmake
index 31a1d97f3..01c438107 100644
--- a/sources/pyside6/cmake/PySideHelpers.cmake
+++ b/sources/pyside6/cmake/PySideHelpers.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 function(pyside_internal_detect_if_cross_building)
     if(CMAKE_CROSSCOMPILING OR QFP_SHIBOKEN_HOST_PATH)
         set(is_cross_build TRUE)
@@ -83,6 +86,7 @@ endmacro()
 macro(collect_optional_modules)
     # Collect all optional modules.
     set(ALL_OPTIONAL_MODULES
+        DBus
         Designer
         Xml
         Help Multimedia
@@ -92,12 +96,14 @@ macro(collect_optional_modules)
         Pdf
         PdfWidgets
         Positioning
+        Location
         NetworkAuth
         Nfc
         Qml
         Quick
         Quick3D
         QuickControls2
+        QuickTest
         QuickWidgets
         RemoteObjects
         Scxml
@@ -111,6 +117,7 @@ macro(collect_optional_modules)
         Svg
         SvgWidgets
         DataVisualization
+        Graphs
         Bluetooth)
     find_package(Qt${QT_MAJOR_VERSION}UiTools)
     if(Qt${QT_MAJOR_VERSION}UiTools_FOUND)
@@ -122,12 +129,7 @@ macro(collect_optional_modules)
         list(APPEND ALL_OPTIONAL_MODULES AxContainer)
     endif()
     list(APPEND ALL_OPTIONAL_MODULES WebChannel WebEngineCore WebEngineWidgets
-         WebEngineQuick WebSockets)
-    if(NOT WIN32)
-        # FIXME: Move to global once DELETE define clash is resolved.
-        list(APPEND ALL_OPTIONAL_MODULES HttpServer)
-        list(APPEND ALL_OPTIONAL_MODULES DBus)
-    endif()
+         WebEngineQuick WebSockets HttpServer)
     list(APPEND ALL_OPTIONAL_MODULES 3DCore 3DRender 3DInput 3DLogic 3DAnimation 3DExtras)
 endmacro()
 
@@ -136,13 +138,18 @@ macro(check_os)
     set(ENABLE_MAC "0")
     set(ENABLE_WIN "0")
 
-    if(CMAKE_HOST_APPLE)
-        set(ENABLE_MAC "1")
-    elseif(CMAKE_HOST_WIN32)
-        set(ENABLE_WIN "1")
-        set(ENABLE_UNIX "0")
-    elseif(NOT CMAKE_HOST_UNIX)
-        message(FATAL_ERROR "OS not supported")
+    # check if Android, if so, set ENABLE_UNIX=1
+    # this is needed to avoid including the wrapper specific to macOS when building for Android
+    # from a macOS host
+    if(NOT CMAKE_SYSTEM_NAME STREQUAL "Android")
+        if(CMAKE_HOST_APPLE)
+            set(ENABLE_MAC "1")
+        elseif(CMAKE_HOST_WIN32)
+            set(ENABLE_WIN "1")
+            set(ENABLE_UNIX "0")
+        elseif(NOT CMAKE_HOST_UNIX)
+            message(FATAL_ERROR "OS not supported")
+        endif()
     endif()
 endmacro()
 
diff --git a/sources/pyside6/cmake/PySideSetup.cmake b/sources/pyside6/cmake/PySideSetup.cmake
index a4ec74d44..038dc1642 100644
--- a/sources/pyside6/cmake/PySideSetup.cmake
+++ b/sources/pyside6/cmake/PySideSetup.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 # Don't ignore targets that do not exist, inside add_dependencies calls.
 cmake_policy(SET CMP0046 NEW)
 
@@ -40,6 +43,10 @@ pyside_internal_set_up_extra_dependency_paths()
 pyside_internal_find_host_shiboken_tools()
 find_package(Shiboken6 6 CONFIG REQUIRED)
 
+if(is_pyside6_superproject_build)
+    shiboken_find_required_python()
+endif()
+
 set(BINDING_API_MAJOR_VERSION "${pyside_MAJOR_VERSION}")
 set(BINDING_API_MINOR_VERSION "${pyside_MINOR_VERSION}")
 set(BINDING_API_MICRO_VERSION "${pyside_MICRO_VERSION}")
@@ -48,7 +55,7 @@ set(BINDING_API_PRE_RELEASE_VERSION "${pyside_PRE_RELEASE_VERSION}")
 
 # Detect if the Python interpreter is actually PyPy
 execute_process(
-    COMMAND ${PYTHON_EXECUTABLE} -c "if True:
+    COMMAND ${Python_EXECUTABLE} -c "if True:
         pypy_version = ''
         import sys
         if hasattr(sys, 'pypy_version_info'):
@@ -215,11 +222,16 @@ if(NOT PYTHON_SITE_PACKAGES)
     shiboken_internal_set_python_site_packages()
 endif()
 
-set(GENERATOR_EXTRA_FLAGS --generator-set=shiboken
-                          --enable-parent-ctor-heuristic
-                          --enable-pyside-extensions
-                          --enable-return-value-heuristic
-                          --use-isnull-as-nb_nonzero)
+shiboken_get_debug_level(debug_level)
+
+set(GENERATOR_EXTRA_FLAGS
+    ${SHIBOKEN_GENERATOR_EXTRA_FLAGS}
+    ${debug_level}
+    --generator-set=shiboken
+    --enable-parent-ctor-heuristic
+    --enable-pyside-extensions
+    --enable-return-value-heuristic
+    --use-isnull-as-nb-bool)
 use_protected_as_public_hack()
 
 # Build with Address sanitizer enabled if requested. This may break things, so use at your own risk.
diff --git a/sources/pyside6/cmake_uninstall.cmake b/sources/pyside6/cmake_uninstall.cmake
index df95fb9d8..4031b4e1a 100644
--- a/sources/pyside6/cmake_uninstall.cmake
+++ b/sources/pyside6/cmake_uninstall.cmake
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
   MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
 ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
diff --git a/sources/pyside6/doc/CMakeLists.txt b/sources/pyside6/doc/CMakeLists.txt
index bc3d17eba..83583756f 100644
--- a/sources/pyside6/doc/CMakeLists.txt
+++ b/sources/pyside6/doc/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 cmake_minimum_required(VERSION 3.18)
 cmake_policy(VERSION 3.18)
 
@@ -29,7 +32,7 @@ if(NOT CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
         return()
     endif()
 else()
-    # We are building the docs as a standalone project, likely via setup.py build_rst_docs
+    # We are building the docs as a standalone project, likely via setup.py build_base_docs
     # command. Perform stricter sanity checks.
     if(NOT SPHINX_BUILD)
         message(FATAL_ERROR "sphinx-build command not found. Please set the SPHINX_BUILD variable.")
@@ -48,6 +51,10 @@ else()
 endif()
 
 set(DOC_DATA_DIR "${CMAKE_CURRENT_BINARY_DIR}/qdoc-output")
+# Directory for sphinx-generated files to build the HTML website. If changed,
+# update "build_scripts/main.py" in "PysideBaseDocs" class at line:
+# self.sphinx_src = self.out_dir / "base".
+set(DOC_BASE_DIR "base")
 
 set(ENV_INHERITANCE_FILE "${CMAKE_CURRENT_BINARY_DIR}/inheritance.json")
 
@@ -57,10 +64,9 @@ set(TS_ROOT "${ROOT}/PySide6")
 file(REMOVE ${CMAKE_CURRENT_LIST_DIR}/pyside.qdocconf ${CMAKE_CURRENT_LIST_DIR}/pyside.qdocconf.in)
 
 # We need to find the interpreter when running this only
-# for a rst_build_docs case, and not a full doc build
+# for the 'build_base_docs' case, and not a full doc build
 if (NOT FULLDOCSBUILD)
     find_package(Python COMPONENTS Interpreter)
-    set(PYTHON_EXECUTABLE ${Python_EXECUTABLE})
 endif()
 
 if (QT_SRC_DIR)
@@ -72,7 +78,7 @@ endif()
 if(PYSIDE_IS_CROSS_BUILD)
     set(python_executable "${QFP_PYTHON_HOST_PATH}")
 else()
-    set(python_executable "${PYTHON_EXECUTABLE}")
+    set(python_executable "${Python_EXECUTABLE}")
 endif()
 
 set(TOOLS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../tools")
@@ -80,7 +86,7 @@ set(TOOLS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../tools")
 if (FULLDOCSBUILD)
     # Fetch and transform the snippets from Qt
     set(SNIPPETS_TOOL "${TOOLS_DIR}/snippets_translate/main.py")
-    set(SNIPPETS_TARGET ${CMAKE_CURRENT_BINARY_DIR}/rst/codesnippets)
+    set(SNIPPETS_TARGET ${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/codesnippets)
 
     # Note QT_SRC_DIR points to 'qtbase',
     # so we use the general SRC directory to copy all the other snippets
@@ -93,8 +99,8 @@ if (FULLDOCSBUILD)
 endif()
 
 # Generate example gallery
-set(EXAMPLE_TOOL_TARGET "${CMAKE_CURRENT_BINARY_DIR}/rst/examples")
-set(EXAMPLE_TOOL_OPTIONS --target "${EXAMPLE_TOOL_TARGET}")
+set(EXAMPLE_TOOL_TARGET "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/examples")
+set(EXAMPLE_TOOL_OPTIONS --target "${EXAMPLE_TOOL_TARGET}" --qt-src-dir "${QT_SRC_DIR}")
 if (QUIET_BUILD)
     list(APPEND EXAMPLE_TOOL_OPTIONS "-q")
 endif()
@@ -131,7 +137,7 @@ if (FULLDOCSBUILD)
     file(WRITE ${global_typesystem} "${typeSystemDocXmlContents}")
 
     execute_process(
-      COMMAND ${PYTHON_EXECUTABLE} "${TOOLS_DIR}/doc_modules.py"
+      COMMAND ${Python_EXECUTABLE} "${TOOLS_DIR}/doc_modules.py"
               -t "${global_typesystem}" -g "${global_header}" -d "${config_docconf}"
               "${QT_INCLUDE_DIR}" "${SUPPORTED_QT_VERSION}"
       OUTPUT_VARIABLE ALL_DOC_MODULES
@@ -149,7 +155,13 @@ if (FULLDOCSBUILD)
         endif()
     endforeach()
 
+    # There is no binding for the qtdoc repository, but it has some relevant documents.
+    set(qtdoc_doc_conf "qtmodules/pyside-qtdoc.qdocconf")
+    configure_file("${qtdoc_doc_conf}.in" "${CMAKE_CURRENT_LIST_DIR}/${qtdoc_doc_conf}" @ONLY)
+    file(APPEND "pyside.qdocconf.in" "\@CMAKE_CURRENT_LIST_DIR\@/${qtdoc_doc_conf}\n")
+
     configure_file("pyside.qdocconf.in" "pyside.qdocconf" @ONLY)
+    configure_file("qdoc_spawner.py.in" "qdoc_spawner.py" @ONLY)
 
 
     set(QDOC_TYPESYSTEM_PATH "${pyside6_SOURCE_DIR}${PATH_SEP}${pyside6_BINARY_DIR}")
@@ -164,20 +176,25 @@ if (FULLDOCSBUILD)
     add_custom_target(qdoc DEPENDS "${DOC_DATA_DIR}/webxml/qtcore-index.webxml")
 
     add_custom_command(OUTPUT "${DOC_DATA_DIR}/webxml/qtcore-index.webxml"
-                       # Use dummy Qt version information, QDoc needs it but has no effect on WebXML output
-                       COMMAND ${CMAKE_COMMAND} -E env BUILDDIR=${CMAKE_CURRENT_LIST_DIR}/src QT_INSTALL_DOCS=${QT_SRC_DIR}/doc
-                       QT_VERSION=${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}.${QT_VERSION_PATCH}
-                       QT_VER=${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}
-                       QT_VERSION_TAG=${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}.${QT_VERSION_PATCH}
-                       "${qdoc_binary}" pyside.qdocconf -single-exec
-                           -installdir ${DOC_DATA_DIR} -outputdir ${DOC_DATA_DIR}
+                        Use dummy Qt version information, QDoc needs it but has no effect on WebXML output
+                       COMMAND ${CMAKE_COMMAND} -E env ${python_executable} qdoc_spawner.py
+                           --qt=${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}.${QT_VERSION_PATCH}
+                           --doc-data-dir=${DOC_DATA_DIR}
+                           --qdoc-binary=${qdoc_binary}
+                           --build-dir=${CMAKE_CURRENT_LIST_DIR}/src
+                           --qt-install-docs=${QT_SRC_DIR}/doc
+                           --parallel="auto"
+                           --verbose
                        COMMENT "Running qdoc against Qt source code...")
 endif()
 
+# Avoid using 'auto' for '-j' option as it could lead to
+# crash on some systems due to out-of-memory situation. Instead
+# use a no. less than 8.
 add_custom_target(apidoc
                   COMMAND ${CMAKE_COMMAND} -E env INHERITANCE_FILE=${ENV_INHERITANCE_FILE}
                           ${SHIBOKEN_PYTHON_INTERPRETER} ${SPHINX_BUILD} -b ${DOC_OUTPUT_FORMAT}
-                          -j auto ${CMAKE_CURRENT_BINARY_DIR}/rst html
+                          -j 6 ${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR} html
                   COMMENT "Generating PySide htmls..."
                  )
 
@@ -190,6 +207,7 @@ if(DOC_OUTPUT_FORMAT STREQUAL "html")
                     ${CMAKE_CURRENT_BINARY_DIR}/../../shiboken6/doc/html
                     ${CMAKE_CURRENT_BINARY_DIR}/html/shiboken6
             COMMENT "Copying Shiboken docs..."
+            DEPENDS "${DOC_DATA_DIR}/webxml/qtcore-index.webxml"
             VERBATIM)
 else()
     if(qhelpgenerator_binary)
@@ -201,6 +219,7 @@ else()
                 COMMAND ${python_executable} ${PATCH_QHP_SCRIPT} -p -v pyside6 ${QHP_FILE}
                 COMMAND "${qhelpgenerator_binary}" ${QHP_FILE}
                 COMMENT "Generating QCH from a QHP file..."
+                DEPENDS "${DOC_DATA_DIR}/webxml/qtcore-index.webxml"
                 VERBATIM
         )
     else()
@@ -209,14 +228,14 @@ else()
 endif()
 
 # create conf.py based on conf.py.in
-configure_file("conf.py.in" "rst/conf.py" @ONLY)
+configure_file("conf.py.in" "${DOC_BASE_DIR}/conf.py" @ONLY)
 
-set(CODE_SNIPPET_ROOT "${CMAKE_CURRENT_BINARY_DIR}/rst/codesnippets")
+set(CODE_SNIPPET_ROOT "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/codesnippets")
 
 if (FULLDOCSBUILD)
 shiboken_get_tool_shell_wrapper(shiboken tool_wrapper)
 
-add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/rst/PySide6/QtCore/index.rst"
+add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/PySide6/QtCore/index.rst"
                    COMMAND
                        ${tool_wrapper}
                        $<TARGET_FILE:Shiboken6::shiboken6>
@@ -228,26 +247,26 @@ add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/rst/PySide6/QtCore/index.
                        --typesystem-paths="${QDOC_TYPESYSTEM_PATH}"
                        --library-source-dir=${QT_SRC_DIR}
                        --documentation-data-dir=${DOC_DATA_DIR}/webxml
-                       --output-directory=${CMAKE_CURRENT_BINARY_DIR}/rst
+                       --output-directory=${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}
                        --documentation-code-snippets-dir=${CODE_SNIPPET_ROOT}
                        --snippets-path-rewrite=${QT_ROOT_PATH}:${CODE_SNIPPET_ROOT}
-                       --documentation-extra-sections-dir=${CMAKE_CURRENT_BINARY_DIR}/rst/extras
-                       --additional-documentation=${CMAKE_CURRENT_BINARY_DIR}/rst/additionaldocs.lst
+                       --documentation-extra-sections-dir=${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/extras
+                       --additional-documentation=${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/additionaldocs.lst
                        --inheritance-file=${ENV_INHERITANCE_FILE}
                        ${global_typesystem}
                    WORKING_DIRECTORY ${${module}_SOURCE_DIR}
                    COMMENT "Running generator to generate documentation...")
 endif()
 
-add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/rst/extras"
-                   COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/rst
+add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/extras"
+                   COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}
                    COMMENT "Copying docs...")
 
 add_custom_target("doc_copy"
-                  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/rst/extras")
+                  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/extras")
 
 add_custom_target("docrsts"
-                  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/rst/PySide6/QtCore/index.rst")
+                  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/PySide6/QtCore/index.rst")
 
 set(LIBEXEC_PATH "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_LIBEXECS}")
 add_custom_target("licensedocrsts"
@@ -255,7 +274,7 @@ add_custom_target("licensedocrsts"
             ${CMAKE_CURRENT_LIST_DIR}/qtattributionsscannertorst.py
             -l "${LIBEXEC_PATH}"
             ${CMAKE_CURRENT_LIST_DIR}/../../..
-            ${CMAKE_CURRENT_BINARY_DIR}/rst/licenses.rst
+            ${CMAKE_CURRENT_BINARY_DIR}/${DOC_BASE_DIR}/licenses.rst
     COMMENT "Creating 3rdparty license documentation..."
 )
 
diff --git a/sources/pyside6/doc/PySide6/QtAsyncio/index.rst b/sources/pyside6/doc/PySide6/QtAsyncio/index.rst
new file mode 100644
index 000000000..326f6efcc
--- /dev/null
+++ b/sources/pyside6/doc/PySide6/QtAsyncio/index.rst
@@ -0,0 +1,150 @@
+.. module:: PySide6.QtAsyncio
+
+PySide6.QtAsyncio
+*****************
+
+.. note:: This module is currently in technical preview.
+
+The Qt Asyncio module is a pure Python module that allows programs to be
+written that use Qt's API in conjunction with `asyncio
+<https://docs.python.org/3/library/asyncio.html>`_. asyncio is a popular
+Python library for asynchronous programming. It is used in particular
+for programs that need to handle many I/O operations from many sources,
+such as web servers. More generally, it allows developers to work with
+`couroutines <https://docs.python.org/3/library/asyncio-task.html#coroutine>`_.
+Coroutines can be imagined as "asynchronous functions". In contrast to
+Qt's signals and slot mechanism, this allows for asynchronous programs
+that are closer in program flow to synchronous programs, as programs no
+longer have to be imagined as a series of callbacks. Instead, coroutines
+transparently resume and yield at designated spots.
+
+Consider the following simple coroutine defined with the ``async``
+keyword in front of its definition:
+
+::
+
+    async def do_something():
+        result = await do_something_asynchronously()
+        print(result)
+
+``do_something_asynchronously()`` is a coroutine itself, e.g., an
+I/O-heavy operation that would normally block the execution flow in a
+synchronous program. Instead, the ``await`` keyword is used to wait for
+the result, at which point ``do_something()`` yields and the program
+flow transparently switches to the next asynchronous task. When the
+result becomes available, the program flow is able to switch back to the
+``do_something()`` coroutine, which then resumes and prints the result.
+
+The asyncio API
+^^^^^^^^^^^^^^^
+
+asyncio and Qt are both based on an event loop. asyncio provides an API
+to replace its default event loop with a custom implementation.
+**QtAsyncio** provides such an implementation that uses Qt's event loop,
+allowing Qt and asyncio to be used together.
+
+We consider that this API consists of two levels:
+
+1.  Fundamental infrastructure for event loops and asynchronous
+    operations, including `futures
+    <https://docs.python.org/3/library/asyncio-future.html#asyncio.Future>`_,
+    `tasks <https://docs.python.org/3/library/asyncio-task.html#asyncio.Task>`_,
+    `handles <https://docs.python.org/3/library/asyncio-eventloop.html#callback-handles>`_,
+    executors, and event loop management functions (see below).
+2.  A user-facing API for use in applications, including transports and
+    protocols, network connections, servers, sockets, signals,
+    subprocesses.
+
+**QtAsyncio** currently covers the first level. This includes the
+following functions, for which the API is identical with QtAsyncio as
+with asyncio:
+
+* `run_until_complete() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.run_until_complete>`_
+* `run_forever() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.run_forever>`_
+* `stop() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.stop>`_
+* `is_running() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.is_running>`_
+* `is_closed() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.is_closed>`_
+* `close() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.close>`_
+* `shutdown_asyncgens() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.shutdown_asyncgens>`_
+* `shutdown_default_executor() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.shutdown_default_executor>`_
+* `call_soon() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_soon>`_
+* `call_soon_threadsafe() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_soon_threadsafe>`_
+* `call_later() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_later>`_
+* `call_at() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_at>`_
+* `time() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.time>`_
+* `create_future() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.create_future>`_
+* `create_task() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.create_task>`_
+* `set_task_factory() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.set_task_factory>`_
+* `get_task_factory() <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.get_task_factory>`_
+
+Also included is the ability to
+`run synchronous code in an executor <https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.run_in_executor>`_
+(``ThreadPoolExecutor``).
+
+Get started with QtAsyncio
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To write a program with **QtAsyncio**, first import the module, e.g.:
+
+::
+
+    import PySide6.QtAsyncio as QtAsyncio
+
+**QtAsyncio** provides a function ``run()`` that can be used to run a
+specific coroutine until it is complete, or to start the Qt & asyncio
+event loop plainly. The former case makes sense if the program flow
+starts with said coroutine, the latter case makes sense if a coroutine
+is enqueued later in the program flow, e.g., after pressing a button in
+the UI.
+
+::
+
+    QtAsyncio.run()
+
+(see the `asyncio "minimal" example <https://doc.qt.io/qtforpython-6/examples/example_async_minimal.html>`_
+for an instance of this usage) or
+
+::
+
+    QtAsyncio.run(my_coroutine())
+
+(see the `asyncio "Eratosthenes" example <https://doc.qt.io/qtforpython-6/examples/example_async_eratosthenes.html>`_)
+or
+
+::
+
+    QtAsyncio.run(my_coroutine(), keep_running=False)
+
+to run the coroutine and then stop the event loop upon its completion.
+This latter case behaves identically to ``asyncio.run(my_coroutine())``.
+
+An additional optional argument ``quit_qapp`` can be passed to ``run()``
+to configure whether the QCoreApplication at the core of QtAsyncio
+should be shut down when asyncio finishes. A special case where one
+would want to disable this is test suites that want to reuse a single
+QCoreApplication instance across all unit tests, which would fail if
+this instance is shut down every time. The default is ``True``.
+
+Note that this argument is orthogonal to the ``keep_running`` argument.
+``keep_running`` determines if **asyncio** should keep running after the
+coroutine has finished, while ``quit_qapp`` determines if the
+QCoreApplication should be shut down after asyncio has finished. It is
+possible for asyncio to finish while the QCoreApplication is kept alive.
+
+An argument ``handle_sigint`` determines whether QtAsyncio should handle
+SIGINT (Ctrl+C) and shut down the event loop when it is received. The
+default is ``False``. Set this to ``True`` if you want QtAsyncio to take
+care of handling SIGINT instead of your program.
+
+Coroutines explained
+^^^^^^^^^^^^^^^^^^^^
+
+Coroutines are functions that can be paused (yield) and resumed. Behind
+this simple concept lies a complex mechanism that is abstracted by the
+asynchronous framework. This talk presents a diagram that attempts to
+illustrate the flow of a coroutine from the moment it's provided to the
+async framework until it's completed.
+
+.. image:: https://img.youtube.com/vi/XuqdTvisqkQ/mqdefault.jpg
+    :alt: Asynchronous programming with asyncio and Qt
+    :target: https://www.youtube.com/watch?v=XuqdTvisqkQ
diff --git a/sources/pyside6/doc/README.md b/sources/pyside6/doc/README.md
deleted file mode 100644
index 88bf3a64d..000000000
--- a/sources/pyside6/doc/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# Recreating the module descriptions after a Qt major version change
-
-The source tree contains .rst files containing the module description in
-doc/extras (named for example "QtCore.rst"). They are extracted/adapted from
-the C++ module descriptions. If there is no module description file, shiboken
-will extract the module description from the webxml files generated by qdoc.
-This ends up in the build directory under doc/rst/PySide6/<module>/index.rst.
-It can be used as a starting point for a module description file. C++
-specific information like build instructions should be removed.
-
-The descriptions may link to tutorials which can be added to additionaldocs.lst
-for webxml extraction.
-
-# Maintaining additionaldocs.lst
-
-The file is a list of additional documentation files. These are basically Qt
-tutorials referenced by the documentation. They will receive some Python
-adaption by shiboken/sphinx.
-
-The list can be created by the below script and some hand-editing. It will find
-almost all documents. Quite a number of them might be unreferenced, but there
-is no good way of filtering for this.
-
-    for F in *.webxml
-    do
-        echo "$F" | egrep '(-index)|(-module)|(-qmlmodule)\.webxml$' > /dev/null
-        if [ $? -ne 0 ]
-        then
-            if fgrep '<para>' "$F" > /dev/null # Exclude reference only
-            then
-                egrep "(<class )|(<namespace )" $F > /dev/null || echo $F
-            fi
-        fi
-    done
diff --git a/sources/pyside6/doc/_static/css/qt_style.css b/sources/pyside6/doc/_static/css/qt_style.css
index 4b9b17fe7..08c4646c6 100644
--- a/sources/pyside6/doc/_static/css/qt_style.css
+++ b/sources/pyside6/doc/_static/css/qt_style.css
@@ -1,39 +1,15 @@
-.btn-qt:hover,
-.btn-qt:active,
-.btn-qt:focus,
-.btn-qt.active {
-  background: #41cd52;
-  color: #fff !important;
-  border-color: #fff;
+.text-center {
+  text-align: center !important;
 }
 
-.btn-link {
-  color: #41cd52 !important;
-}
-
-.btn-link:hover {
-  color: #222840 !important;
-  text-decoration: underline;
-}
-
-/* Using !important is not recommended, but out CSS is being added
- * to the pages before the bootstrap ones, so we cannot override them
- * without using it */
-.btn-qt {
-  color: #41cd52 !important;
-  border-color: #41cd52 !important;
-  font-weight: bold !important;
-}
-.card-img-top-main {
+.text-center img {
     padding-top: 10px;
     height: 70px !important;
 }
 
-.card-img-top {
-  object-fit: contain;
-  height: 120px;
-  padding-top: 20px;
-  transform: scale(1.3, 1.3);
+.cover-img img {
+  object-fit: cover;
+  height: 50%;
 }
 
 /* Tables */
@@ -78,3 +54,47 @@ table.docutils td ul > li {
   position:relative;
   overflow:visible
 }
+
+/* We cannot put a :download:`....` command inside
+ * a sphinx-design button, so we add some properties from the button
+ * to the download class to mimic it */
+code.download {
+  text-align: center;
+  color: var(--color-brand-primary);
+  display: block;
+  border-color: transparent;
+  background-color: transparent;
+  border: 1px solid var(--color-brand-primary) !important;
+  border-radius: 0.25rem;
+  font-size: 1rem;
+  font-weight: 400;
+  vertical-align: middle;
+  padding: .375rem .75rem;
+  user-select: none;
+  line-height: 1.5;
+  transition: color .15s ease-in-out, background-color .15s ease-in-out, border-color .15s ease-in-out, box-shadow .15s ease-in-out;
+}
+
+code.download:hover {
+  color: white;
+  background-color: var(--color-brand-primary);
+  border-color: var(--color-brand-primary);
+  text-decoration: none;
+  padding: .375rem .75rem;
+}
+
+dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple):first-child > dt {
+  font-size: +2.25rem;
+  font-weight: 700;
+  color: #ff00dd;
+}
+
+.theme-toggle svg{
+  width: +1.25rem;
+  height: +2.25rem;
+}
+
+.sd-card-title code span {
+  font-size: +1rem;
+  color: var(--color-brand-primary);
+}
diff --git a/sources/pyside6/doc/_static/qtforpython.ico b/sources/pyside6/doc/_static/qtforpython.ico
new file mode 100644
index 000000000..2f4d9e9de
--- /dev/null
+++ b/sources/pyside6/doc/_static/qtforpython.ico
diff --git a/sources/pyside6/doc/_static/qtforpython.png b/sources/pyside6/doc/_static/qtforpython.png
index 3a2f2bd17..33e971022 100644
--- a/sources/pyside6/doc/_static/qtforpython.png
+++ b/sources/pyside6/doc/_static/qtforpython.png
diff --git a/sources/pyside6/doc/_tags/android.rst b/sources/pyside6/doc/_tags/android.rst
new file mode 100644
index 000000000..08a30fc0f
--- /dev/null
+++ b/sources/pyside6/doc/_tags/android.rst
@@ -0,0 +1,21 @@
+My tags: Android
+################
+
+.. toctree::
+    :maxdepth: 1
+    :caption: With this tag
+
+    ../examples/example_bluetooth_heartrate_game.rst
+    ../examples/example_bluetooth_lowenergyscanner.rst
+    ../examples/example_location_mapviewer.rst
+    ../examples/example_multimedia_audiooutput.rst
+    ../examples/example_multimedia_audiosource.rst
+    ../examples/example_multimedia_camera.rst
+    ../examples/example_qml_editingmodel.rst
+    ../examples/example_qml_usingmodel.rst
+    ../examples/example_quick_models_objectlistmodel.rst
+    ../examples/example_quick_models_stringlistmodel.rst
+    ../examples/example_quick_painteditem.rst
+    ../examples/example_quickcontrols_contactslist.rst
+    ../examples/example_quickcontrols_gallery.rst
+    ../examples/example_widgets_widgets_digitalclock.rst
diff --git a/sources/pyside6/doc/_tags/tagsindex.rst b/sources/pyside6/doc/_tags/tagsindex.rst
new file mode 100644
index 000000000..be29337ec
--- /dev/null
+++ b/sources/pyside6/doc/_tags/tagsindex.rst
@@ -0,0 +1,12 @@
+:orphan:
+
+.. _tagoverview:
+
+Tags overview
+#############
+
+.. toctree::
+    :caption: Tags
+    :maxdepth: 1
+
+    Android (14) <android.rst>
diff --git a/sources/pyside6/doc/_themes/pysidedocs/static/pyside.css b/sources/pyside6/doc/_themes/pysidedocs/static/pyside.css
deleted file mode 100644
index 5b4cb9d1f..000000000
--- a/sources/pyside6/doc/_themes/pysidedocs/static/pyside.css
+++ /dev/null
@@ -1,2198 +0,0 @@
-@import url('cookie-confirm.css') screen;
-
-/* -- admonitions -- */
-
-div.admonition {
-    margin: 1.5em 0 1.5em;
-    padding: 0;
-}
-
-div.admonition dt {
-    font-weight: bold;
-}
-
-div.admonition dl {
-    margin-bottom: 0;
-}
-
-p.admonition-title {
-    margin: 0px 10px 5px 0px;
-    font-weight: bold;
-}
-
-div.admonition code {
-    font-family: inherit;
-}
-
-p.admonition-title + p {
-    padding-left: 1em;
-}
-
-div.admonition a:after {
-    content: ', ';
-}
-
-div.admonition a:last-child:after {
-    content: '';
-}
-
-.body {
-    width: 100%;
-  background-color: #00FF00;
-  clear: both;
-  display:inline-block;
-  background-color:#fff;
-  padding: 25px 35px 20px 30px;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box;
-}
-.bodywrapper {
-    position: relative;
-    /*background-color: #0000ff;*/
-}
-.bodywrapper .admonition p.admonition-title {
-  margin-bottom:5px
-}
-
-.bodywrapper .admonition p {
-  margin:0
-}
-
-div.body p.centered {
-    text-align: center;
-    margin-top: 25px;
-}
-
-div.warning, div.seealso, div.note, div.important {
-    padding: 6px 0px 6px 10px;
-    border: none;
-}
-
-div.warning {
-    background-color: #ffe4e4;
-}
-
-div.important {
-    background-color: #fef9f3;
-    border-left: 5px solid #feeec8;
-}
-
-div.seealso {
-    background-color: #fff2d6;
-}
-
-div.note {
-    background-color: #c5d3f4;
-    border-left: 5px solid #7899f4;
-}
-
-table.docutils {
-    margin-right: auto;
-    margin-bottom: 10px;
-    border: none;
-    width: initial;
-}
-
-table.docutils.colwidths-given td {
-    float: none;
-}
-
-table.docutils th,
-table.docutils td {
-    padding-left:0;
-    border: none;
-}
-
-table.docutils td ul {
-    margin:0
-}
-
-table.docutils td ul > li {
-    margin: 0 0 0.5em;
-}
-h2 em {
-    float: right;
-    font-size: 10px;
-    position: relative;
-    top: -20px;
-}
-
-.document {
-    padding-bottom: 20px;
-}
-
-.documentwrapper {
-    margin-left: 255px;
-    position: relative;
-}
-@media screen and (max-width: 700px) {
-    .documentwrapper {
-        clear: both;
-        margin-left: 0px;
-        position: relative;
-    }
-}
-
-.body blockquote {
-    border: none;
-    padding-left: 0;
-    margin-bottom: 1.5em;
-}
-
-.sphinxsidebar {
-    float: left;
-    width: 186px;
-    padding: 15px;
-    text-align: left;
-    background-color: #fff;
-    clear: both;
-}
-
-.sphinxsidebar ul {
-    padding: 0px;
-    margin: 0px;
-    list-style-position: inside;
-}
-
-.sphinxsidebar > ul {
-    padding: 0px;
-    margin: 0px;
-}
-
-.sphinxsidebar ul li li {
-    margin-left: 10px;
-    padding: 0px;
-    font-size: 0.95em;
-}
-
-.sphinxsidebar ul a,
-.sphinxsidebar p.topless a {
-    word-break: break-word;
-}
-
-.sphinxsidebar h3, .sphinxsidebar h3 a {
-    color: #333;
-}
-
-.sphinxsidebar p.topless {
-    margin: 1em 0 1em;
-}
-
-.pysidetoc ul {
-    list-style: none;
-    padding: 0px;
-    margin: 0px;
-}
-
-.pysidetoc em {
-    font-style: normal;
-}
-
-.pysidetoc strong {
-    display: block;
-    padding: 5px;
-    margin: 0 10px 10px 0;
-    border: none;
-    background-color: #e2e2e2;
-}
-
-.section .docutils.container td {
-    float:left;
-}
-
-.hide {
-    display: none;
-}
-
-/* copy-notice */
-.document + p {
-    margin-left: 255px;
-    width: 70%;
-    font-size: 0.75em;
-    margin: 0 35px 15px 280px;
-}
-
-#searchbox {
-    border-top: 1px solid #989898;
-    padding-top: 10px;
-    margin-left: -10px;
-    margin-right: -10px;
-    padding-left: 10px;
-    padding-right: 10px;
-}
-
-#search_button {
-    border: 1px solid #3A393A;
-    background-color: #3A393A;
-    color: white;
-    cursor: pointer;
-    -moz-border-radius: 5px;
-    -webkit-border-radius: 5px;
-    -khtml-border-radius: 5px;
-
-}
-
-form {
-    margin: 0px;
-    padding: 0px;
-}
-
-#searchbox h3 {
-    padding: 10px 0 0 0;
-    margin-bottom: 5px;
-}
-
-/* search field */
-form #q {
-    width: 136px;
-    /*     height: 22px; */
-    /* border: none; */
-    margin: 0px;
-    -moz-border-radius: 5px;
-    -webkit-border-radius: 5px;
-    -khtml-border-radius: 5px;
-    margin-top: 2px;
-    padding: 4px;
-    line-height: 22px;
-}
-
-#search-results h2 {
-    display: none;
-}
-
-#search-results h2 {
-    display: none;
-}
-
-#search-results ul.search {
-    margin: 0px;
-    padding: 0px;
-}
-
-ul.search div.context {
-    padding-left: 40px;
-}
-
-#installation td {
-    text-align: center;
-    font-weight: bold;
-}
-
-em {
-    color: inherit;
-    font-style:italic;
-}
-
-/********   REL bar     *********/
-
-.related {
-    display: inline;
-}
-
-.related h3 {
-    display: none;
-}
-
-.align-center {
-    text-align: center;
-}
-
-.contentstable {
-    width: 100%;
-}
-
-.contentstable td {
-    padding-left: 30px;
-    vertical-align: top;
-}
-
-p.biglink a {
-    font-size: 20px;
-}
-
-dt:target, .highlight {
-    background-color: #fbe54e;
-}
-
-p.highlight-link {
-    margin-top: 10px;
-    font-size: 0.8em;
-}
-
-#synopsis table, table.field-list {
-    margin: 1em 0 1em 0;
-}
-
-table.field-list tr {
-    text-align: left;
-}
-
-tt.descname {
-    font-size: 120%;
-    font-weight: bold;
-}
-
-#functions ul, #virtual-functions ul, #slots ul, #signals ul, #static-functions ul {
-    margin: 0;
-    padding: 6px;
-    border: 1px solid #ddd;
-    border-radius: 0;
-    background-color: #e2e2e2;
-}
-
-#functions p, #virtual-functions p, #slots p, #signals p, #static-functions p {
-    margin: 0;
-    padding: 0;
-}
-
-#functions li, #virtual-functions li, #slots li, #signals li, #static-functions li {
-    list-style: none;
-    margin: 5px;
-    padding: 0;
-    font-size: 90%;
-}
-
-#synopsis span.pre {
-    color: #009491;
-    font-weight: bolder;
-}
-
-#detailed-description .class dt,
-#detailed-description .method dt,
-#detailed-description .staticmethod dt,
-#detailed-description .attribute dt  {
-    margin: 0px;
-    margin-bottom: 10px;
-    padding: 10px;
-    font-weight: bold;
-    background-color: #e2e2e2;
-    border: none;
-    border-radius: 0;
-}
-
-#detailed-description dd > blockquote,
-#detailed-description dd > .field-list {
-    font-family: 'Droid Sans Mono', monospace;
-    font-size: small;
-    border-left: 10px solid #e2e2e2;
-    padding-left: 10px;
-    margin-bottom: 1.5em;
-}
-
-#detailed-description dd > blockquote blockquote {
-    border: none;
-    padding: 0;
-}
-
-#detailed-description .class .field-odd,
-#detailed-description .method .field-odd,
-#detailed-description .staticmethod .field-odd,
-#detailed-description .attribute .field-odd  {
-    margin: 0;
-    padding: 1px 0 0 0;
-    background-color: #ffffff;
-
-}
-
-#detailed-description .class .field-even,
-#detailed-description .method .field-even,
-#detailed-description .staticmethod .field-even,
-#detailed-description .attribute .field-even  {
-    margin: 0;
-    padding: 1px 0 0 0;
-    background-color: #ffffff;
-}
-
-#detailed-description .class .field-odd li,
-#detailed-description .method .field-odd li,
-#detailed-description .staticmethod .field-odd li,
-#detailed-description .attribute .field-odd li {
-    list-style: none;
-    margin: 0;
-    padding: 0;
-
-}
-
-#detailed-description .class .field-even li,
-#detailed-description .method .field-even li,
-#detailed-description .staticmethod .field-even li,
-#detailed-description .attribute .field-even li {
-    list-style: none;
-    margin: 0;
-    padding: 0;
-}
-
-#detailed-description .class .field-odd p,
-#detailed-description .method .field-odd p,
-#detailed-description .staticmethod .field-odd p,
-#detailed-description .attribute .field-odd  p{
-    margin: 0;
-    margin-left: 20px;
-
-}
-
-#detailed-description .class .field-even p,
-#detailed-description .method .field-even p,
-#detailed-description .staticmethod .field-even p,
-#detailed-description .attribute .field-even p{
-    margin: 0;
-    margin-left: 20px;
-}
-
-#detailed-description .class .field-odd p:last-child,
-#detailed-description .method .field-odd p:last-child,
-#detailed-description .staticmethod .field-odd p:last-child,
-#detailed-description .attribute .field-odd  p:last-child {
-    margin-bottom: 10px;
-
-}
-
-#detailed-description .class .field-even p:last-child,
-#detailed-description .method .field-even p:last-child,
-#detailed-description .staticmethod .field-even p:last-child,
-#detailed-description .attribute .field-even p:last-child{
-    margin-bottom: 10px;
-}
-
-.document dl.attribute,
-.document dl.class,
-.document dl.method,
-.document dl.staticmethod {
-    margin-top: 2em;
-}
-
-.document dl.attribute dd,
-.document dl.class dd,
-.document dl.method dd,
-.document dl.staticmethod dd {
-    padding-left: 1em;
-}
-
-#detailed-description .attribute td:nth-child(1) {
-    font-family: 'Droid Sans Mono', monospace;
-}
-
-/* Qt theme */
-#navbar {
-  position:fixed;
-  top:0;
-  left:0;
-  z-index:100;
-  background:#fff;
-  width:100%
-}
-#navbar .container, .fixed .container {
-  max-width:1280px;
-  margin:0 auto;
-  padding:0 3.9%; /* 0? */
-  position:relative;
-  overflow:visible
-}
-#navbar .navbar-header {
-  position:relative
-}
-#menuextras li a:hover span {
-  color: #41cd52;
-}
-/* new header */
-#mm-wrap, #mm-wrap #mm-helper,
-#mm-wrap #mm-helper li.mm-item,
-#mm-wrap #mm-helper a.mm-link {
-    -moz-transition: none;
-    -o-transition: none;
-    -webkit-transition: none;
-    transition: none;
-    -webkit-border-radius: 0 0 0 0;
-    -moz-border-radius: 0 0 0 0;
-    -ms-border-radius: 0 0 0 0;
-    -o-border-radius: 0 0 0 0;
-    border-radius: 0 0 0 0;
-    -webkit-box-shadow: none;
-    -moz-box-shadow: none;
-    -ms-box-shadow: none;
-    -o-box-shadow: none;
-    box-shadow: none;
-    background: none;
-    border: 0;
-    bottom: auto;
-    box-sizing: border-box;
-    clip: auto;
-    color: #090e21;
-    display: block;
-    float: none;
-    font-family: inherit;
-    font-size: 14px;
-    height: auto;
-    left: auto;
-    line-height: 1.7;
-    list-style-type: none;
-    margin: 0;
-    min-height: 0;
-    opacity: 1;
-    outline: none;
-    overflow: visible;
-    padding: 0;
-    position: relative;
-    right: auto;
-    text-align: left;
-    text-decoration: none;
-    text-transform: none;
-    top: auto;
-    vertical-align: baseline;
-    visibility: inherit;
-    width: auto;
-}
-#mm-wrap #mm-helper {
-  visibility:visible;
-  text-align:right;
-  padding:0 0px 0 0px
-}
-#navbar #mm-wrap #mm-helper li.mm-item {
-  border-right:solid #f3f3f4 1px;
-  padding-right:30px;
-  padding-left:30px
-}
-#navbar #mm-wrap #mm-helper li.mm-item > a:hover {
-  opacity: .5
-}
-#mm-wrap #mm-helper > li.mm-item {
-  margin:0 0 0 0;
-  display:inline-block;
-  height:auto;
-  vertical-align:middle
-}
-#navbar #mm-wrap #mm-helper li.mm-item:nth-child(3) {
-  border-right:0
-}
-#mm-wrap #mm-helper a.mm-link {
-  cursor: pointer
-}
-@media (max-width: 1279px) {
-  #navbar {
-    padding:0;
-    position:relative;
-  }
-  #navbar .container {
-    max-width:100%
-  }
-  .container {
-    padding:0 2%
-  }
-  .sphinxsidebar {
-    top: 16px !important;
-  }
-}
-#navbar .navbar-oneQt {
-  display:inline;
-  float:left;
-  width:31px;
-  color:#41cd52
-}
-#navbar .navbar-oneQt:before {
-  content:attr(data-icon);
-  position:absolute;
-  top:14px;
-  left:0;
-  color:#41cd52;
-  font-family:'Qt Icons';
-  line-height:1;
-  font-size:40px;
-  transition:all 0.3s ease-in-out;
-}
-#mm-wrap {
-  clear:both;
-  background:rgba(255, 255, 255, 0.1);
-  -webkit-border-radius:0px 0px 0px 0px;
-  -moz-border-radius:0px 0px 0px 0px;
-  -ms-border-radius:0px 0px 0px 0px;
-  -o-border-radius:0px 0px 0px 0px;
-  border-radius:0px 0px 0px 0px
-}
-#mm-wrap #mm-helper li.mm-item:last-child a {
-  background:transparent url("icon_avatar.png") 50% 50% no-repeat !important;
-  background-size:24px !important;
-  width:24px !important;
-  height:24px !important;
-}
-#navbar #mm-wrap #mm-helper li.mm-item > a {
-  opacity:1;
-  -webkit-transition:all 0.3s ease-in-out;
-  -moz-transition:all 0.3s ease-in-out;
-  -ms-transition:all 0.3s ease-in-out;
-  -o-transition:all 0.3s ease-in-out;
-  transition:all 0.3s ease-in-out;
-}
-#mm-wrap #mm-helper > li.mm-item > a.mm-link {
-  border-top:0px solid #fff;
-  border-left:0px solid #fff;
-  border-right:0px solid #fff;
-  border-bottom:0px solid #fff;
-  outline:none;
-  text-decoration:none;
-  padding:0 0 0 0;
-  line-height:70px;
-  font-weight:normal;
-  height:70px;
-  vertical-align:baseline;
-  text-align:left;
-  width:auto;
-  display:block;
-  color:#090e21;
-  text-transform:none;
-  text-decoration:none;
-  background:rgba(0, 0, 0, 0);
-  -webkit-border-radius:0px 0px 0px 0px;
-  -moz-border-radius:0px 0px 0px 0px;
-  -ms-border-radius:0px 0px 0px 0px;
-  -o-border-radius:0px 0px 0px 0px;
-  border-radius:0px 0px 0px 0px;
-  font-family:inherit;
-  font-size:14px;
-}
-/* end new header */
-@media (min-width: 1320px) {
-  .body .flowListDiv dl.flowList {
-    -webkit-column-count:3;
-    -moz-column-count:3;
-    column-count:3
-  }
-}
-@media (min-width: 1120px) {
-  #navbar.fixed {
-    -moz-box-shadow:0px 0px 8px rgba(0,0,0,0.23);
-    -webkit-box-shadow:0px 0px 8px rgba(0,0,0,0.23);
-    box-shadow:0px 0px 8px rgba(0,0,0,0.23)
-  }
-  #navbar.fixed #mm-wrap #mm-helper > li.mm-item > a.mm-link {
-    height:50px;
-    line-height:50px
-  }
-  #navbar.fixed .navbar-oneQt:before {
-    font-size:35px;
-    top:7px
-  }
-
-  .flowListDiv dl.flowList {
-    -webkit-column-count:2;
-    -moz-column-count:2;
-    column-count:2
-  }
-}
-@media (max-width: 1120px) {
-  #navbar {
-    padding:0;
-    position:relative
-  }
-  #navbar .navbar-oneQt:before {
-    left:10px
-  }
-  #navbar .container {
-    max-width:100%;
-    padding:0
-  }
-  #footerbar .container {
-    padding:0
-  }
-  body .main {
-    margin-top:0px
-  }
-  #footerbar .footer-main .footer-nav {
-    padding:3.9% 0 3.9% 3%;
-    border-bottom:1px solid #413d3b;
-    float:none;
-    display:block;
-    width:auto
-  }
-  #footerbar .footer-main .theqtcompany {
-    clear:both;
-    float:left;
-    margin:30px 0 8px 3%
-  }
-  #footerbar .footer-main .footer-social {
-    float:left;
-    padding:50px 0px 0px 3%
-  }
-  #footerbar #menu-footer-submenu {
-    clear:both;
-    float:none;
-    display:block;
-    padding:0px 0px 3.9% 3%
-  }
-  ul#menu-footer-submenu {
-    margin-left: 0
-  }
-}
-.cookies_yum {
-  background-color:#cecfd5;
-  display:none;
-  width:100%
-}
-.cookies_yum img {
-  width:25px;
-  top:6px;
-  display:inline-block;
-  position:absolute;
-  left:13px
-}
-.cookies_yum div {
-  margin:0 auto;
-  max-width:1280px;
-  min-height:30px;
-  padding:6px 0px 6px 0px;
-  position:relative
-}
-.cookies_yum p {
-  color:#09102b;
-  margin:0px;
-  font-size:0.79em;
-  display:inline-block;
-  line-height:1.2;
-  padding:0 30px 0 50px
-}
-.cookies_yum p a {
-  white-space:nowrap
-}
-.cookies_yum a:hover {
-  color:#46a2da
-}
-.cookies_yum .close {
-  width:15px;
-  height:15px;
-  background-image:url("cookiebar-x.png");
-  background-size:15px 30px;
-  background-position:top left;
-  cursor:pointer;
-  top:13px;
-  right:13px;
-  position:absolute;
-  transition:none
-}
-.cookies_yum .close:hover {
-  background-position:bottom left
-}
-#sidebar-toggle,#toc-toggle {
-  width:24px;
-  height:14px;
-  background-size:24px 28px;
-  cursor:pointer;
-  background-image:url("list_expand.png");
-  float:right
-}
-#sidebar-toggle.collapsed,
-#toc-toggle.collapsed {
-  background-position:bottom left
-}
-#sidebar-content > h2 {
-  display:none
-}
-#footerbar {
-  background:#222840;
-  color:#fff;
-  font-size: 0.9em;
-}
-#footerbar.fixed {
-  bottom:0;
-  left:0;
-  width:100%
-}
-#footerbar .footer-nav {
-  display:inline;
-  float:left
-}
-#footerbar .footer-main .footer-nav li {
-  float:left;
-  margin-right:1em
-}
-#footerbar .footer-main .footer-nav li a {
-  display:block;
-  padding:30px 0 10px 0;
-  line-height:20px;
-  height:20px;
-  color:#fff;
-  font-weight: 600;
-}
-#footerbar .footer-main .footer-nav li a:hover,#footerbar .footer-main .footer-nav li.current-menu-item a {
-  color:#eee
-}
-#footerbar .footer-main .footer-nav .sub-menu {
-  margin-left:0;
-  margin-bottom:0
-}
-#footerbar .footer-main .footer-nav .sub-menu li {
-  float:none;
-  width: 100%;
-}
-#footerbar .footer-main .footer-nav .sub-menu ul {
-  padding:1px 1em;
-  font-size:0.786em;
-  line-height:8px;
-  float:none;
-  color:#5d5b59;
-  margin-bottom:0
-}
-#footerbar .footer-main .footer-nav .sub-menu li a {
-  padding:2px 0;
-  font-size:1em;
-  float:none;
-  color:#cecfd5;
-  font-weight: 400;
-}
-#footerbar .footer-main .footer-nav .sub-menu li a:hover,#footerbar .footer-main .footer-nav .sub-menu li.current-menu-item a {
-  color:#eee
-}
-#footerbar .theqtcompany {
-  background:url("theqtcompany.png") no-repeat;
-  background-size:100%;
-  width:215px;
-  height:68px;
-  display:inline;
-  float:right;
-  margin:29px 0 28px 30px
-}
-#footerbar .footer-social {
-  display:inline;
-  float:right;
-  width:164px
-}
-#footerbar .footer-main .footer-social>div {
-  margin-left:0.1em;
-  margin-bottom:10px
-}
-#footerbar .disclaimer {
-  font-size:0.786em;
-  line-height:2.73;
-  color:#868584;
-  padding-top:20px;
-  padding-bottom:0.5%
-}
-#footerbar .disclaimer a {
-  color:#bdbebf
-}
-#footerbar .disclaimer a:hover {
-  color:#d6d6d6
-}
-#footerbar .disclaimer ul li {
-  float:left;
-  vertical-align:middle;
-  margin-left:1.18em
-}
-#footerbar .disclaimer ul li:first-child {
-  margin-left:0
-}
-#footerbar .disclaimer ul.lang-selector a {
-  color:#506a34;
-  color:rgba(128,195,66,0.3)
-}
-#footerbar .disclaimer ul.lang-selector a:hover {
-  color:#80c342;
-  color:rgba(128,195,66,0.7)
-}
-#menu-footer-menu, #menu-footer-menu ul {
-  margin-left:0;
-  margin-bottom:0
-}
-@font-face {
-  font-family: 'Titillium Web';
-  font-style: normal;
-  font-weight: 400;
-  src: url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.eot");
-  /* IE9 Compat Modes */
-  src: local("Titillium Web"), local("TitilliumWeb-Regular"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.eot?#iefix") format("embedded-opentype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.woff2") format("woff2"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.woff") format("woff"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.ttf") format("truetype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-regular.svg#TitilliumWeb") format("svg");
-  /* Legacy iOS */
-}
-/* titillium-web-italic - latin_latin-ext */
-@font-face {
-  font-family: 'Titillium Web';
-  font-style: italic;
-  font-weight: 400;
-  src: url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.eot");
-  /* IE9 Compat Modes */
-  src: local("Titillium WebItalic"), local("TitilliumWeb-Italic"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.eot?#iefix") format("embedded-opentype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.woff2") format("woff2"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.woff") format("woff"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.ttf") format("truetype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-italic.svg#TitilliumWeb") format("svg");
-  /* Legacy iOS */
-}
-/* titillium-web-600 - latin_latin-ext */
-@font-face {
-  font-family: 'Titillium Web';
-  font-style: normal;
-  font-weight: 600;
-  src: url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.eot");
-  /* IE9 Compat Modes */
-  src: local("Titillium WebSemiBold"), local("TitilliumWeb-SemiBold"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.eot?#iefix") format("embedded-opentype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.woff2") format("woff2"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.woff") format("woff"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.ttf") format("truetype"), url("//d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/fonts/titillium-web-v4-latin_latin-ext-600.svg#TitilliumWeb") format("svg");
-  /* Legacy iOS */
-}
-@font-face {
-  font-family: 'Droid Sans Mono', monospace;
-  font-style:normal;
-  font-weight:400;
-  src:local("Droid Sans Mono"),local("DroidSansMono"),url(//fonts.gstatic.com/s/droidsansmono/v7/ns-m2xQYezAtqh7ai59hJUYuTAAIFFn5GTWtryCmBQ4.woff) format("woff")
-}
-@font-face {
-  font-family:'Qt Icons';
-  src:url("../style/icomoon.eot?-tgjuoj");
-  src:url("../style/icomoon.eot?#iefix-tgjuoj") format("embedded-opentype"),url("../style/icomoon.woff?-tgjuoj") format("woff"),url("../style/icomoon.ttf?-tgjuoj") format("truetype"),url("../style/icomoon.svg?-tgjuoj#icomoon") format("svg");
-  font-weight:normal;
-  font-style:normal
-}
-@font-face {
-  font-family:'social-icons';
-  src:url("../style/social-icons.eot?54625607");
-  src:url("../style/social-icons.eot?54625607#iefix") format("embedded-opentype"),
-      url("../style/social-icons.woff?54625607") format("woff");
-  font-weight:normal;
-  font-style:normal
-}
-.clearfix:before,.clearfix:after {
-  content:" ";
-  display:table
-}
-.clearfix:after {
-  clear:both
-}
-.clearfix {
-  *zoom:1
-}
-.clearfix .right {
-  float:right
-}
-html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video {
-  margin:0;
-  padding:0;
-  border:0;
-  font-size:100%;
-  line-height: 1.4;
-}
-html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,caption,article,aside,canvas,details,embed,figure,figcaption,footer,header,hgroup,menu,nav,output,ruby,section,summary,time,mark,audio,video {
-  vertical-align:baseline
-}
-h1,h2,h3,h4,h5,h6 {
-  font-weight:300
-}
-.body h2,.body h3,.body h4,.body h5,.body h6 {
-  margin:1.5em 0 0.75em
-}
-.body h1 {
-  margin-bottom:0.75em;
-  font-size:2.25em;
-}
-.body h3.fn,.body h3.flags {
-  color:#26282a;
-  font-size:1.46em;
-  padding:15px 0 15px 0;
-  border-bottom:2px #eee solid;
-  word-wrap:break-word
-}
-.body .fngroup {
-  border-bottom:2px #eee solid;
-  padding-bottom:15px;
-  margin-bottom:1.5em
-}
-.body .fngroup h3.fngroupitem {
-  margin:0;
-  padding-bottom:0;
-  border:none
-}
-.body h3.fn .name,
-.body h3 span.type,
-.qmlname span.name {
-  font-weight: 400
-}
-.qmlname {
-  font-size:1.46em
-}
-.qmlproto table {
-  border:none;
-  border-bottom:2px #eee solid
-}
-.qmlproto table p {
-  max-width:100%
-}
-.qmlproto table tr {
-  background-color:#fff
-}
-.qmlname td, .qmlname th {
-  border:none;
-  text-align:left;
-  padding:5px 0 0 0
-}
-.qmlreadonly,.qmldefault {
-  padding:0 5px 0 5px;
-  font-size:0.75em;
-  background-color:#eee;
-  float:right
-}
-.qmlreadonly {
-  color:#414141
-}
-.qmldefault {
-  color:#D14141
-}
-.rightAlign {
-  padding:3px 5px 3px 10px;
-  text-align:right
-}
-.centerAlign.functionIndex {
-  text-align:center;
-  font-size:150%;
-  margin-bottom: 1em
-}
-article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section {
-  display:block
-}
-body {
-  line-height:1;
-  font-family:'Titillium Web', Arial, Helvetica, sans-serif;
-  font-weight:400;
-  transition-duration:1s;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  font-size: 16px;
-  background-color:#f3f3f4;
-  color:#404244;
-}
-ol,ul {
-  list-style-type: square;
-  color: #17a81a;
-}
-.body ol,.body ul {
-  margin-top:0.75em;
-  margin-left:20px
-}
-.bodywrapper ol>li {
-  list-style-type:decimal;
-  margin-left:15px
-}
-.bodywrapper ol.a >li {
-  list-style-type:lower-alpha;
-}
-.bodywrapper ol.A >li {
-  list-style-type:upper-alpha;
-}
-.bodywrapper ol.i >li {
-  list-style-type:lower-roman;
-}
-.bodywrapper ol.I >li {
-  list-style-type:upper-roman;
-}
-.body li p {
-  margin-top:1em
-}
-blockquote,q {
-  quotes:none;
-  border-left:10px solid #ddd;
-  padding-left:10px
-}
-blockquote:before,blockquote:after,q:before,q:after {
-  content:'';
-  content:none;
-  width:100%
-}
-table {
-  border-collapse:collapse;
-  border-spacing:0;
-  margin-bottom:5px;
-  width:100%
-}
-a {
-  color:#17a81a;
-  text-decoration:none;
-  transition-duration:0.3s
-}
-a:hover {
-  color:#17a81a
-}
-.main,#footerbar>div {
-  max-width:1280px;
-  width:95%;
-  margin:0 auto
-}
-.main {
-  margin-top:80px
-}
-@media (max-width: 1120px) {
-  .main,.navbar-header,#footerbar>div {
-    width: 100%;
-    margin: 0;
-  }
-  .main .main-rounded {
-    padding: 0 15px;
-  }
-}
-.main_index {
-  background-color:#fff
-}
-.sectionlist {
-  margin-bottom:2em
-}
-[class*="col-"] {
-  letter-spacing:normal
-}
-.landing,.main_index .row {
-  letter-spacing:-0.31em
-}
-.main_index .row>div {
-  letter-spacing:normal
-}
-.col-1 {
-  clear: both;
-  display:inline-block;
-  background-color:#fff;
-  padding: 25px 35px 20px 30px;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box;
-}
-.col-1 h2 {
-  font-size:1.8em;
-  font-weight:300;
-  line-height:1.1;
-  margin-bottom:0.83em;
-  margin-top:1em
-}
-.icons1of3 img {
-  display:inline-block;
-  float:left;
-  margin-right:0.75em;
-  margin-top:-5px;
-  width:2.75em
-}
-div.multi-column {
-  position:relative
-}
-div.multi-column div {
-  display:-moz-inline-box;
-  display:inline-block;
-  vertical-align:top;
-  margin-top:1em;
-  margin-right:2em;
-  width:16em
-}
-.sidebar {
-  display:block;
-  position:relative;
-  position:sticky;
-  float:left;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box;
-  width:20%;
-  padding-right:20px
-}
-.sidebar li {
-  text-overflow:ellipsis;
-  overflow:hidden
-}
-.toc,.sectionlist {
-  padding:25px;
-  background-color:#fff;
-  margin-bottom:1.25em
-}
-.sidebar .sectionlist p {
-  margin-bottom:0
-}
-.sectionlist.promo {
-  padding:0;
-  background-color:#f3f3f4
-}
-.sidebar-content:empty {
-  display:none;
-  visibility:hidden
-}
-.col-2 h2,.toc h3,.sidebar-content h2,
-.sidebar-content h3,.sectionlist h2,
-.sphinxsidebar {
-  position: -webkit-sticky;
-  position: sticky;
-  top: 0px;
-  width: 200px;
-  overflow: scroll;
-  overflow-x: hidden;
-  overflow-y: hidden;
-}
-.sphinxsidebar h3 {
-  font-weight: bold;
-  margin-bottom:1em;
-}
-
-/* On screens that are less than 700px wide, make the sidebar into a topbar */
-@media screen and (max-width: 700px) {
-  .sphinxsidebar {
-    top: 64px;
-    /*overflow-x: hidden;
-    overflow-y: hidden;*/
-    width: 100%;
-    height: auto;
-    position: relative;
-  }
-  /*.sidebar a {float: left;}*/
-  div.content {margin-left: 0;}
-}
-
-/* On screens that are less than 400px, display the bar vertically, instead of horizontally
-@media screen and (max-width: 400px) {
-  .sphinxsidebar a {
-    text-align: center;
-    float: none;
-  }
-}
-*/
-
-.toc h3 a {
-  color:#404244
-}
-.title {
-  font-size:2.25em;
-  font-weight:300;
-  letter-spacing:-1px;
-  line-height:1.15em;
-  margin-bottom:0.5em;
-  word-wrap:break-word
-}
-.navigationbar,col-1 h2 {
-  font-size:0.85em
-}
-.navigationbar h1 {
-  font-size:2.5em;
-  margin-bottom:0.85em;
-  margin-top:0.85em
-}
-.navigationbar li {
-  display:inline-block;
-  margin-right:5px;
-  position:relative;
-  padding-right:10px;
-  color:#585a5c
-}
-.navigationbar ul:last-of-type li a {
-  color:#404244
-}
-.sectionlist li, .sphinxsidebar li {
-  padding-bottom: 10px;
-  line-height: 1.75em;
-}
-.col-1 ul {
-  margin-bottom:1.56em
-}
-.bodywrapper li {
-  margin-top:0.5em;
-  line-height:1.25em
-}
-.bodywrapper li.level2 {
-  margin-left:10px;
-  margin-top:0.4em;
-  font-size:0.9375em;
-}
-.bodywrapper p,
-.bodywrapper dd {
-  line-height:1.25em;
-  margin:1em 0 1em;
-  color:#404244
-}
-.bodywrapper b {
-  font-weight:600
-}
-.body ul,.body ol {
-  /* margin-bottom:1.5em */
-}
-.bodywrapper ul ul {
-  margin-top:0.5em
-}
-.bodywrapper .naviNextPrevious {
-  margin-top:25px;
-  max-width:100%;
-  position: relative;
-}
-.naviNextPrevious.headerNavi,
-p.naviNextPrevious + p {
-  display:none
-}
-.nextPage {
-  float:right
-}
-.prevPage:before {
-  content:"< "
-}
-.nextPage:after {
-  content:" >"
-}
-.navigationbar li a {
-  color:#404244
-}
-.navigationbar li:after {
-  color:#404244;
-  content:"›";
-  display:inline-block;
-  font-size:1.5em;
-  line-height:1;
-  position:absolute;
-  right:-2px;
-  top:-4px
-}
-.sub-navigation {
-  margin-top:10px
-}
-.navigationbar li:last-child:after,.sub-navigation li:after {
-  content:none
-}
-.navigationbar {
-  margin-bottom:10px;
-  line-height:1em
-}
-#buildversion {
-  margin-bottom:10px;
-  font-style:italic;
-  font-size:small;
-  float:right
-}
-.copy-notice {
-  width:75%;
-  font-size:0.75em;
-  margin:20px 35px 0 10px;
-  line-height:1.75em;
-  float:right;
-  color:#585a5c
-}
-.copy-notice.index {
-  margin-top:10px;
-  float:none
-}
-li a.active {
-  color:#585a5c
-}
-.flowList {
-  padding:25px
-}
-.flowListDiv dl {
-  -webkit-column-count:1;
-  -moz-column-count:1;
-  column-count:1
-}
-.flowList dd {
-  display:inline-block;
-  margin-left:10px;
-  width:90%;
-  line-height:1.15em;
-  overflow-x:hidden;
-  text-overflow:ellipsis
-}
-.alphaChar {
-  font-size:2em;
-  position:absolute
-}
-.flowList.odd {
-  background-color:#f9f9f9
-}
-.body ul>li,.doc-column ul>li {
-  list-style-image:url("list_arrow.png");
-  margin-left:15px;
-  color:#404244;
-  margin-top:0.65em;
-  line-height:1em
-}
-.bodywrapper table p {
-  margin:0px;
-  padding:0px
-}
-.bodywrapper table p {
-  margin:0px;
-  padding:0px;
-  min-height:1.25em
-}
-.bodywrapper .qmldoc {
-  margin-top:0.75em;
-}
-.body h2 {
-  margin-top: 1.5em;
-  font-size:1.75em
-}
-.body h3 {
-  font-size:1.35em
-}
-.body h4 {
-  font-size:1.15em
-}
-.body p img {
-  margin-top:0.75em;
-  max-width:100%
-}
-.body .border img {
-  box-shadow:3px 3px 8px 3px rgba(200,200,200,0.5)
-}
-.body .border .player {
-  box-shadow:3px 3px 8px 3px rgba(200,200,200,0.5)
-}
-.body p.figCaption {
-  transform:translateY(-30px);
-  color:#606366;
-  font-size:95%;
-  margin-left:3px;
-  font-style:italic
-}
-.body table {
-  width:initial;
-  vertical-align:initial
-}
-table .odd {
-  background-color:#f9f9f9
-}
-table thead {
-  text-align:left;
-  padding-left:20px
-}
-table,table td,table th {
-  border:1px solid #eee
-}
-table td,table th {
-  padding:5px 20px;
-  line-height:1.3
-}
-.body .fixed table td {
-  min-width:50%;
-  width:50%
-}
-table.alignedsummary,table.propsummary {
-  width:initial
-}
-table.valuelist td.tblval {
-  font-size:0.75em
-}
-div.main_index .row {
-  border-bottom:10px solid #f3f3f4
-}
-div.main_index .row {
-  position:relative
-}
-div.main_index .row>div {
-  display:inline-block;
-  width:50%;
-  vertical-align:top;
-  padding:2em 3em;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box
-}
-div.main_index h2 {
-  font-size:2.1875em;
-  margin-bottom:1em
-}
-#search_bar {
-  width:40%;
-  float:right
-}
-div.main_index .row:after {
-  content:"";
-  position:absolute;
-  top:0;
-  right:50%;
-  height:100%;
-  width:10px;
-  background-color:#f3f3f4
-}
-div.table {
-  overflow-x:auto
-}
-.body tr > td > pre {
-  font-size:0.75em
-}
-p.qt_commercial {
-  border:3px solid #5caa15;
-  margin:0 auto;
-  padding:15px;
-  width:28%;
-  text-align:center;
-  clear:both
-}
-h1.qt_commercial {
-  padding:20px;
-  background-color:#5caa15;
-  display:inline;
-  float:right;
-  font-size:1.25em;
-  line-height:1.25em;
-  height:1.25em;
-  color:#fff
-}
-div.qt_commercial {
-  border-top:5px solid #5caa15;
-  margin-bottom:50px
-}
-div.pre {
-  position:relative;
-  height:auto
-}
-pre, .LegaleseLeft {
-  background-color:#222840;
-  color:#fff;
-  display:block;
-  font-family: 'Droid Sans Mono', monospace;
-  line-height:1.5;
-  overflow-x:auto;
-  margin-bottom:25px;
-  padding:25px;
-  margin-top:0.75em;
-  font-size: .8em;
-}
-.bodywrapper .LegaleseLeft p {
-  color:#fff;
-  white-space: pre-wrap;
-}
-pre .str,code .str {
-  color:#aaaaaa
-}
-pre .kwd,code .kwd {
-  color:#ffff55
-}
-pre .com,code .com {
-  color:#55ffff
-}
-pre .typ,code .typ {
-  color:#4f9d08
-}
-pre a .typ,code a .typ {
-  color:#21be2b
-}
-pre .lit,code .lit {
-  color:#ff55ff
-}
-pre .pun,code .pun {
-  color:#fff
-}
-pre .pln,code .pln {
-  color:#fff
-}
-@media print {
-  pre {
-    background-color:#eee !important
-  }
-  pre .str,code .str {
-    color:#060
-  }
-  pre .kwd,code .kwd{
-    color:#006;
-    font-weight:bold
-  }
-  pre .com,code .com {
-    color:#600
-  }
-  pre .typ,code .typ {
-    color:#404;
-    font-weight:bold
-  }
-  pre .lit,code .lit {
-    color:#044
-  }
-  pre .pun,code .pun {
-    color:#440
-  }
-  pre .pln,code .pln {
-    color:#000
-  }
-}
-pre.wrap {
-  white-space:pre-wrap
-}
-pre span.wrap {
-  display:none;
-  background:url("wrap.png") no-repeat;
-  right:0;
-  top:2px;
-  position:absolute;
-  width:20px;
-  height:14px;
-  margin:4px;
-  opacity:0.65
-}
-
-span.pre {
-    color: black;
-    font-family: monospace;
-    font-weight: normal;
-    background-color: #eaeaea;
-    padding: 2px 4px;
-    color: black;
-    border-radius: 2px;
-}
-
-span.wrap:hover {
-  opacity:1
-}
-span.wrap:active {
-  opacity:0.75
-}
-.copy_text {
-  background-color:#46a2da;
-  color:#fff;
-  border:2px solid #46a2da;
-  padding:10px 16px;
-  margin-left:-10px;
-  margin-top:-50px;
-  position:absolute;
-  opacity:0;
-  cursor:pointer;
-  float:right
-}
-.copy_text:hover {
-  background-color:#fff;
-  color:#46a2da
-}
-code,.codelike {
-  font-family: 'Droid Sans Mono', monospace;
-}
-#detailed-description .function dt > code,
-#detailed-description .function dt > em {
-  font-weight:bold
-}
-h3.fn code {
-  font-size:0.75em;
-  float:right;
-  background-color:#eee;
-  padding:3px;
-  margin: 3px 0 0 20px
-}
-pre:hover>.copy_text {
-  display:inline-block;
-  opacity:1;
-  transition:0.5s ease
-}
-#main_title_bar {
-  background:url("pyside-logo.png") no-repeat;
-  background-size:100%;
-  width:366px;
-  height:86px;
-  margin:15px 0 15px 0
-}
-#main_title_bar h1 {
-  visibility:hidden
-}
-#main_title_bar .search_bar {
-  letter-spacing:normal;
-  width:50%;
-  display:inline-block;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box;
-  vertical-align:middle
-}
-#main_title_bar h1 {
-  letter-spacing:normal;
-  display:inline-block;
-  -webkit-box-sizing:border-box;
-  -moz-box-sizing:border-box;
-  -ms-box-sizing:border-box;
-  box-sizing:border-box;
-  vertical-align:middle
-}
-#main_title_bar .search_bar * {
-  letter-spacing:normal;
-  padding:0;
-  margin:0;
-  border:none
-}
-#sidebar-toggle,#toc-toggle {
-  display:none
-}
-@media (max-width: 980px) {
-  body {
-    font-size:calc-em(14px)
-  }
-  #main_title_bar>h1,#main_title_bar .search_bar {
-    width:100%
-  }
-  #main_title_bar .search_bar {
-    margin-bottom:15px
-  }
-  .main {
-    margin-top:0px
-  }
-  .main_index .row {
-    border:none !important
-  }
-  .title {
-    font-size:1.5em;
-    font-weight:400;
-    word-wrap:break-word
-  }
-  .col-1,.body,.naviNextPrevious,.sidebar {
-    padding:10px
-  }
-  .sidebar {
-    position:relative;
-    padding-top:0
-  }
-  .search .sidebar {
-    display:none;
-    visibility:hidden
-  }
-  .col-2 h2,.toc h3,.sidebar-content h2,.sidebar-content h3,.sectionlist h2 {
-    text-align:center;
-    margin-bottom:5px
-  }
-  div.main_index .row:after {
-    content:none
-  }
-  div.main_index .row>div {
-    display:block !important;
-    width:100%;
-    padding:15px;
-    margin:0
-  }
-  .body,.sidebar,.col-1 {
-    width:100%
-  }
-  .sidebar-content,.col-2,.toc {
-    background-color:#fff;
-    margin-bottom:1em;
-    padding:20px
-  }
-  #sidebar-toggle,#toc-toggle {
-    display:block
-  }
-  #sidebar-toggle.collapsed + h2 {
-    display:block
-  }
-  .bodywrapper p {
-    margin-bottom:1em;
-    max-width:100%
-  }
-  table td,table th {
-    padding:5px 5px
-  }
-  .sectionlist {
-    padding:0
-  }
-  .sidebar > .sectionlist {
-    padding:20px
-  }
-  .sectionlist.promo {
-    max-width:46%;
-    margin:0 auto 1em auto;
-    float:left;
-    padding:0 2%
-  }
-  .sidebar .sidebar-content {
-    clear:both
-  }
-  .copy-notice {
-    float:none;
-    width:initial
-  }
-}
-[id]:target > *:first-child,
-dt[id]:target {
-  -webkit-animation:highlighter 3s;
-  animation:highlighter 3s
-}
-@-webkit-keyframes highlighter {
-  25% {
-    background-color:#d1e8f6;
-    color:#444
-  }
-  75% {
-    background-color:#d1e8f6;
-    color:#444
-  }
-}
-@keyframes highlighter {
-  25% {
-    background-color:#d1e8f6;
-    color:#444
-  }
-  75% {
-    background-color:#d1e8f6;
-    color:#444
-  }
-}
-@-webkit-keyframes copypaste {
-  25% {
-    opacity:1
-  }
-  100% {
-    border-radius:10px;
-    margin-top:-50px;
-    opacity:1
-  }
-}
-@keyframes copypaste {
-  25% {
-    opacity:1
-  }
-  100% {
-    border-radius:10px;
-    margin-top:-50px;
-    opacity:1
-  }
-}
-#footer {
-  clear:both
-}
-.footer-social i {
-  font-family: "social-icons";
-  font-style: normal;
-  font-size:150%;
-  margin: .55em;
-  color: #cecfd5
-}
-.footer-social i:hover {
-  color: #eee
-}
-.footer-social .icon-twitter:before {
-  content: '\f099'
-}
-.footer-social .icon-facebook:before {
-  content: '\f09a'
-}
-.footer-social .icon-youtube:before {
-  content: '\f16a'
-}
-.menuextraslanguages {
-  display:none;
-  visibility:hidden
-}
-form.gsc-search-box {
-  font-size: 25px !important;
-  margin-top: 0 !important;
-  margin-right: 0 !important;
-  margin-bottom: 4px !important;
-  margin-left: 0 !important;
-  width: 102.5% !important;
-}
-table.gsc-search-box {
-  border-style: none !important;
-  border-width: 0 !important;
-  border-spacing: 0 0 !important;
-  width: 100% !important;
-  margin-bottom: 2px !important;
-}
-
-table.gsc-search-box td {
-  vertical-align: middle !important;
-}
-
-table.gsc-search-box td.gsc-input {
-  padding-right: 0px !important;
-}
-table.gsc-search-box td.gsc-input input {
-  background-position: 10px center !important;
-}
-
-td.gsc-search-button {
-  width: 1% !important;
-}
-
-td.gsc-clear-button {
-  width: 14px !important;
-  visibility:hidden !important;
-  display:none !important;
-}
-table.gsc-branding td,
-table.gsc-branding {
-  margin: 0 0 0 0 !important;
-  padding: 0 0 0 0 !important;
-  border: none !important;
-}
-
-table.gsc-branding {
-  border-style: none !important;
-  border-width: 0 !important;
-  border-spacing: 0 0 !important;
-  width: 100% !important;
-}
-
-.gsc-branding-text {
-  color: #676767 !important;
-}
-
-td.gsc-branding-text {
-  vertical-align: top !important;
-}
-td.gsc-branding-text div.gsc-branding-text {
-  padding-bottom: 2px !important;
-  text-align: right !important;
-  font-size: 11px !important;
-  margin-right: 2px !important;
-}
-
-td.gsc-branding-img {
-  width: 65px !important;
-  vertical-align: bottom !important;
-}
-
-img.gsc-branding-img {
-  padding-top: 1px !important;
-  margin: 0 0 0 0 !important;
-  padding-right: 0 !important;
-  padding-left: 0 !important;
-  padding-bottom: 0 !important;
-  border: none !important;
-  display: inline !important;
-}
-
-input.gsc-search-button {
-  background-color: white !important;
-  height: 35px !important;
-  width: 25px !important;
-  color: transparent !important;
-  background-image: url("doc_search.png") !important;
-  background-size: 25px auto;
-  background-position: 0px 5px;
-  background-repeat: no-repeat;
-  margin-left: -43px !important;
-  overflow: hidden;
-  min-width: 20px !important;
-}
-
-input.gsc-search-button:hover {
-  cursor: pointer;
-}
-
-input.gsc-search-button:focus {
-  outline: none;
-  box-shadow: none;
-}
-
-.gsc-search-box-tools .gsc-clear-button {
-  display: none !important;
-  visibility: none !important;
-}
-
-.gsc-overflow-hidden {
-  overflow: hidden !important;
-}
-
-input.gsc-input {
-  background-color: #fff !important;
-  border: 1px solid #d6d6d6 !important;
-  box-sizing: border-box !important;
-  -moz-box-sizing: border-box !important;
-  color: #868482 !important;
-  outline: 0 none !important;
-  padding: 9px 10px 10px !important;
-  transition: color 0.5s ease 0s, box-shadow 0.5s ease 0s, background-color 0.5s ease 0s !important;
-}
-
-input {
-  font-family: 'Titillium Web', Arial, Helvetica, sans-serif !important;
-  line-height: 1.5 !important;
-  font-weight: 300 !important;
-  vertical-align:middle
-}
-
-input:focus {
-  border-color: #46a2da;
-  box-shadow: 0 0 5px #46a2da;
-  color: #000;
-}
-
-.animation {
-  width: 100%;
-  border-style: none;
-  border-width: 0
-}
-
-.player {
-  width: auto;
-  position: relative;
-  display: table;
-  margin-bottom:1.5em;
-}
-
-.playcontrol {
-  display: none;
-  background: url("play_icon.svg") no-repeat center,
-    linear-gradient(
-      rgba(0,0,0,0.15), rgba(0,0,0,0.15)
-    );
-  background-size: 25%;
-  width: 100%;
-  height: 100%;
-  position: absolute;
-  left: 0%;
-  right: 0%;
-  top: 0%;
-  bottom: 0%;
-  margin: auto
-}
-
-/* expand/collapse code sections */
-pre input {
-  display:none;
-  visibility:hidden
-}
-pre label {
-  display:block;
-  margin:-3px 3px 0 -16px;
-  text-align:center;
-  color:#21be2b;
-  float:left;
-}
-pre label:hover {
-  color:#fff
-}
-pre label::before {
-  font-weight:600;
-  font-size:16px;
-  content:"+";
-  display:inline-block;
-  width:16px;
-  height:16px
-}
-#ec_expand {
-  height:16px;
-  overflow:hidden;
-  transition:height 0.35s;
-}
-#ec_expand::before {
-  content:"...*/";
-  color:#aaa;
-  background-color:#3a4055;
-  z-index:99 !important;
-  right:25px;
-  position:absolute
-}
-#ec_toggle:checked ~ #ec_expand {
-  height:initial
-}
-#ec_toggle:checked ~ #ec_expand::before {
-  content:""
-}
-#ec_toggle:checked ~ label::before {
-  content:"-"
-}
-
-/* permalinks */
-h1:hover > .headerlink,
-h2:hover > .plink,
-h2:hover > .headerlink,
-h3:hover > .plink,
-h3:hover > .headerlink,
-h4:hover > .plink,
-h4:hover > .headerlink,
-h5:hover > .plink,
-h5:hover > .headerlink {
-  opacity:1
-}
-a.plink, a.headerlink {
-  opacity: 0;
-  padding-left: 8px;
-  font-size: 0.8em;
-  font-weight: 600;
-  transition: opacity 180ms ease-in-out
-}
-a.plink::before {
-  content:'\00B6'
-}
-
-table.special {
-    border: 3px;
-    padding: 0px;
-    border-collapse: separate;
-    border-spacing: 20px;
-    line-height: 1.5em;
-    table-layout: fixed;
-    width: 80%;
-}
-
-.special p {
-    text-align: center;
-    color: #3a4055;
-}
-
-.special a {
-    display: block;
-    border-bottom: 0;
-    text-decoration: none;
-}
-
-.special a:hover {
-    border-bottom: 0;
-    text-decoration: none;
-}
-
-.special strong {
-    color: #17a81a;
-    font-size: 110%;
-    font-weight: normal;
-}
-
-table.special th,
-table.special td {
-    border: 1px solid #888;
-    padding-top: 14px;
-    padding-bottom: 14px;
-    padding-left: 6px;
-    padding-right: 5px;
-    border-radius: 5px;
-    -moz-border-radius: 5px;
-    -webkit-border-radius: 5px;
-    -khtml-border-radius: 5px;
-    overflow: hidden;
-}
-
-.special td:hover {
-    padding-top: 14px;
-    padding-bottom: 10px;
-    border-bottom: 4px solid #41cd52;
-    overflow: hidden;
-}
-
-.command {
-    font-family: monospace;
-    font-weight: normal;
-    background-color: #9cd1a6;
-    padding: 2px 4px;
-    color: black;
-    border-radius: 2px;
-}
-
-div.leftside {
-    width: 50%;
-    padding: 0px 50px 0px 0px;
-    float: left;
-}
-
-div.rightside {
-    margin-left: 50%;
-}
-
-.btn-qt:hover,
-.btn-qt:active,
-.btn-qt:focus,
-.btn-qt.active {
-  background: #41cd52;
-  color: #fff !important;
-  border-color: #fff;
-}
-
-.btn-link {
-  color: #41cd52 !important;
-}
-
-.btn-link:hover {
-  color: #222840 !important;
-  text-decoration: underline;
-}
-
-/* Using !important is not recommended, but out CSS is being added
- * to the pages before the bootstrap ones, so we cannot override them
- * without using it */
-.btn-qt {
-  color: #41cd52 !important;
-  border-color: #41cd52 !important;
-  font-weight: bold !important;
-}
-.card-img-top-main {
-    padding-top: 10px;
-    height: 70px !important;
-}
-
-.card-img-top {
-  object-fit: contain;
-  height: 120px;
-  padding-top: 20px;
-  transform: scale(1.3, 1.3);
-}
diff --git a/sources/pyside6/doc/_themes/pysidedocs_qthelp/static/pyside.css b/sources/pyside6/doc/_themes/pysidedocs_qthelp/static/pyside.css
index aee5e4420..94134cacf 100644
--- a/sources/pyside6/doc/_themes/pysidedocs_qthelp/static/pyside.css
+++ b/sources/pyside6/doc/_themes/pysidedocs_qthelp/static/pyside.css
@@ -466,7 +466,7 @@ tt.descname {
   position:relative
 }
 #menuextras li a:hover span {
-  color: #41cd52;
+  color: #2cde85;
 }
 /* new header */
 #mm-wrap, #mm-wrap #mm-helper,
@@ -557,14 +557,14 @@ tt.descname {
   display:inline;
   float:left;
   width:31px;
-  color:#41cd52
+  color:#2cde85
 }
 #navbar .navbar-oneQt:before {
   content:attr(data-icon);
   position:absolute;
   top:14px;
   left:0;
-  color:#41cd52;
+  color:#2cde85;
   font-family:'Qt Icons';
   line-height:1;
   font-size:40px;
@@ -1939,5 +1939,5 @@ table.special td {
 .special td:hover {
     padding-top: 2px;
     padding-bottom: 2px;
-    border-bottom: 4px solid #41cd52;
+    border-bottom: 4px solid #2cde85;
 }
diff --git a/sources/pyside6/doc/additionaldocs.lst b/sources/pyside6/doc/additionaldocs.lst
index 6d2872d7a..81da58370 100644
--- a/sources/pyside6/doc/additionaldocs.lst
+++ b/sources/pyside6/doc/additionaldocs.lst
@@ -20,7 +20,6 @@ creating-a-sensor-plugin.webxml
 custom-types.webxml
 database.webxml
 datastreamformat.webxml
-datavisualization-examples.webxml
 dbus-changes-qt6.webxml
 determining-the-default-sensor-for-a-type.webxml
 dialogs.webxml
@@ -117,7 +116,6 @@ qml-tutorial1.webxml
 qml-tutorial2.webxml
 qml-tutorial3.webxml
 qmldiskcache.webxml
-qmlexampletoggleswitch.webxml
 qmlreference.webxml
 qndeffilter-record.webxml
 qoutputrange.webxml
@@ -133,8 +131,6 @@ qsggeometry-texturedpoint2d.webxml
 qsgmaterialshader-graphicspipelinestate.webxml
 qsgmaterialtype.webxml
 qstaticplugin.webxml
-qt3d-advancedcustommaterial-example.webxml
-qt3d-audio-visualizer-qml-example.webxml
 qt3d-basicshapes-cpp-example.webxml
 qt3d-changes-qt6.webxml
 qt3d-cpp.webxml
@@ -142,15 +138,9 @@ qt3d-examples.webxml
 qt3d-multiviewport-example.webxml
 qt3d-overview.webxml
 qt3d-pbr-materials-example.webxml
-qt3d-planets-qml-example.webxml
 qt3d-qml.webxml
-qt3d-scene2d-example.webxml
-qt3d-scene3d-example.webxml
-qt3d-shadow-map-qml-example.webxml
 qt3d-simple-qml-example.webxml
 qt3d-simplecustommaterial-example.webxml
-qt3d-wave-example.webxml
-qt3d-widgets-scene3d-example.webxml
 qt3d-wireframe-example.webxml
 qt3drender-framegraph.webxml
 qt3drender-geometry.webxml
@@ -162,7 +152,6 @@ qtbluetooth-changes-qt6.webxml
 qtbluetooth-le-overview.webxml
 qtbluetooth-lowenergyscanner-example.webxml
 qtbluetooth-overview.webxml
-qtbluetooth-pingpong-example.webxml
 qtcborcommon.webxml
 qtcharts-barmodelmapper-example.webxml
 qtcharts-boxplotchart-example.webxml
@@ -170,7 +159,6 @@ qtcharts-candlestickchart-example.webxml
 qtcharts-changes-qt6.webxml
 qtcharts-customchart-example.webxml
 qtcharts-datetimeaxis-example.webxml
-qtcharts-donutchart-example.webxml
 qtcharts-examples.webxml
 qtcharts-horizontalbarchart-example.webxml
 qtcharts-horizontalpercentbarchart-example.webxml
@@ -179,28 +167,20 @@ qtcharts-legendmarkers-example.webxml
 qtcharts-multiaxis-example.webxml
 qtcharts-openglseries-example.webxml
 qtcharts-overview.webxml
-qtcharts-piechartcustomization-example.webxml
-qtcharts-piechartdrilldown-example.webxml
 qtcharts-pointsselectionandmarkers-example.webxml
 qtcharts-polarchart-example.webxml
 qtcharts-qmlaxes-example.webxml
-qtcharts-qmlchart-example.webxml
 qtcharts-qmlcustomizations-example.webxml
 qtcharts-qmlcustomlegend-example.webxml
 qtcharts-qmlf1legends-example.webxml
 qtcharts-qmloscilloscope-example.webxml
 qtcharts-qmlweather-example.webxml
 qtcharts-scatterchart-example.webxml
-qtcharts-scatterinteractions-example.webxml
 qtcharts-selectedbar-example.webxml
 qtcharts-splinechart-example.webxml
 qtcharts-stackedbarchart-example.webxml
-qtcharts-stackedbarchartdrilldown-example.webxml
 qtcharts-zoomlinechart-example.webxml
 qtconcurrent-imagescaling-example.webxml
-qtconcurrent-map-example.webxml
-qtconcurrent-progressdialog-example.webxml
-qtconcurrent-runfunction-example.webxml
 qtconcurrent-wordcount-example.webxml
 qtconcurrentfilter.webxml
 qtconcurrentmap.webxml
@@ -215,31 +195,6 @@ qtcore-threads-queuedcustomtype-example.webxml
 qtcore-threads-semaphores-example.webxml
 qtcore-threads-waitconditions-example.webxml
 qtcore-tools-contiguouscache-example.webxml
-qtcore-tools-customtype-example.webxml
-qtdatavis3d-custominput-example.webxml
-qtdatavis3d-customitems-example.webxml
-qtdatavis3d-customproxy-example.webxml
-qtdatavis3d-draggableaxes-example.webxml
-qtdatavis3d-itemmodel-example.webxml
-qtdatavis3d-qml3doscilloscope-example.webxml
-qtdatavis3d-qmlaxisdrag-example.webxml
-qtdatavis3d-qmlaxisformatter-example.webxml
-qtdatavis3d-qmlbars-example.webxml
-qtdatavis3d-qmlcustominput-example.webxml
-qtdatavis3d-qmllegend-example.webxml
-qtdatavis3d-qmlmultigraph-example.webxml
-qtdatavis3d-qmlscatter-example.webxml
-qtdatavis3d-qmlspectrogram-example.webxml
-qtdatavis3d-qmlsurface-example.webxml
-qtdatavis3d-qmlsurfacelayers-example.webxml
-qtdatavis3d-rotations-example.webxml
-qtdatavis3d-scatter-example.webxml
-qtdatavis3d-texturesurface-example.webxml
-qtdatavis3d-volumetric-example.webxml
-qtdatavisualization-data-handling.webxml
-qtdatavisualization-interacting-with-data.webxml
-qtdatavisualization-known-issues.webxml
-qtdatavisualization-overview.webxml
 qtdbus-chat-example.webxml
 qtdbus-cmake-qt-add-dbus-adaptor.webxml
 qtdbus-cmake-qt-add-dbus-interface.webxml
@@ -253,8 +208,6 @@ qtdesigner-components.webxml
 qtdesigner-containerextension-example.webxml
 qtdesigner-customwidgetplugin-example.webxml
 qtdesigner-manual.webxml
-qtdesigner-worldtimeclockbuilder-example.webxml
-qtdesigner-worldtimeclockplugin-example.webxml
 qtest-overview.webxml
 qtest-tutorial.webxml
 qtextedit-extraselection.webxml
@@ -271,18 +224,8 @@ qtjavascript.webxml
 qtmath.webxml
 qtmultimedia-apple.webxml
 qtmultimedia-changes-qt6.webxml
-qtmultimedia-multimedia-audiodevices-example.webxml
-qtmultimedia-multimedia-audiorecorder-example.webxml
-qtmultimedia-multimedia-declarative-camera-example.webxml
-qtmultimedia-multimedia-spectrum-example.webxml
-qtmultimedia-multimedia-video-mediaplayer-example.webxml
-qtmultimedia-multimedia-video-qmlvideo-example.webxml
-qtmultimedia-multimedia-video-recorder-example.webxml
-qtmultimedia-multimediawidgets-videographicsitem-example.webxml
-qtmultimedia-multimediawidgets-videowidget-example.webxml
 qtnetwork-broadcastreceiver-example.webxml
 qtnetwork-broadcastsender-example.webxml
-qtnetwork-downloadmanager-example.webxml
 qtnetwork-http-example.webxml
 qtnetwork-multicastreceiver-example.webxml
 qtnetwork-multicastsender-example.webxml
@@ -292,8 +235,6 @@ qtnetwork-securesocketclient-example.webxml
 qtnetwork-secureudpclient-example.webxml
 qtnetwork-secureudpserver-example.webxml
 qtnetwork-torrent-example.webxml
-qtnetworkauth-changes-qt6.webxml
-qtnetworkauth-twittertimeline-example.webxml
 qtnfc-annotatedurl-example.webxml
 qtnfc-changes-qt6.webxml
 qtnfc-ndefeditor-example.webxml
@@ -306,7 +247,6 @@ qtplugin.webxml
 qtpositioning-android.webxml
 qtpositioning-changes-qt6.webxml
 qtpositioning-examples.webxml
-qtpositioning-geoflickr-example.webxml
 qtpositioning-ios.webxml
 qtpositioning-logfilepositionsource-example.webxml
 qtpositioning-plugins.webxml
@@ -327,20 +267,16 @@ qtqml-javascript-imports.webxml
 qtqml-javascript-qmlglobalobject.webxml
 qtqml-javascript-resources.webxml
 qtqml-javascript-topic.webxml
-qtqml-networkaccessmanagerfactory-example.webxml
 qtqml-qml-i18n-example.webxml
-qtqml-qmlextensionplugins-example.webxml
 qtqml-syntax-basics.webxml
 qtqml-syntax-directoryimports.webxml
 qtqml-syntax-imports.webxml
 qtqml-syntax-objectattributes.webxml
 qtqml-syntax-propertybinding.webxml
-qtqml-tool-qmltc.webxml
 qtqml-tutorials-extending-qml-example.webxml
 qtqml-typesystem-basictypes.webxml
 qtqml-typesystem-objecttypes.webxml
 qtqml-typesystem-topic.webxml
-qtqml-xmlhttprequest-example.webxml
 qtquick-animation-example.webxml
 qtquick-bestpractices.webxml
 qtquick-canvas-example.webxml
@@ -350,14 +286,11 @@ qtquick-cppextensionpoints.webxml
 qtquick-customitems-dialcontrol-example.webxml
 qtquick-customitems-flipable-example.webxml
 qtquick-customitems-painteditem-example.webxml
-qtquick-customitems-scrollbar-example.webxml
-qtquick-customitems-tabwidget-example.webxml
 qtquick-draganddrop-example.webxml
 qtquick-effects-particles.webxml
 qtquick-effects-sprites.webxml
 qtquick-effects-topic.webxml
 qtquick-effects-transformations.webxml
-qtquick-externaldraganddrop-example.webxml
 qtquick-imageelements-example.webxml
 qtquick-imageprovider-example.webxml
 qtquick-imageresponseprovider-example.webxml
@@ -385,11 +318,8 @@ qtquick-positioning-righttoleft.webxml
 qtquick-positioning-topic.webxml
 qtquick-quick-accessibility-example.webxml
 qtquick-quickwidgets-quickwidget-example.webxml
-qtquick-righttoleft-example.webxml
-qtquick-scenegraph-customgeometry-example.webxml
 qtquick-scenegraph-custommaterial-example.webxml
 qtquick-scenegraph-d3d11underqml-example.webxml
-qtquick-scenegraph-fboitem-example.webxml
 qtquick-scenegraph-graph-example.webxml
 qtquick-scenegraph-materials.webxml
 qtquick-scenegraph-metaltextureimport-example.webxml
@@ -407,12 +337,8 @@ qtquick-statesanimations-topic.webxml
 qtquick-tableview-gameoflife-example.webxml
 qtquick-tableview-pixelator-example.webxml
 qtquick-text-example.webxml
-qtquick-text-validator.webxml
-qtquick-threading-example.webxml
-qtquick-threading-threadedlistmodel-example.webxml
 qtquick-tool-qmllint.webxml
 qtquick-tools-and-utilities.webxml
-qtquick-touchinteraction-example.webxml
 qtquick-tutorials-dynamicview-dynamicview1-example.webxml
 qtquick-tutorials-dynamicview-dynamicview2-example.webxml
 qtquick-tutorials-dynamicview-dynamicview3-example.webxml
@@ -437,38 +363,35 @@ qtquickcontrols-contactlist-example.webxml
 qtquickcontrols-eventcalendar-example.webxml
 qtquickcontrols-flatstyle-example.webxml
 qtquickcontrols-imagine-automotive-example.webxml
-qtquickcontrols-imagine-musicplayer-example.webxml
-qtquickcontrols-sidepanel-example.webxml
-qtquickcontrols-swipetoremove-example.webxml
 qtquickcontrols-texteditor-example.webxml
 qtquickcontrols-wearable-example.webxml
-qtquickcontrols2-basic.webxml
-qtquickcontrols2-buttons.webxml
-qtquickcontrols2-configuration.webxml
-qtquickcontrols2-containers.webxml
-qtquickcontrols2-customize.webxml
-qtquickcontrols2-delegates.webxml
-qtquickcontrols2-deployment.webxml
-qtquickcontrols2-environment.webxml
-qtquickcontrols2-examples.webxml
-qtquickcontrols2-fileselectors.webxml
-qtquickcontrols2-focus.webxml
-qtquickcontrols2-fusion.webxml
-qtquickcontrols2-gettingstarted.webxml
-qtquickcontrols2-guidelines.webxml
-qtquickcontrols2-icons.webxml
-qtquickcontrols2-imagine.webxml
-qtquickcontrols2-indicators.webxml
-qtquickcontrols2-input.webxml
-qtquickcontrols2-macos.webxml
-qtquickcontrols2-material.webxml
-qtquickcontrols2-menus.webxml
-qtquickcontrols2-navigation.webxml
-qtquickcontrols2-popups.webxml
-qtquickcontrols2-separators.webxml
-qtquickcontrols2-styles.webxml
-qtquickcontrols2-universal.webxml
-qtquickcontrols2-windows.webxml
+qtquickcontrols-basic.webxml
+qtquickcontrols-buttons.webxml
+qtquickcontrols-configuration.webxml
+qtquickcontrols-containers.webxml
+qtquickcontrols-customize.webxml
+qtquickcontrols-delegates.webxml
+qtquickcontrols-deployment.webxml
+qtquickcontrols-environment.webxml
+qtquickcontrols-examples.webxml
+qtquickcontrols-fileselectors.webxml
+qtquickcontrols-focus.webxml
+qtquickcontrols-fusion.webxml
+qtquickcontrols-gettingstarted.webxml
+qtquickcontrols-guidelines.webxml
+qtquickcontrols-icons.webxml
+qtquickcontrols-imagine.webxml
+qtquickcontrols-indicators.webxml
+qtquickcontrols-input.webxml
+qtquickcontrols-macos.webxml
+qtquickcontrols-material.webxml
+qtquickcontrols-menus.webxml
+qtquickcontrols-navigation.webxml
+qtquickcontrols-popups.webxml
+qtquickcontrols-separators.webxml
+qtquickcontrols-styles.webxml
+qtquickcontrols-universal.webxml
+qtquickcontrols-windows.webxml
 qtquicklayouts-overview.webxml
 qtremoteobjects-cmake-qt-add-repc-merged.webxml
 qtremoteobjects-cmake-qt-add-repc-replicas.webxml
@@ -480,7 +403,6 @@ qtremoteobjects-external-schemas.webxml
 qtremoteobjects-gettingstarted.webxml
 qtremoteobjects-interaction.webxml
 qtremoteobjects-node.webxml
-qtremoteobjects-qmlmodelviewclient-example.webxml
 qtremoteobjects-registry.webxml
 qtremoteobjects-repc.webxml
 qtremoteobjects-replica.webxml
@@ -488,21 +410,11 @@ qtremoteobjects-source.webxml
 qtremoteobjects-ssl-example.webxml
 qtremoteobjects-troubleshooting.webxml
 qtremoteobjects-websockets-example.webxml
-qtscxml-calculator-qml-example.webxml
-qtscxml-calculator-widgets-example.webxml
 qtscxml-changes-qt6.webxml
 qtscxml-cmake-qt-add-statecharts.webxml
 qtscxml-ftpclient-example.webxml
 qtscxml-instantiating-state-machines.webxml
-qtscxml-invoke-dynamic-example.webxml
-qtscxml-invoke-static-example.webxml
-qtscxml-mediaplayer-qml-cppdatamodel-example.webxml
-qtscxml-mediaplayer-qml-dynamic-example.webxml
-qtscxml-mediaplayer-qml-static-example.webxml
-qtscxml-mediaplayer-widgets-dynamic-example.webxml
-qtscxml-mediaplayer-widgets-static-example.webxml
 qtscxml-overview.webxml
-qtscxml-pinball-example.webxml
 qtscxml-scxml-compliance.webxml
 qtscxml-sudoku-example.webxml
 qtscxml-trafficlight-qml-dynamic-example.webxml
@@ -510,24 +422,13 @@ qtscxml-trafficlight-qml-simple-example.webxml
 qtscxml-trafficlight-qml-static-example.webxml
 qtscxml-trafficlight-widgets-dynamic-example.webxml
 qtscxml-trafficlight-widgets-static-example.webxml
-qtsensors-accelbubble-example.webxml
 qtsensors-changes-qt6.webxml
 qtsensors-cpp.webxml
 qtsensors-examples.webxml
-qtsensors-grue-example.webxml
-qtsensors-maze-example.webxml
-qtsensors-qmlqtsensors-example.webxml
-qtsensors-sensor-explorer-example.webxml
 qtsensors-sensorsshowcase-example.webxml
 qtserialport-blockingreceiver-example.webxml
 qtserialport-blockingsender-example.webxml
-qtserialport-cenumerator-example.webxml
 qtserialport-changes-qt6.webxml
-qtserialport-creaderasync-example.webxml
-qtserialport-creadersync-example.webxml
-qtserialport-cwriterasync-example.webxml
-qtserialport-cwritersync-example.webxml
-qtserialport-enumerator-example.webxml
 qtserialport-examples.webxml
 qtserialport-terminal-example.webxml
 qtsql-cachedtable-example.webxml
@@ -539,9 +440,6 @@ qtsql-sqlbrowser-example.webxml
 qtsql-sqlwidgetmapper-example.webxml
 qtsql-tablemodel-example.webxml
 qtsvg-changes-qt6.webxml
-qtsvg-richtext-textobject-example.webxml
-qtsvg-svggenerator-example.webxml
-qtsvg-svgviewer-example.webxml
 qttest-best-practices-qdoc.webxml
 qttestlib-tutorial1-example.webxml
 qttestlib-tutorial2-example.webxml
@@ -549,7 +447,6 @@ qttestlib-tutorial3-example.webxml
 qttestlib-tutorial4-example.webxml
 qttestlib-tutorial5-example.webxml
 qttestlib-tutorial6.webxml
-qtuitools-multipleinheritance-example.webxml
 qtuitools-textfinder-example.webxml
 qtwebchannel-changes-qt6.webxml
 qtwebchannel-chatclient-html-example.webxml
@@ -561,21 +458,14 @@ qtwebengine-changes-qt6.webxml
 qtwebengine-features.webxml
 qtwebengine-overview.webxml
 qtwebengine-platform-notes.webxml
-qtwebengine-webenginequick-customdialogs-example.webxml
 qtwebengine-webenginequick-lifecycle-example.webxml
-qtwebengine-webenginequick-minimal-example.webxml
-qtwebengine-webenginequick-recipebrowser-example.webxml
-qtwebengine-webenginequick-webengineaction-example.webxml
 qtwebengine-webenginewidgets-contentmanipulation-example.webxml
 qtwebengine-webenginewidgets-cookiebrowser-example.webxml
 qtwebengine-webenginewidgets-html2pdf-example.webxml
 qtwebengine-webenginewidgets-maps-example.webxml
-qtwebengine-webenginewidgets-minimal-example.webxml
 qtwebengine-webenginewidgets-printme-example.webxml
 qtwebengine-webenginewidgets-spellchecker-example.webxml
-qtwebengine-webenginewidgets-stylesheetbrowser-example.webxml
 qtwebengine-webenginewidgets-videoplayer-example.webxml
-qtwebengine-webenginewidgets-webui-example.webxml
 qtwebenginewidgets-qtwebkitportingguide.webxml
 qtwebsockets-changes-qt6.webxml
 qtwebsockets-echoclient-example.webxml
@@ -587,57 +477,32 @@ qtwebsockets-simplechat-example.webxml
 qtwebsockets-sslechoclient-example.webxml
 qtwebsockets-sslechoserver-example.webxml
 qtwebsockets-testing.webxml
-qtwidgets-draganddrop-fridgemagnets-example.webxml
-qtwidgets-draganddrop-puzzle-example.webxml
-qtwidgets-effects-fademessage-example.webxml
 qtwidgets-gestures-imagegestures-example.webxml
 qtwidgets-graphicsview-basicgraphicslayouts-example.webxml
 qtwidgets-graphicsview-chip-example.webxml
-qtwidgets-graphicsview-embeddeddialogs-example.webxml
-qtwidgets-graphicsview-flowlayout-example.webxml
 qtwidgets-graphicsview-simpleanchorlayout-example.webxml
-qtwidgets-graphicsview-weatheranchorlayout-example.webxml
-qtwidgets-itemviews-chart-example.webxml
 qtwidgets-itemviews-coloreditorfactory-example.webxml
 qtwidgets-itemviews-combowidgetmapper-example.webxml
 qtwidgets-itemviews-customsortfiltermodel-example.webxml
-qtwidgets-itemviews-dirview-example.webxml
 qtwidgets-itemviews-frozencolumn-example.webxml
-qtwidgets-itemviews-interview-example.webxml
-qtwidgets-itemviews-pixelator-example.webxml
-qtwidgets-itemviews-puzzle-example.webxml
-qtwidgets-itemviews-simpledommodel-example.webxml
 qtwidgets-itemviews-simpletreemodel-example.webxml
-qtwidgets-itemviews-simplewidgetmapper-example.webxml
-qtwidgets-mainwindows-mainwindow-example.webxml
 qtwidgets-mainwindows-menus-example.webxml
-qtwidgets-mainwindows-sdi-example.webxml
 qtwidgets-painting-affine-example.webxml
 qtwidgets-painting-composition-example.webxml
 qtwidgets-painting-deform-example.webxml
-qtwidgets-painting-fontsampler-example.webxml
 qtwidgets-painting-gradients-example.webxml
 qtwidgets-painting-imagecomposition-example.webxml
 qtwidgets-painting-painterpaths-example.webxml
 qtwidgets-painting-pathstroke-example.webxml
 qtwidgets-painting-transformations-example.webxml
-qtwidgets-richtext-calendar-example.webxml
 qtwidgets-tools-completer-example.webxml
 qtwidgets-tools-customcompleter-example.webxml
 qtwidgets-tools-echoplugin-example.webxml
-qtwidgets-tools-i18n-example.webxml
-qtwidgets-tools-plugandpaint-app-example.webxml
-qtwidgets-tools-plugandpaint-plugins-basictools-example.webxml
-qtwidgets-tools-plugandpaint-plugins-extrafilters-example.webxml
 qtwidgets-tools-settingseditor-example.webxml
 qtwidgets-tools-styleplugin-example.webxml
 qtwidgets-tools-treemodelcompleter-example.webxml
-qtwidgets-tools-undo-example.webxml
 qtwidgets-tools-undoframework-example.webxml
-qtwidgets-touch-dials-example.webxml
-qtwidgets-touch-fingerpaint-example.webxml
 qtwidgets-touch-knobs-example.webxml
-qtwidgets-touch-pinchzoom-example.webxml
 qtwidgets-tutorials-notepad-example.webxml
 qtwidgets-tutorials-widgets-childwidget-example.webxml
 qtwidgets-tutorials-widgets-nestedlayouts-example.webxml
@@ -646,27 +511,14 @@ qtwidgets-tutorials-widgets-windowlayout-example.webxml
 qtwidgets-widgets-analogclock-example.webxml
 qtwidgets-widgets-calculator-example.webxml
 qtwidgets-widgets-calendarwidget-example.webxml
-qtwidgets-widgets-digitalclock-example.webxml
-qtwidgets-widgets-elidedlabel-example.webxml
 qtwidgets-widgets-groupbox-example.webxml
-qtwidgets-widgets-icons-example.webxml
-qtwidgets-widgets-imageviewer-example.webxml
 qtwidgets-widgets-lineedits-example.webxml
-qtwidgets-widgets-mousebuttons-example.webxml
-qtwidgets-widgets-movie-example.webxml
 qtwidgets-widgets-scribble-example.webxml
 qtwidgets-widgets-shapedclock-example.webxml
 qtwidgets-widgets-sliders-example.webxml
 qtwidgets-widgets-spinboxes-example.webxml
-qtwidgets-widgets-styles-example.webxml
-qtwidgets-widgets-stylesheet-example.webxml
 qtwidgets-widgets-tablet-example.webxml
-qtwidgets-widgets-tooltips-example.webxml
-qtwidgets-widgets-validators-example.webxml
-qtwidgets-widgets-wiggly-example.webxml
 qtwidgets-widgets-windowflags-example.webxml
-qtxml-streambookmarks-example.webxml
-qtxml-xmlstreamlint-example.webxml
 quick-changes-qt6.webxml
 qwebenginecookiestore-filterrequest.webxml
 qwidget-styling.webxml
@@ -706,9 +558,7 @@ stylesheet-syntax.webxml
 stylesheet.webxml
 svgrendering.webxml
 testlib-changes-qt6.webxml
-textedit-example.webxml
 timers.webxml
-tutorials-addressbook.webxml
 usingadaptors.webxml
 videooverview.webxml
 webengine-examples.webxml
@@ -723,3 +573,52 @@ xml-namespaces.webxml
 xml-processing.webxml
 xml-streaming.webxml
 xml-tools.webxml
+# qtdoc repository
+accessible.webxml
+appicon.webxml
+create-your-first-applications.webxml
+deployment.webxml
+desktop-integration.webxml
+exceptionsafety.webxml
+explore-qt.webxml
+get-and-install-qt.webxml
+gettingstarted.webxml
+highdpi.webxml
+install-qt-design-studio.webxml
+ipc.webxml
+known-issues.webxml
+overviews-main.webxml
+plugins-howto.webxml
+qml-codingconventions.webxml
+qml-glossary.webxml
+qmlapplications.webxml
+qmlfirststeps.webxml
+qt-intro.webxml
+qtquick-debugging.webxml
+qtquick-performance.webxml
+qtquick-qml-runtime.webxml
+qtquick-usecase-animations.webxml
+qtquick-usecase-integratingjs.webxml
+qtquick-usecase-layouts.webxml
+qtquick-usecase-styling.webxml
+qtquick-usecase-text.webxml
+qtquick-usecase-userinput.webxml
+qtquick-usecase-visual.webxml
+qundo.webxml
+rcc.webxml
+restoring-geometry.webxml
+scalability.webxml
+session.webxml
+sharedlibrary.webxml
+solutions-for-application-development.webxml
+solutions-for-ui-design.webxml
+thread-basics.webxml
+threads.webxml
+tools-for-qt-quick-uis.webxml
+tools-for-qt-widget-based-uis.webxml
+topics-app-development.webxml
+topics-data-io.webxml
+topics-ui.webxml
+uic.webxml
+unicode.webxml
+wayland-and-qt.webxml
diff --git a/sources/pyside6/doc/api.rst b/sources/pyside6/doc/api.rst
index 62273c31f..7bbe2ce1c 100644
--- a/sources/pyside6/doc/api.rst
+++ b/sources/pyside6/doc/api.rst
@@ -8,33 +8,23 @@ Basic modules
 
 These are the main modules that help you build a Widget-based UI.
 
-.. panels::
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    :mod:`QtCore <PySide6.QtCore>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtCore <PySide6.QtCore>`
 
-    Provides core non-GUI functionality, like signal and
-    slots, properties, base classes of item models,
-    serialization, and more.
+        Provides core non-GUI functionality, like signal and slots, properties,
+        base classes of item models, serialization, and more.
 
-    ---
+    .. grid-item-card:: :mod:`QtGui <PySide6.QtGui>`
 
-    :mod:`QtGui <PySide6.QtGui>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Extends QtCore with GUI functionality: Events, windows and screens,
+        OpenGL and raster-based 2D painting, as well as images.
 
-    Extends QtCore with GUI functionality: Events, windows
-    and screens, OpenGL and raster-based 2D painting, as
-    well as images.
+    .. grid-item-card:: :mod:`QtWidgets <PySide6.QtWidgets>`
 
-    ---
-
-    :mod:`QtWidgets <PySide6.QtWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides ready to use Widgets for your application,
-    including graphical elements for your UI.
+        Provides ready to use Widgets for your application, including graphical
+        elements for your UI.
 
 QML and Qt Quick
 ----------------
@@ -42,31 +32,21 @@ QML and Qt Quick
 Use these modules to interact with the `QML Language <https://doc.qt.io/qt-5.qmlapplications>`_,
 from Python.
 
-.. panels::
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-
-    :mod:`QtQml <PySide6.QtQml>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    The base Python API to interact with the
-    module.
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    ---
+    .. grid-item-card:: :mod:`QtQml <PySide6.QtQml>`
 
-    :mod:`QtQuick <PySide6.QtQuick>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        The base Python API to interact with the module.
 
-    Provides classes to embed Qt Quick in Qt
-    applications.
+    .. grid-item-card:: :mod:`QtQuick <PySide6.QtQuick>`
 
-    ---
+        Provides classes to embed Qt Quick in Qt applications.
 
-    :mod:`QtQuickWidgets <PySide6.QtQuickWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtQuickWidgets <PySide6.QtQuickWidgets>`
 
-    Provides the QQuickWidget class to embed Qt
-    Quick in widget-based applications.
+        Provides the QQuickWidget class to embed Qt Quick in widget-based
+        applications.
 
 All the modules
 ---------------
diff --git a/sources/pyside6/doc/commercial/index.rst b/sources/pyside6/doc/commercial/index.rst
index a4d0c43fc..e74419d6a 100644
--- a/sources/pyside6/doc/commercial/index.rst
+++ b/sources/pyside6/doc/commercial/index.rst
@@ -1,7 +1,7 @@
 .. _commercial-page:
 
-Commercial Distribution
-=======================
+Commercial Use
+==============
 
 |project| follows the same licensing that Qt has, which means that there are two
 distributions, the Community Edition (LGPLv3/GPLv3) and a Commercial Edition. For
@@ -16,18 +16,105 @@ any of the following licenses:
 #. Qt for Device Creation Enterprise (DCE)
 
 The only difference is that the ADP license **does not** include the extra
-``Qt OPC UA``,  ``Qt MQTT`` and ``Qt CoAP`` modules, which are distributed in
+``Qt OPC UA``, ``Qt MQTT`` and ``Qt CoAP`` modules, which are distributed in
 a special Python wheel.
 
-All commercial licenses include the 5.15.x and 6.2.x LTS releases.
+|project| follows the same approach as Qt, meaning that commercial
+users will have access to both our commercial packages for any
+given version, or the special commercial LTS releases.
 
 Commercial users **should not** install the Community Edition distribution via ``pip
 install pyside6`` to avoid licensing problems, and should refer to the
-packages provided in the `Qt Account`_.
+packages that can be acquired from the `Qt Account`_, the Qt Installer, or
+via the `qtpip` tool.
 
 Installation
 ------------
 
+We understand that the installation of the commercial wheels will depend
+on your use cases. For this, we currently offer three
+ways to install a commercial Qt for Python release: a command line tool,
+using the Maintenance Tool, or downloading packages by hand.
+
+qtpip - a commercial wheel installer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+`qtpip`_ is a wrapper around `pip`_ (the package installer for Python) that provides an
+integration with the detection of commercial licenses.
+
+To set up the tool, we recommend creating a virtual environment for your
+project, and then installing the tool like any other module:
+
+.. code-block:: bash
+
+    # Create and activate a virtual environment first
+    # then install 'qtpip'
+    pip install qtpip
+
+    # Now install pyside6 (or any of the Qt for Python packages)
+    qtpip install pyside6
+
+Besides the ``install`` command, you can also ``uninstall`` (like in pip) but
+you can also perform a `fulluninstall`` to fully remove all the Qt for Python
+packages. You can find more information running ``qtpip -h``::
+
+   $ qtpip -h
+   Usage: qtpip [options] install <package> fulluninstall <PySide6/shiboken6/all>
+   Qt wrapper around pip.
+   These arguments override pip's. For more, refer to pip --help
+
+   Options:
+     -f, --force                  Force installation if OSS wheels were already
+                                  installed.
+     --no-input                   Disable prompting for input.
+     --no-cache-dir               Disable the cache.
+     --disable-pip-version-check  Don't periodically check PyPI to determine
+                                  whether a new version of pip is available for
+                                  download.
+     --no-color                   Suppress colored output.
+     --user                       Install to the Python user install directory for
+                                  your platform.
+     --force-reinstall            Reinstall all packages even if they are already
+                                  up-to-date.
+     -h, --help                   Displays help on commandline options.
+     --help-all                   Displays help, including generic Qt options.
+     -v, --version                Displays version information.
+
+   Arguments:
+     install                      Installs a package, this can be any of PySide6,
+                                  PySide6-Essentials, PySide6-Addons, shiboken6 or
+                                  shiboken6-generator for the respective commercial
+                                  wheel, or any other wheel from PyPi.
+     fulluninstall                Fully uninstalls all packages related to
+                                  PySide6, shiboken6, or both.
+
+.. note:: The release cycle of ``qtpip`` will be independent from the Qt for
+   Python one.
+
+
+Maintenance Tool
+^^^^^^^^^^^^^^^^
+
+As a commercial user, you are able to download the commercial set of wheels
+from the `Qt Maintenance Tool`_. The same versions that are available for
+Qt/C++ are available for the Python bindings.
+
+The wheels will be downloaded, but not installed, mainly because they should
+be installed into a virtual environment rather than the default interpreter.
+A ``requirements.txt`` file will be provided alongside the wheels, in order to
+simplify the installation step::
+
+   pip install -r /path/to/Qt/QtForPython/6.6.0/requirements.txt
+
+Complementary to the wheels, you will be able to download the sources
+as well.
+
+.. note:: Wheels installed this way will be detectable by `*Qt Creator*`_, which
+   will offer you to install them for your current Python interpreter.
+
+Using account.qt.io
+^^^^^^^^^^^^^^^^^^^
+
 Head to your `Qt Account`_ page, and select the **Download** option on the side
 menu. You will find an option to select |project| from the **Products**
 section:
@@ -93,11 +180,11 @@ the wheels are::
 Qt Creator Integration
 ----------------------
 
-Qt Creator offers the option to create new |project| projects from the main
+*Qt Creator* offers the option to create new |project| projects from the main
 wizard.
 
 To execute the projects, make sure that the proper *Python Interpreter* is
-selected, so Qt Creator can use the commercial modules you just installed.
+selected, so *Qt Creator* can use the commercial modules you just installed.
 Go to *Edit -> Preferences* where you can find the *Python* option
 that will show the following:
 
@@ -110,7 +197,7 @@ select the main Python executable from your environment. This can be found on
 ``path_to_your_env/bin/python`` (macOS and Linux), or
 ``path_to_your_env\python.exe`` (Windows).
 
-As an alternative, you can launch Qt Creator from within the virtual
+As an alternative, you can launch *Qt Creator* from within the virtual
 environment, detecting your installation automatically.
 
 Migrating from other versions
@@ -156,4 +243,8 @@ packages will likely happen.
 
 .. _`Qt Licensing`: https://www.qt.io/licensing/
 .. _`Qt Account`: https://account.qt.io
+.. _`Qt Maintenance Tool`: https://doc.qt.io/qt-6/qt-online-installation.html
+.. _`Qt Creator`: https://www.qt.io/product/development-tools
+.. _`qtpip`: https://pypi.org/project/qtpip/
+.. _`pip`: https://pypi.org/project/pip/
 
diff --git a/sources/pyside6/doc/conf.py.in b/sources/pyside6/doc/conf.py.in
index 0c2593147..e195d227f 100644
--- a/sources/pyside6/doc/conf.py.in
+++ b/sources/pyside6/doc/conf.py.in
@@ -13,7 +13,6 @@
 
 import sys
 import os
-from pathlib import Path
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -27,12 +26,28 @@ if @HAS_WEBENGINE_WIDGETS@:
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-#extensions = ['sphinx.ext.todo', 'sphinx.ext.graphviz', 'inheritance_diagram', 'pysideinclude']
 extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.ifconfig',
     'sphinx.ext.coverage', 'sphinx.ext.intersphinx', 'sphinx.ext.todo',
     'sphinx.ext.graphviz', 'inheritance_diagram', 'pysideinclude',
     'sphinx.ext.viewcode',
-    'sphinx_panels', 'sphinx_copybutton']
+    'sphinx_design', 'sphinx_copybutton', 'myst_parser', 'sphinx_tags',
+    'sphinx_toolbox.decorators']
+
+myst_enable_extensions = [
+    "amsmath",
+    "colon_fence",
+    "deflist",
+    "dollarmath",
+    "fieldlist",
+    "html_admonition",
+    "html_image",
+    "replacements",
+    "smartquotes",
+    "strikethrough",
+    "substitution",
+    "tasklist",
+]
+myst_heading_anchors = 6
 
 output_format='@DOC_OUTPUT_FORMAT@'
 
@@ -48,7 +63,10 @@ rst_epilog = """
 templates_path = ['@CMAKE_CURRENT_SOURCE_DIR@/_templates']
 
 # The suffix of source filenames.
-source_suffix = '.rst'
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
 
 # The encoding of source files.
 source_encoding = 'utf-8'
@@ -60,7 +78,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'PySide'
-copyright = u'2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 (https://www.gnu.org/licenses/fdl.html) as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.'
+copyright = u'2024 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 (https://www.gnu.org/licenses/fdl.html) as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.'
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
@@ -87,7 +105,7 @@ release = '@BINDING_API_VERSION_FULL@'
 # for source files.
 exclude_patterns = ['_build',
                     'extras',
-                    ]
+                    '**README.md']
 
 # The reST default role (used for this markup: `text`) to use for all documents.
 #default_role = None
@@ -121,17 +139,22 @@ html_theme = 'furo'
 # further.  For a list of options available for each theme, see the
 # documentation.
 html_theme_options = {
+    # FIXME: This option is currently enable because on the 'requirements-doc.txt'
+    # We are using a fork of the theme, to include this new option.
+    # This needs to be removed once the functionality is either upstreamed,
+    # or a similar option is provided.
+    "collapse_navbar": True,
     "dark_css_variables": {
-        "color-brand-primary": "#66689d",
-        "color-brand-content": "#66689d",
-        "color-admonition-title--important": "#41cd52",
+        "color-brand-primary": "#2cde85",
+        "color-brand-content": "#2cde85",
+        "color-admonition-title--important": "#2cde85",
         "color-admonition-title-background--important": "#474b53",
         "font-stack": "'Titillium Web', sans-serif",
     },
     "light_css_variables": {
-        "color-brand-primary": "#66689d",
-        "color-brand-content": "#41cd52",
-        "color-admonition-title--important": "#41cd52",
+        "color-brand-primary": "#27138b",
+        "color-brand-content": "#27138b",
+        "color-admonition-title--important": "#27138b",
         "font-stack": "'Titillium Web', sans-serif",
     },
 }
@@ -141,7 +164,7 @@ html_theme_path = ['@CMAKE_CURRENT_SOURCE_DIR@/_themes']
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-html_title = u'Qt for Python'
+html_title = 'Qt for Python'
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
 #html_short_title = None
@@ -153,7 +176,7 @@ html_logo = "@CMAKE_CURRENT_SOURCE_DIR@/_static/qtforpython.png"
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+html_favicon = "_static/qtforpython.ico"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
@@ -205,7 +228,7 @@ intersphinx_mapping = {'shiboken6': ('shiboken6','@SHIBOKEN_INTERSPHINX_FILE@')}
 add_module_names = False
 
 # Skip some warnings when building the documentation with
-# 'build_rst_docs' due to the lack of qdoc generated files, in charge
+# 'build_base_docs' due to the lack of qdoc generated files, in charge
 # of sphinx modules (autodoc) and references.
 if @SKIP_SPHINX_WARNINGS@:
     suppress_warnings = ["autodoc", "autodoc.import_object", "ref.ref"]
@@ -213,7 +236,9 @@ if @SKIP_SPHINX_WARNINGS@:
 # -- Options for qthelp output ---------------------------------------------------
 qthelp_theme = 'pysidedocs_qthelp'
 
-# Sphinx Panels color for inactive tab
-panels_css_variables = {
-    "tabs-color-label-inactive": "rgba(116, 116, 116, 1.0)",
+# for example tagging based on supported platforms
+tags_create_tags = True
+tags_create_badges = True
+tags_badge_colors = {
+    "Android": "info",
 }
diff --git a/sources/pyside6/doc/considerations.rst b/sources/pyside6/doc/considerations.rst
index 6f4a059a2..dda1d8b0d 100644
--- a/sources/pyside6/doc/considerations.rst
+++ b/sources/pyside6/doc/considerations.rst
@@ -10,7 +10,7 @@ One of the goals of |pymodname| is to be API compatible with PyQt,
 with certain exceptions.
 
 The latest considerations and known issues will be also reported
-in the `wiki <https://wiki.qt.io/Qt_for_Python/Considerations>`_.
+in the :ref:`developer-notes`.
 
 __hash__() function return value
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -241,6 +241,7 @@ part of modern Python. The implementation is perfectly modelled after the needs
 users. It is therefore just consequent to stop having two different enum implementations
 in the same application and instead to use the new Python implementation everywhere.
 
+
 Existing Work
 ~~~~~~~~~~~~~
 
@@ -249,17 +250,18 @@ with Python variants, which harmonize the builtin enums with the already existin
 ``QEnum`` "macro" shown in the :ref:`QEnum` section.
 
 
-Activating the New Enums
+Enums behavior in PySide
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-The new approach to enum will be the default in ``PySide 6.4``, but a preview is already built
-into ``PySide 6.3`` with the environment variable:
-`PYSIDE63_OPTION_PYTHON_ENUM=1 python3 <myscript>` enables the new enums.
-In ``PySide 6.4``, this flag is by default on, but it can be switched to the old Shiboken
-enums by setting the variable to 0.
+In ``PySide 6.3`` there was a double implementation of old and new enums, where the
+default was old enums.
+The new approach to enum is the default in ``PySide 6.4`` and becomes mandatory
+in ``PySide 6.6``. There exists the environment variable ``PYSIDE6_OPTION_PYTHON_ENUM``
+with the default value of "1". There can also variations be selected by specifying
+different flags, but the value of "0" (switching off) is no longer supported.
 
-This environment variable will stay until a general acceptance of the new enums has been
-reached and a fallback to the old implementation is no longer needed.
+The still available options for switching some enum features off can be found in the
+:ref:`enum-features` section.
 
 
 The Differences between old and new Enums
@@ -268,13 +270,10 @@ The Differences between old and new Enums
 Python enums and Shiboken enums are more or less compatible with each other.
 Tiny differences are in restrictions:
 
-  * Python enums cannot inherit from each other, whereas Shiboken enums can
-
-  * Python enums don't allow undefined values, Shiboken enums do
-
-  * Python enums always need exactly one argument, Shiboken enums have a default zero value
-
-  * Python enums rarely inherit from int, Shiboken enums always do
+* Python enums cannot inherit from each other, whereas Shiboken enums can
+* Python enums don't allow undefined values, Shiboken enums do
+* Python enums always need exactly one argument, Shiboken enums have a default zero value
+* Python enums rarely inherit from int, Shiboken enums always do
 
 More visible are the differences between flags, as shown in the following:
 
@@ -348,9 +347,8 @@ and never propose the old ones.
 
 The reason to implement ``forgiveness mode`` this way was
 
-  * to make the transition as smooth as possible, but
-
-  * to encourage people to use the new enums whenever new code is written.
+* to make the transition as smooth as possible, but
+* to encourage people to use the new enums whenever new code is written.
 
 So you can continue to write:
 
@@ -385,3 +383,59 @@ cannot be written in the shortcut form
 because there is no surrounding PySide class that provides the forgiving mode
 implementation. Typically, the needed changes are easily found because they often occur
 in an import statement.
+
+Permission API
+--------------
+
+The cross-platform permission APIs were introduced to Qt in version 6.5 which are currently relevant
+to platforms macOS, iOS, Android and WebAssembly. With this API, your Qt application can check and
+request permission for certain features like Camera, Microphone, Location, Bluetooth, Contacts,
+Calendar. More about permission API can be read in this `Blog post`_.
+
+When a PySide6 application that uses the permission API is run in interpreted mode, i.e.,
+``python <main_file>.py``, the code implementing the permission API *will not work*. The only way
+to make your PySide6 application using permission API work is to bundle the application. For Android,
+this means using the `pyside6-android-deploy`_ tool and for macOS, this means using the
+`pyside6-deploy`_ tool.
+
+When running in interpreted mode, you can skip over the permission check/request using the following
+*if* condition
+
+::
+
+    is_deployed = "__compiled__" in globals()
+    if not is_deployed and sys.platform == "darwin":
+        # code implementing permission check and request
+
+This can also be seen in the PySide6 `Camera example`_. * __compiled__ * is a Nuitka attribute to
+check if the application is run as a standalone application or run in interpreted mode with Python.
+
+Android
+~~~~~~~~
+
+For Android, `pyside6-android-deploy`_ takes care of identifying the necessary permissions needed by
+the application and adding those permissions to the *AndroidManifest.xml* using the
+*<uses-permission>* element.
+
+macOS
+~~~~~
+
+Since the Android platform does not automatically come bundled with a Python interpreter, it is
+evident that to make a PySide6 application run on Android you have to package the PySide6
+application. This is not the case for desktop platforms like macOS where a Python interpreter and
+its packages can be installed and run quite easily.
+
+The problem for macOS is that for the permission API to work you need a macOS bundle with an
+*Info.plist* file that lists all the permissions required using the *usage description* string for
+each permission used. When Python is run in interpreted mode, i.e., when you run Python, the Qt
+permission API fetches the *Info.plist* from the Python interpreter by default which does not
+contain the *usage description* strings for the permissions required. You can certainly modify the
+*Info.plist* of the Python framework installation to make the Qt permission API work when running
+a PySide6 application from the terminal. However, this is not recommended. Therefore, the only
+viable solution is to bundle the PySide6 application as a macOS application bundle using
+`pyside6-deploy`_. This macOS application bundle will have its own Info.plist file.
+
+.. _`Blog post`: https://www.qt.io/blog/permission-apis-in-qt-6.5
+.. _`Camera Example`: https://doc.qt.io/qtforpython-6/examples/example_multimedia_camera.html#camera-example
+.. _`pyside6-android-deploy`: https://doc.qt.io/qtforpython-6/gettingstarted/package_details.html#deployment
+.. _`pyside6-deploy`: https://doc.qt.io/qtforpython-6/gettingstarted/package_details.html#deployment
diff --git a/sources/pyside6/doc/contents.rst b/sources/pyside6/doc/contents.rst
index 9d471d7f9..4b6c7ffa9 100644
--- a/sources/pyside6/doc/contents.rst
+++ b/sources/pyside6/doc/contents.rst
@@ -4,15 +4,16 @@
     :maxdepth: 2
 
     quickstart.rst
+    commercial/index.rst
     gettingstarted/index.rst
     api.rst
+    tools/index.rst
     tutorials/index.rst
     examples/index.rst
     videos.rst
     deployment/index.rst
     considerations.rst
     developer/index.rst
-    commercial.rst
 
 ..
     Intersphinx references in toctrees is not supported
diff --git a/sources/pyside6/doc/deployment/deployment-briefcase.rst b/sources/pyside6/doc/deployment/deployment-briefcase.rst
index 95aee1432..e85e618a7 100644
--- a/sources/pyside6/doc/deployment/deployment-briefcase.rst
+++ b/sources/pyside6/doc/deployment/deployment-briefcase.rst
@@ -1,13 +1,16 @@
 |project| & Briefcase
 #######################
 
-`Briefcase <https://briefcase.readthedocs.io>`_  is a packaging tool that lets you create a standalone package for a Python application. It supports the following installer formats:
+`Briefcase <https://briefcase.readthedocs.io>`_  is a packaging tool that lets
+you create a standalone package for a Python application. It supports the
+following installer formats:
 
- * .app application bundle for macOS
- * MSI installer for Windows
- * AppImage for Linux
+* ``.app`` application bundle for macOS
+* MSI installer for Windows
+* AppImage for Linux
 
-For more details, see the `official documentation <https://briefcase.readthedocs.io/en/latest/index.html>`_.
+For more details, see the `official documentation
+<https://briefcase.readthedocs.io/en/latest/index.html>`_.
 
 Status of Qt 6 Support
 ======================
@@ -17,15 +20,15 @@ As of March 2021, Qt 6 is not supported yet.
 Preparation
 ===========
 
-Install `Briefcase` using the following **pip** command::
+Install ``Briefcase`` using the following **pip** command::
 
     pip install briefcase
 
 You also need : docker on linux, `WixToolset`_ on windows,
 
-If you're using a virtual environment, remember to activate it before installing `Briefcase`.
+If you're using a virtual environment, remember to activate it before installing ``Briefcase``.
 
-After installation, the `briefcase` binary is located in your virtual environment's `bin/`
+After installation, the ``briefcase`` binary is located in your virtual environment's ``bin/``
 directory, or where your Python executable is located.
 
 You can either create a brand new project using the briefcase assistant or setup your own.
@@ -39,8 +42,8 @@ Run the following command and answer the questions to get started::
 
     briefcase new
 
-Ensure that `PySide6` is chosen as the `GUI toolkit choice`.
-Your PySide6 application is now configured. You can jump to `Build the package`_.
+Ensure that |pymodname| is chosen as the **GUI toolkit choice**.
+Your |pymodname| application is now configured. You can jump to `Build the package`_.
 
 
 Set up your project
@@ -49,7 +52,7 @@ Set up your project
 Create a pyproject.toml
 -----------------------
 
-At the root level of your project, create a `pyproject.toml` file::
+At the root level of your project, create a ``pyproject.toml`` file::
 
         [tool.briefcase]
         project_name = "MyPySideApp"
@@ -85,7 +88,7 @@ At the root level of your project, create a `pyproject.toml` file::
 
 
 Write some code
-----------------
+---------------
 
 Let's say your project tree is like this::
 
@@ -103,7 +106,7 @@ Let's say your project tree is like this::
             app.py
 
 
-Content of `__main__.py`::
+Content of ``__main__.py``::
 
     import sys
     from PySide6.QtWidgets import QApplication
@@ -119,7 +122,7 @@ Content of `__main__.py`::
         sys.exit(app.exec())
 
 
-Content of  `app.py`::
+Content of ``app.py``::
 
     import random
     from PySide6.QtWidgets import (QLabel, QPushButton,
@@ -151,10 +154,10 @@ Content of  `app.py`::
 
 
 Build the package
-==================
+=================
 
 Initialize the package
-------------------------
+----------------------
 
 Just run::
 
@@ -162,7 +165,8 @@ Just run::
 
 Run the following command to initialize the building the packages for Windows, Linux, and macOS.
 It creates a subdirectory each for the different platforms.
-This step takes longer as it adds the packages listed in `requires` sections in the `pyproject.toml` file.
+This step takes longer as it adds the packages listed in ``requires`` sections in the
+``pyproject.toml`` file.
 
 Build the application
 ---------------------
@@ -185,20 +189,23 @@ Run the application
 
     briefcase run
 
-.. note:: You can run your project in `dev` mode (your source code not packaged) with `briefcase dev`
+.. note:: You can run your project in ``dev`` mode (your source code not packaged) with
+   ``briefcase dev``
 
 
 Build the installer (only Windows and macOS)
----------------------------------------------
+--------------------------------------------
 
 macOS::
 
     briefcase package --no-sign
 
-It's possible to sign, see the `documentation <https://briefcase.readthedocs.io/en/latest/how-to/code-signing/index.html>`_. You get `macOS/A Cool App-0.0.1.dmg`
+It's possible to sign, see the
+`documentation <https://briefcase.readthedocs.io/en/latest/how-to/code-signing/index.html>`_.
+You get ``macOS/A Cool App-0.0.1.dmg``
 
 Windows::
 
     briefcase package
 
-You get `windows\A_Cool_App-0.0.1.msi`
+You get ``windows\A_Cool_App-0.0.1.msi``
diff --git a/sources/pyside6/doc/deployment/deployment-cxfreeze.rst b/sources/pyside6/doc/deployment/deployment-cxfreeze.rst
index 681dcf315..46cbb142e 100644
--- a/sources/pyside6/doc/deployment/deployment-cxfreeze.rst
+++ b/sources/pyside6/doc/deployment/deployment-cxfreeze.rst
@@ -8,37 +8,38 @@ platforms are Linux, macOS, Windows, FreeBSD, among others.
 
 You can read the `official documentation <https://cx-freeze.readthedocs.io/en/latest/index.html>`_
 to clarify any further question, and remember to contribute to
-the project by `filing issues <https://sourceforge.net/projects/cx-freeze/>`_
-if you find any, or contributing to `their development <https://bitbucket.org/anthony_tuininga/cx_freeze/src>`_.
+the project by `filing issues
+<https://github.com/marcelotduarte/cx_Freeze/issues>`_
+if you find any, or contributing to `their development <https://github.com/marcelotduarte/cx_Freeze>`_.
 
 Preparation
 ===========
 
-Installing `cx_Freeze` can be done using **pip**::
+Installing ``cx_Freeze`` can be done using **pip**::
 
     pip install cx_freeze
 
 If you are using a virtual environment, remember to activate it before
-installing `cx_Freeze` into it.
+installing ``cx_Freeze`` into it.
 
-After the installation, you will have the `cxfreeze` binary to deploy
+After the installation, you will have the ``cxfreeze`` binary to deploy
 your application.
 
 Freezing an application
 =======================
 
-There are three options to work with `cx_Freeze`:
+There are three options to work with ``cx_Freeze``:
 
- 1. Using the `cxfreeze` script.
- 2. Creating `setup.py` script to build the project.
- 3. Using the module classes directly (for advanced purposes).
+1. Using the ``cxfreeze`` script.
+2. Creating ``setup.py`` script to build the project.
+3. Using the module classes directly (for advanced purposes).
 
 The following sections cover the first two use cases.
 
 Creating an example
 -------------------
 
-Now, consider the following simple script, named `hello.py`::
+Now, consider the following simple script, named ``hello.py``::
 
     import sys
     import random
@@ -79,28 +80,28 @@ Now, consider the following simple script, named `hello.py`::
         sys.exit(app.exec())
 
 
-Using `cxfreeze` executable
----------------------------
+Using ``cxfreeze`` executable
+-----------------------------
 
 Now that we have an application, try freezing it with the following
 command::
 
     cxfreeze hello.py
 
-This command creates a `dist/` directory containing the executable.
-and a `lib/` directory containing all the shared libraries.
+This command creates a ``dist/`` directory containing the executable.
+and a ``lib/`` directory containing all the shared libraries.
 
-To launch the application, go to the `dist/` directory and execute
+To launch the application, go to the ``dist/`` directory and execute
 the file::
 
     cd dist/
     ./main
 
 
-Using a setuptools script
--------------------------
+Using a ``setuptools`` script
+-----------------------------
 
-For this process, you need an additional script called `setup.py`::
+For this process, you need an additional script called ``setup.py``::
 
     import sys
     from cx_Freeze import setup, Executable
@@ -114,15 +115,15 @@ Now, build the project using it::
 
     python setup.py build
 
-This step creates a `build/` directory with the following structure::
+This step creates a ``build/`` directory with the following structure::
 
     build
     └── exe.linux-x86_64-3.7
         └── lib
         └── main
 
-The first directory inside `build/` depends on the platform
-you are using, in this case a `x86_64` Linux using Python 3.7.
+The first directory inside ``build/`` depends on the platform
+you are using, in this case a ``x86_64`` Linux using Python 3.7.
 The structure is the same as previously described, and you can simply
 enter the directory and execute the file::
 
diff --git a/sources/pyside6/doc/deployment/deployment-fbs.rst b/sources/pyside6/doc/deployment/deployment-fbs.rst
index c2a2397d2..459a225bf 100644
--- a/sources/pyside6/doc/deployment/deployment-fbs.rst
+++ b/sources/pyside6/doc/deployment/deployment-fbs.rst
@@ -2,7 +2,7 @@
 ####################
 
 `fbs`_ provides a powerful environment for packaging, creating installers, and signing your
-application. It also lets you manage updates to your application. Since `fbs` is based on
+application. It also lets you manage updates to your application. Since `fbs`_ is based on
 PyInstaller, it supports Linux, macOS, and Windows.
 
 For more details, see the `fbs tutorial`_ and the `fbs manual`_.
@@ -32,12 +32,12 @@ command::
 
 This command prompts you to answer a few questions to configure the details of your project, like:
 
- * Application name
- * Author name
- * Qt bindings (PySide6 or PyQt5)
- * Bundle indentified (for macOS)
+* Application name
+* Author name
+* Qt bindings (PySide6)
+* Bundle indentified (for macOS)
 
-Afterwards, you have a `src/` directory that contains the following structure::
+Afterwards, you have a ``src/`` directory that contains the following structure::
 
     └── src
         ├── build
@@ -49,10 +49,10 @@ Afterwards, you have a `src/` directory that contains the following structure::
             │   └── mac
             └── python
 
-Inside the `settings` directory, there are a few JSON files that can be edited to include more
+Inside the ``settings`` directory, there are a few JSON files that can be edited to include more
 information about your project.
 
-The `main` file is in the `python` directory, and its default content is::
+The ``main`` file is in the ``python`` directory, and its default content is::
 
     from fbs_runtime.application_context import ApplicationContext
     from PySide6.QtWidgets import QMainWindow
@@ -67,7 +67,7 @@ The `main` file is in the `python` directory, and its default content is::
         exit_code = appctxt.app.exec()      # 2. Invoke appctxt.app.exec()
         sys.exit(exit_code)
 
-This example shows an empty `QMainWindow`. You can run it using the following command::
+This example shows an empty ``QMainWindow``. You can run it using the following command::
 
     fbs run
 
@@ -83,15 +83,15 @@ After the process completes, you see a message stating the location of your exec
 example::
 
     Done. You can now run `target/MyApp/MyApp`. If that doesn't work, see
-    https://build-system.fman.io/troubleshooting.
+    https://build-system.fman.io/troubleshooting
 
 
 Now, you can try to run the application. The result is the same window as the one you saw with the
-`fbs run` command::
+``fbs run`` command::
 
     cd target/MyApp/
     ./MyApp
 
 .. note:: This is the case for Linux. For other platforms like macOS, you need to enter the
-   directory: `target/MyApp.app/Contents/macOS`. For Windows, you need to find the `MyApp.exe`
+   directory: ``target/MyApp.app/Contents/macOS``. For Windows, you need to find the ``MyApp.exe``
    executable.
diff --git a/sources/pyside6/doc/deployment/deployment-nuitka.rst b/sources/pyside6/doc/deployment/deployment-nuitka.rst
index 9be982a4c..8b0afa56c 100644
--- a/sources/pyside6/doc/deployment/deployment-nuitka.rst
+++ b/sources/pyside6/doc/deployment/deployment-nuitka.rst
@@ -11,11 +11,11 @@ For more details, see the `official documentation <https://nuitka.net/pages/over
 Preparation
 ===========
 
-Install `Nuitka` via **pip** with the following command::
+Install ``Nuitka`` via **pip** with the following command::
 
-    pip3 install nuitka
+    pip install nuitka
 
-After installation, the `nuitka3` binary is located in your virtual environment's `bin/`
+After installation, the ``nuitka3`` binary is located in your virtual environment's ``bin/``
 directory, or where your Python executable is located.
 Alternatively, you can also run::
 
@@ -26,7 +26,7 @@ to achieve the same effect.
 Freeze an application
 =====================
 
-`Nuitka` has many options that you can use. To list them all, run `nuitka3 -h`.
+``Nuitka`` has many options that you can use. To list them all, run ``nuitka3 -h``.
 
 To simply compile a project, you can run::
 
@@ -34,17 +34,17 @@ To simply compile a project, you can run::
 
 There are two main features:
 
- * the option to place it in a directory containing the libraries
-   (`--standalone`)
- * the option to package the whole project (including shared libraries) into one executable file
-   (`--onefile`)
+* the option to place it in a directory containing the libraries
+  (``--standalone``)
+* the option to package the whole project (including shared libraries) into one executable file
+  (``--onefile``)
 
-If you use these options, you need to specify `--plugin-enable=pyside6`.
+If you use these options, you need to specify ``--plugin-enable=pyside6``.
 
 Run an example
 --------------
 
-Now, consider the following script, named `hello.py`::
+Now, consider the following script, named ``hello.py``::
 
     import sys
     import random
@@ -84,13 +84,13 @@ Now, consider the following script, named `hello.py`::
 
         sys.exit(app.exec())
 
-You don't have to copy this script. You find it as `examples/installer_test/hello.py`.
+You don't have to copy this script. You find it as ``examples/installer_test/hello.py``.
 
 The command line to proceed looks like this::
 
     nuitka3 examples/installer_test/hello.py
 
-This process creates an executable `hello.bin` and a directory hello.build that you
+This process creates an executable ``hello.bin`` and a directory hello.build that you
 don't need. You can execute the binary directly.
 
 In order to create a bundle which can be copied onto a machine without any pre-existing
@@ -98,23 +98,23 @@ installation, run::
 
     nuitka3 --standalone --plugin-enable=pyside6 examples/installer_test/hello.py
 
-This creates an application `hello.dist/hello` that contains everything needed to run.
+This creates an application ``hello.dist/hello`` that contains everything needed to run.
 
-To run the application, go to `hello.dist/` and run the program::
+To run the application, go to ``hello.dist/`` and run the program::
 
     cd hello.dist
     ./hello
 
-Use the `--onefile` option if you prefer to have everything bundled into one executable, without
+Use the ``--onefile`` option if you prefer to have everything bundled into one executable, without
 the shared libraries next to it. First you need to install::
 
-    pip3 install zstandard
+    pip install zstandard
 
-for data compression. Then you can run
+for data compression. Then you can run::
 
     nuitka3 --onefile --plugin-enable=pyside6 examples/installer_test/hello.py
 
-This process takes a bit longer, but in the end you have one executable `hello.bin`::
+This process takes a bit longer, but in the end you have one executable ``hello.bin``::
 
     ./hello.bin
 
@@ -127,6 +127,6 @@ Nuitka issue on macOS
 ---------------------
 
 Nuitka currently has a problem with the macOS bundle files on current macOS versions.
-That has the effect that `--standalone` and `--onefile` create a crashing application.
+That has the effect that ``--standalone`` and ``--onefile`` create a crashing application.
 Older versions which don't have the recent macOS API changes from 2020 will work.
 We are currently trying to fix that problem.
diff --git a/sources/pyside6/doc/deployment/deployment-py2exe.rst b/sources/pyside6/doc/deployment/deployment-py2exe.rst
index 24d260d71..6ca09a826 100644
--- a/sources/pyside6/doc/deployment/deployment-py2exe.rst
+++ b/sources/pyside6/doc/deployment/deployment-py2exe.rst
@@ -1,16 +1,16 @@
 |project| & py2exe
 ##################
 
-Deploying an application using py2exe requires writing a small `setup.py` file.
+Deploying an application using py2exe requires writing a small ``setup.py`` file.
 It is explained in the `Tutorial <http://www.py2exe.org/index.cgi/Tutorial>`_.
 
 py2exe is not generally aware of Qt. It merely copies the dependent libraries
-of the application to the `dist` directory, so, the plugins, QML imports
+of the application to the ``dist`` directory, so, the plugins, QML imports
 and translations of Qt are missing.
 
 The latter need to be copied manually after running py2exe.
-This can be achieved by running the `windeployqt` tool
-from the Qt SDK on the Qt libraries present in the `dist` directory,
-for example:
+This can be achieved by running the ``windeployqt`` tool
+from the Qt SDK on the Qt libraries present in the ``dist`` directory,
+for example::
 
    windeployqt dist\\Qt6Widgets.dll
diff --git a/sources/pyside6/doc/deployment/deployment-pyinstaller.rst b/sources/pyside6/doc/deployment/deployment-pyinstaller.rst
index eb900bd74..feb257162 100644
--- a/sources/pyside6/doc/deployment/deployment-pyinstaller.rst
+++ b/sources/pyside6/doc/deployment/deployment-pyinstaller.rst
@@ -5,21 +5,21 @@
 stand-alone executable. This installer supports Linux, macOS, Windows, and more; and is also
 compatible with 3rd-party Python modules, such as |pymodname|.
 
-For more details, see the `official documentation <https://www.pyinstaller.org/documentation.html>`_.
+For more details, see the `official documentation <https://www.pyinstaller.org>`_.
 
 Status of Qt 6 Support
 ======================
 
 As of March 2021, Qt 6 is not supported yet. PyInstaller is unable to properly
-deploy Qt; the Qt plugins are not copied. With that, using `--onefile` is not
+deploy Qt; the Qt plugins are not copied. With that, using ``--onefile`` is not
 possible.
 
-It is possible to use PyInstaller for the non `--onefile` case though by
+It is possible to use PyInstaller for the non ``--onefile`` case though by
 manually copying the Qt plugins, QML imports and translations into
 the dist directory after running PyInstaller.
 
-On Windows, this can be achieved by running the `windeployqt` tool
-from the Qt SDK on the Qt libraries present in the `dist` directory, for
+On Windows, this can be achieved by running the ``windeployqt`` tool
+from the Qt SDK on the Qt libraries present in the ``dist`` directory, for
 example:
 
    windeployqt dist\\app\\Qt6Widgets.dll
@@ -28,15 +28,15 @@ example:
 Preparation
 ===========
 
-Install the `PyInstaller` via **pip** with the following command::
+Install the ``PyInstaller`` via **pip** with the following command::
 
     pip install pyinstaller
 
-If you're using a virtual environment, remember to activate it before installing `PyInstaller`.
+If you're using a virtual environment, remember to activate it before installing ``PyInstaller``.
 
-After installation, the `pyinstaller` binary is located in your virtual environment's `bin/`
-directory, or where your Python executable is located. If that directory isn't in your `PATH`,
-include the whole path when you run `pyinstaller`.
+After installation, the ``pyinstaller`` binary is located in your virtual environment's ``bin/``
+directory, or where your Python executable is located. If that directory isn't in your ``PATH``,
+include the whole path when you run ``pyinstaller``.
 
 .. warning:: If you already have a PySide6 or Shiboken6 version installed in your
    system path, PyInstaller uses them instead of your virtual environment version.
@@ -44,24 +44,24 @@ include the whole path when you run `pyinstaller`.
 Freeze an application
 =======================
 
-`PyInstaller` has many options that you can use. To list them all, run `pyinstaller -h`.
+``PyInstaller`` has many options that you can use. To list them all, run ``pyinstaller -h``.
 
 There are two main features:
 
  * the option to package the whole project (including shared libraries) into one executable file
-   (`--onefile`)
+   (``--onefile``)
  * the option to place it in a directory containing the libraries
 
-Additionally, on Windows when the command is running, you can open a console with the `-c` option
-(or `--console` or `--nowindowed` equivalent).
+Additionally, on Windows when the command is running, you can open a console with the ``-c`` option
+(or ``--console`` or ``--nowindowed`` equivalent).
 
-Otherwise, you can specify to not open such a console window on macOS and Windows with the `-w`
-option (or `--windowed` or `--noconsole` equivalent).
+Otherwise, you can specify to not open such a console window on macOS and Windows with the ``-w``
+option (or ``--windowed`` or ``--noconsole`` equivalent).
 
 Create an example
 -----------------
 
-Now, consider the following script, named `hello.py`::
+Now, consider the following script, named ``hello.py``::
 
     import sys
     import random
@@ -102,28 +102,29 @@ Now, consider the following script, named `hello.py`::
         sys.exit(app.exec())
 
 
-Since it has a UI, you use the `--windowed` option.
+Since it has a UI, you use the ``--windowed`` option.
 
 The command line to proceed looks like this::
 
     pyinstaller --name="MyApplication" --windowed hello.py
 
-This process creates two directories: `dist/` and `build/`. The application executable and the
-required shared libraries are placed in `dist/MyApplication`.
+This process creates two directories: ``dist/`` and ``build/``. The application executable and the
+required shared libraries are placed in ``dist/MyApplication``.
 
-To run the application, go to `dist/MyApplication` and run the program::
+To run the application, go to ``dist/MyApplication`` and run the program::
 
     cd dist/MyApplication/
     ./MyApplication
 
-.. note:: The directory inside `dist/` and the executable have the same name.
+.. note:: The directory inside ``dist/`` and the executable have the same name.
 
-Use the `--onefile` option if you prefer to have everything bundled into one executable, without
+Use the ``--onefile`` option if you prefer to have everything bundled into one executable, without
 the shared libraries next to it::
 
     pyinstaller --name="MyApplication" --windowed --onefile hello.py
 
-This process takes a bit longer, but in the end you have one executable in the `dist/` directory::
+This process takes a bit longer, but in the end you have one executable in the
+``dist/`` directory::
 
     cd dist/
     ./MyApplication
@@ -136,26 +137,26 @@ Some Caveats
 PyInstaller Issue
 -----------------
 
-As mentioned before, if available, `PyInstaller` picks a system installation of PySide6 or
-Shiboken6 instead of your `virtualenv` version without notice. This is negligible if those
+As mentioned before, if available, ``PyInstaller`` picks a system installation of |pymodname| or
+Shiboken6 instead of your ``virtualenv`` version without notice. This is negligible if those
 two versions are the same.
 
 If you're working with different versions, this can result in frustrating debugging sessions
-when you think you are testing the latest version, but `PyInstaller` is working with an older
+when you think you are testing the latest version, but ``PyInstaller`` is working with an older
 version.
 
 
 Safety Instructions
 -------------------
 
-- When using `PyInstaller` with `virtualenv`, make sure that there is no system
+- When using ``PyInstaller`` with ``virtualenv``, make sure that there is no system
   installation of PySide6 or shiboken6.
 
-- Before compiling, use `pip -uninstall pyside6 shiboken6 -y` multiple times, until
-  none of the programs are found anymore.
+- Before compiling, use ``pip -uninstall pyside6 pyside6_essentials pyside6_addons shiboken6 -y``
+  multiple times, until none of the programs are found anymore.
 
 - Pip is usually a good tool. But to be 100 % sure, you should directly remove
-  the PySide6 and shiboken6 folders from site-packages.
+  the PySide6 and shiboken6 folders from ``site-packages``.
 
 - Be sure to use the right version of pip. The safest way to really run the right
   pip, is to use the Python that you mean: Instead of the pip command, better use::
diff --git a/sources/pyside6/doc/deployment/deployment-pyside6-android-deploy.rst b/sources/pyside6/doc/deployment/deployment-pyside6-android-deploy.rst
new file mode 100644
index 000000000..53944f6ea
--- /dev/null
+++ b/sources/pyside6/doc/deployment/deployment-pyside6-android-deploy.rst
@@ -0,0 +1,211 @@
+.. _pyside6-android-deploy:
+
+pyside6-android-deploy: the Android deployment tool for Qt for Python
+#####################################################################
+
+``pyside6-android-deploy`` is an easy-to-use tool for deploying PySide6 applications to different
+Android architectures, namely *arm64-v8a, x86_64, x86 and armeabi-v7a*. This tool works similarly to
+the ``pyside6-deploy`` tool and uses the same configuration file ``pysidedeploy.spec`` as
+``pyside6-deploy`` to configure the deployment process. Using the deployment configuration
+options either from the command line or from ``pysidedeploy.spec``, ``pyside6-android-deploy``
+configures the deployment to be initiated and invokes `buildozer`_, a tool used for packaging Python
+applications to Android.
+
+The final output is a `.apk` or a `.aab` file created within the project's source directory. The
+`mode` option specified under the :ref:`buildozer <buildozer_key>` key in ``pysidedeploy.spec``
+determines whether a `.apk` or a `.aab` is created.
+
+.. warning:: Currently, users are required to cross-compile Qt for Python to generate the wheels
+    required for a specific Android target architecture. This requirement will disappear when
+    there are official Qt for Python Android wheels (*in progress*). Because of this
+    requirement ``pyside6-android-deploy`` will be considered in **Technical Preview**.
+    Instructions on cross-compiling Qt for Python for Android can be found
+    :ref:`here <cross_compile_android>`.
+
+.. note:: ``pyside6-android-deploy`` only works on a Linux host at the moment. This constraint
+    is also because Qt for Python cross-compilation for Android currently only works on Linux
+    systems.
+
+How to use it?
+==============
+
+Like ``pyside6-deploy``, there are :ref:`two different ways <how_pysidedeploy>` with which
+you can deploy your PySide6 application using ``pyside6-android-deploy``. The only difference is
+that for ``pyside6-android-deploy`` to work, the main Python entry point file should be named
+``main.py``.
+
+.. _pysideandroiddeploy:
+
+pysidedeploy.spec
+=================
+
+Like ``pyside6-deploy``, you can use the ``pysidedeploy.spec`` file to control the various
+parameters of the deployment process. The file has multiple sections, with each section containing
+multiple keys (parameters being controlled) assigned to a value. The advantages of such a file are
+mentioned :ref:`here <pysidedeployspec_advantages>`. The benefit of using the same
+``pysidedeploy.spec`` for both ``pyside6-deploy`` and ``pyside6-android-deploy`` is that you can
+have one single file to control deployment to all platforms.
+
+The relevant parameters for ``pyside6-android-deploy`` are:
+
+**app**
+  * ``title``: The name of the application.
+  * ``project_dir``: Project directory. The general assumption made is that the project directory
+    is the parent directory of the main Python entry point file.
+  * ``input_file``: Path to the main Python entry point file. For ``pyside6-android-deploy`` this
+    file should be named `main.py`.
+  * ``project_file``: If it exists, this points to the path to the `Qt Creator Python Project File
+    .pyproject <https://doc.qt.io/qtforpython-6/faq/typesoffiles.html
+    #qt-creator-python-project-file-pyproject>`_ file. Such a file in the project directory ensures
+    that deployment does not consider unnecessary files when bundling the executable.
+  * ``exec_directory``: The directory where the final executable is generated.
+
+**python**
+  * ``python_path``: Path to the Python executable. It is recommended to run
+    ``pyside6-android-deploy`` from a virtual environment as certain Python packages will be
+    installed onto the Python environment. However, note to keep the created virtual environment
+    outside the project directory so that ``pyside6-android-deploy`` does not try to package it
+    as well.
+  * ``android_packages``: The Python packages installed into the Python environment for deployment
+    to work. By default, the Python packages `buildozer`_ and `cpython`_ are installed.
+
+.. _qt_key:
+
+**qt**
+  * ``modules``: Comma-separated list of all the Qt modules used by the application. Just like the
+    other configuration options in ``pysidedeploy.spec``, this option is also computed automatically
+    by ``pyside6-android-deploy``. However, if you want to explicitly include certain Qt modules,
+    the module names can be appended to this list without the `Qt` prefix.
+    e.g. Network instead of QtNetwork
+  * ``plugins``: This field is *not relevant* for ``pyside6-android-deploy`` and is only specific to
+    ``pyside6-deploy``. The plugins relevant for ``pyside6-android-deploy`` are specified through
+    the ``plugins`` option under the :ref:`android <android_key>` key.
+
+.. _android_key:
+
+**android**
+  * ``wheel_pyside``: Specifies the path to the PySide6 Android wheel for a specific target
+    architecture.
+  * ``wheel_pyside``: Specifies the path to the Shiboken6 Android wheel for a specific target
+    architecture.
+  * ``plugins``: Comma-separated list of all the Qt plugins used by the application. Just like the
+    other configuration options in ``pysidedeploy.spec``, this option is also computed automatically
+    by ``pyside6-android-deploy``. However, if you want to to explicitly include certain Qt plugins,
+    the plugin names can be appended to this list. To see all the plugins bundled with PySide6, see
+    the `plugins` folder in the ``site-packages`` on your Python where PySide6 is installed. The
+    plugin name corresponds to their folder name. This field can be confused with the ``plugins``
+    option under :ref:`qt <qt_key>` key. In the future, they will be merged into one single option.
+
+.. _buildozer_key:
+
+**buildozer**
+  * ``mode``: Specifies one of the two modes - `release` and `debug`, to run `buildozer`_. The
+    `release` mode creates an *aab* while the `debug` mode creates an apk. The default mode is
+    `debug`.
+  * ``recipe_dir``: Specifies the path to the directory containing `python-for-android`_ recipes.
+    This option is automatically computed by ``pyside6-android-deploy`` during deployment. Without
+    the :ref:`--keep-deployment-files <keep_deployment_files>` option of ``pyside6-android-deploy``,
+    the `recipe_dir` will point to a temporary directory that is deleted after the final Android
+    application package is created.
+  * ``jars_dir``: Specifies the path to the Qt Android `.jar` files that are relevant for
+    creating the Android application package. This option is automatically computed by
+    ``pyside6-android-deploy`` during deployment. Just like ``recipe_dir``, this field is also
+    *not relevant* unless used with the :ref:`--keep-deployment-files <keep_deployment_files>`
+    option of ``pyside6-android-deploy``.
+  * ``ndk_path``: Specifies the path to the Android NDK used for packaging the application.
+  * ``sdk_path``: Specifies the path to the Android SDK used for packaging the application.
+  * ``local_libs``: Specifies non-Qt plugins or other libraries compatible with the Android target
+    to be loaded by the Android runtime on startup.
+  * ``sdk_path``: Specifies the path to the Android SDK used for packaging the application.
+  * ``arch``: Specifies the target architecture's instruction set. This option take one of the four
+    values - *aarch64, armv7a, i686, x86_64*.
+
+Command Line Options
+====================
+
+Here are all the command line options of ``pyside6-android-deploy``:
+
+* **-c/--config-file**: This option is used to specify the path to ``pysidedeploy.spec`` explicitly.
+
+* **--init**: Used to only create the ``pysidedeploy.spec`` file.
+  Usage::
+
+    pyside6-android-deploy --init
+
+* **-v/--verbose**: Runs ``pyside6-android-deploy`` in verbose mode.
+
+* **--dry-run**: Displays the commands being run to produce the Android application package.
+
+.. _keep_deployment_files:
+
+* **--keep-deployment-files**: When this option is added, it retains the build folders created by
+  `buildozer`_ during the deployment process. This includes the folder storing the
+  `python-for-android`_ recipes, relevant `.jar` files and even the Android Gradle project for the
+  application.
+
+* **-f/--force**: When this option is used, it assumes ``yes`` to all prompts and runs
+  ``pyside6-android-deploy`` non-interactively. ``pyside6-android-deploy`` prompts the user to
+  create a Python virtual environment, if not already in one. With this option, the current Python
+  environment is used irrespective of whether the current Python environment is a virtual
+  environment or not.
+
+* **--name**: Application name.
+
+* **--wheel-pyside**:  Path to the PySide6 Android wheel for a specific target architecture.
+
+* **--wheel-shiboken**: Path to the Shiboken6 Android wheel for a specific target architecture.
+
+* **--ndk-path**:  Path to the Android NDK used for packaging the application.
+
+* **--sdk-path**: Path to the Android SDK used for packaging the application.
+
+* **--extra-ignore-dirs**: Comma-separated directory names inside the project directory. These
+  directories will be skipped when searching for Python files relevant to the project.
+
+* **--extra-modules**:  Comma-separated list of Qt modules to be added to the application,
+  in case they are not found automatically. The module name can either be specified
+  by omitting the prefix of Qt or including it eg: both Network and QtNetwork works.
+
+.. _cross_compile_android:
+
+Cross-compile Qt for Python wheels for Android
+==============================================
+
+The cross-compilation of Qt for Python wheel for a specific Android target architecture needs to be
+done only once per Qt version, irrespective of the number of applications you are deploying.
+Currently, cross-compiling Qt for Python wheels only works with a Linux host. Follow these steps
+to cross-compile Qt for Python Android wheels.
+
+#. `Download <qt_download>`_ and install Qt version for which you would like to create Qt for Python
+   wheels.
+
+#. Cloning the Qt for Python repository::
+
+    git clone https://code.qt.io/pyside/pyside-setup
+
+#. Check out the version that you want to build, for example 6.7. The version checked out has
+   to correspond to the Qt version downloaded in Step 1::
+
+    cd pyside-setup && git checkout 6.7
+
+#. Installing the dependencies::
+
+    pip install -r requirements.txt
+    pip install -r tools/cross_compile_android/requirements.txt
+
+#. Run the cross-compilation Python script.::
+
+    python tools/cross_compile_android/main.py --plat-name=aarch64 --qt-install-path=/opt/Qt/6.7.0
+    --auto-accept-license --skip-update
+
+   *--qt-install-path* refers to the path where Qt 6.7.0 is installed. *--auto-accept-license* and
+   *--skip-update* are required for downloading and installing Android NDK and SDK if not already
+   specified through command line options or if they don't already exist in the
+   ``pyside6-android-deploy`` cache. Use --help to see all the other available options::
+
+     python tools/cross_compile_android/main.py --help
+
+.. _`buildozer`: https://buildozer.readthedocs.io/en/latest/
+.. _`python-for-android`: https://python-for-android.readthedocs.io/en/latest/
+.. _`qt_download`: https://www.qt.io/download
+.. _`cpython`: https://pypi.org/project/Cython/
diff --git a/sources/pyside6/doc/deployment/deployment-pyside6-deploy.rst b/sources/pyside6/doc/deployment/deployment-pyside6-deploy.rst
new file mode 100644
index 000000000..980fe2dd1
--- /dev/null
+++ b/sources/pyside6/doc/deployment/deployment-pyside6-deploy.rst
@@ -0,0 +1,217 @@
+.. _pyside6-deploy:
+
+pyside6-deploy: the deployment tool for Qt for Python
+#####################################################
+
+``pyside6-deploy`` is an easy to use tool for deploying PySide6 applications to different
+platforms. It is a wrapper around `Nuitka <https://nuitka.net/>`_, a Python compiler that
+compiles your Python code to C code, and links with libpython to produce the final executable.
+
+The final executable produced has a ``.exe`` suffix on Windows, ``.bin`` on Linux and ``.app`` on
+macOS.
+
+.. note:: Although using a virtual environment for Python is recommended for ``pyside6-deploy``, do
+    not add the virtual environment to the application directory you are trying to deploy.
+    ``pyside6-deploy`` will try to package this venv folder and will eventually fail.
+
+.. _how_pysidedeploy:
+
+How to use it?
+==============
+
+There are 2 different ways with which you can deploy your PySide6 application using
+``pyside6-deploy``:
+
+Approach 1: Using the main python entry point file
+--------------------------------------------------
+
+In this approach, you point ``pyside6-deploy`` to the file containing the main Python entry point
+file of the project i.e. the file containing ``if __name__ == "__main__":``.
+The command looks like this::
+
+    pyside6-deploy /path/to/main_file.py
+
+On running the command, ``pyside6-deploy`` installs all the dependencies required for deployment
+into the Python environment.
+
+If your main Python entry point file is named ``main.py``, then you don't have to point it to the
+filename. You can run ``pyside6-deploy`` without any options, and it will work.
+
+.. note:: If your project contains a ``pysidedeploy.spec`` file, which is generated on the first
+    run of ``pyside6-deploy`` on the project directory, then for any subsequent runs of
+    ``pyside6-deploy`` you can run ``pyside6-deploy`` without specifying the main Python entry
+    point file. It would take the path to the main file from the ``pysidedeploy.spec`` file.
+    To know more about what deployment parameters are controlled by ``pysidedeploy.spec`` file,
+    read `pysidedeploy`_.
+
+.. _approach_two:
+
+Approach 2: Using pysidedeploy.spec config file
+------------------------------------------------
+
+When you run ``pyside6-deploy`` for the first time, it creates a file called ``pysidedeploy.spec``
+in the project directory. This file controls various :ref:`parameters <pysidedeploy>` that influence
+the deployment process. Any subsequent runs of ``pyside6-deploy`` on the project directory, would
+not require additional parameters like the main Python entry point file. You can also point
+``pyside6-deploy`` to the path of the ``pysidedeploy.spec`` file (in case it is not in the same
+directory), to take the parameters from that file. This can be done with the following command::
+
+    pyside6-deploy -c /path/to/pysidedeploy.spec
+
+.. _pysidedeploy:
+
+pysidedeploy.spec
+=================
+
+As mentioned in the `Approach 2 <approach_two>`_ above, you can use this file to control the various
+parameters of the deployment process. The file has multiple sections, with each section containing
+multiple keys (parameters being controlled) assigned to a value. The advantages of such a file are
+two folds:
+
+.. _pysidedeployspec_advantages:
+
+#. Using the command line, you can control the deployment parameters without specifying them each
+   time. It is saved permanently in a file, and any subsequent runs much later in time
+   would enable the user to be aware of their last deployment parameters.
+
+#. Since these parameters are saved into a file, they can be checked into version control. This
+   gives the user more control of the deployment process. For example, when you decide to exclude
+   more QML plugins, or want to include more Nuitka options into your executable.
+
+This file is also used by the ``pyside6-android-deploy`` tool as a configuration file. The advantage
+here is that you can have one single file to control deployment to all platforms.
+
+The relevant parameters for ``pyside6-deploy`` are:
+
+**app**
+  * ``title``: The name of the application
+  * ``project_dir``: Project directory. The general assumption made is that the project directory
+    is the parent directory of the main Python entry point file
+  * ``input_file``: Path to the main Python entry point file
+  * ``project_file``: If it exists, this points to the path to the `Qt Creator Python Project File
+    .pyproject <https://doc.qt.io/qtforpython-6/faq/typesoffiles.html
+    #qt-creator-python-project-file-pyproject>`_ file. Such a file makes sure that the deployment
+    process never considers unnecessary files when bundling the executable.
+  * ``exec_directory``: The directory where the final executable is generated.
+  * ``icon``: The icon used for the application. For Windows, the icon image should be of ``.ico``
+    format, for macOS it should be of ``.icns`` format, and for linux all standard image formats
+    are accepted.
+
+**python**
+  * ``python_path``: Path to the Python executable. It is recommended to run the deployment
+    process inside a virtual environment as certain python packages will be installed onto the
+    Python environment.
+  * ``packages``: The Python packages installed into the Python environment for deployment to
+    work. By default, the Python packages `nuitka <https://pypi.org/project/Nuitka/>`__,
+    `ordered_set <https://pypi.org/project/ordered-set/>`_ and `zstandard
+    <https://pypi.org/project/zstandard/>`_ are installed. If the deployment platform is
+    Linux-based, then `patchelf <https://pypi.org/project/patchelf/>`_ is also installed
+
+**qt**
+  * ``qml_files``: Comma-separated paths to all the QML files bundled with the executable
+  * ``excluded_qml_plugins``: The problem with using Nuitka for QML deployment is that all the QML
+    plugins are also bundled with the executable. When the plugins are bundled, the binaries of
+    the plugin's Qt module are also packaged. For example, size heavy module like QtWebEngine
+    also gets added to your executable, even when you do not use it in your code. The
+    ``excluded_qml_plugins`` parameter helps you to explicitly specify which all QML plugins are
+    excluded. ``pyside6-deploy`` automatically checks the QML files against the various QML
+    plugins and excludes the following Qt modules if they don't exist::
+
+      QtQuick, QtQuick3D, QtCharts, QtWebEngine, QtTest, QtSensors
+
+    The reason why only the presence of the above 6 Qt modules is searched for is because they
+    have the most size heavy binaries among all the Qt modules. With this, you can drastically
+    reduce the size of your executables.
+  * ``modules``: Comma-separated list of all the Qt modules used by the application. Just like the
+    other configuration options in `pysidedeploy.spec`, this option is also computed automatically
+    by ``pyside6-deploy``. However, if the user wants to explicitly include certain Qt modules, the
+    module names can be appended to this list without the `Qt` prefix.
+    e.g. Network instead of QtNetwork
+  * ``plugins``: Comma-separated list of all the Qt plugins used by the application. Just like the
+    other configuration options in `pysidedeploy.spec`, this option is also computed automatically
+    by ``pyside6-deploy``. However, if the user wants to explicitly include certain Qt plugins,
+    the plugin names can be appended to this list. To see all the plugins bundled with PySide6,
+    see the `plugins` folder in the `site-packages` on your Python where PySide6 is installed. The
+    plugin name correspond to their folder name.
+
+**nuitka**
+  * ``macos.permissions``: Only relevant for macOS. This option lists the  permissions used by the
+    macOS application, as found in the ``Info.plist`` file of the macOS application bundle, using
+    the so-called UsageDescription strings. The permissions are normally automatically found by
+    ``pyside6-deploy``. However the user can also explicitly specify them using the format
+    `<UsageDescriptionKey>:<Short Description>`. For example, the Camera permission is specified
+    as::
+
+      NSCameraUsageDescription:CameraAccess
+
+  * ``extra_args``: Any extra Nuitka arguments specified. It is specified as space-separated
+    command line arguments i.e. just like how you would specify it when you use Nuitka through
+    the command line. By default, it contains the following arguments::
+
+      --quiet --noinclude-qt-translations=True
+
+Command Line Options
+====================
+
+The most important command line options are the path to the main Python entry point file and the
+``pysidedeploy.spec`` file. If neither of these files exists or their command line options are
+given, then ``pyside6-deploy`` assumes that your current working directory does not contain a
+PySide6 project.
+
+Here are all the command line options of ``pyside6-deploy``:
+
+* **main entry point file**: This option does not have a name or a flag and is not restricted by it.
+  This enables ``pyside6-deploy`` to be used like::
+
+    pyside6-deploy /path/to/main_file.py
+
+* **-c/--config-file**: This option is used to specify the path to ``pysidedeploy.spec`` explicitly
+
+* **--init**: Used to only create the ``pysidedeploy.spec`` file
+  Usage::
+
+    pyside6-deploy /path/to/main --init
+
+
+* **-v/--verbose**: Runs ``pyside6-deploy`` in verbose mode.
+
+* **--dry-run**: Displays the final Nuitka command being run.
+
+* **--keep-deployment-files**: When this option is added, it retains the build folders created by
+   Nuitka during the deployment process.
+
+* **-f/--force**: When this option is used, it forces through all the input prompts.
+  ``pyside6-deploy`` prompts the user to create a Python virtual environment, if not already in one.
+  With this option, the current Python environment is used irrespective of whether the current
+  Python environment is a virtual environment or not.
+
+* **--name**: Application name.
+
+* **--extra-ignore-dirs**: Comma-separated directory names inside the project directory. These
+  directories will be skipped when searching for Python files relevant to the project.
+
+* **--extra-modules**:  Comma-separated list of Qt modules to be added to the application,
+  in case they are not found automatically. The module name can either be specified
+  by omitting the prefix of Qt or including it eg: both Network and QtNetwork works.
+
+Considerations
+===============
+
+For deployment to work efficiently by bundling only the necessary plugins, the following utilities
+are required to be installed on the system:
+
+.. list-table::
+   :header-rows: 1
+
+   * - OS
+     - Dependencies
+     - Installation
+   * - Windows
+     - dumpbin
+     - Shipped with MSVC. Run `vcvarsall.bat` to add it to PATH
+   * - Linux
+     - readelf
+     - Available by default
+   * - macOS
+     - dyld_info
+     - Available by default from macOS 12 and upwards
diff --git a/sources/pyside6/doc/deployment/index.rst b/sources/pyside6/doc/deployment/index.rst
index 98b80500b..36e677566 100644
--- a/sources/pyside6/doc/deployment/index.rst
+++ b/sources/pyside6/doc/deployment/index.rst
@@ -15,13 +15,18 @@ Here are a few distribution options that you can use:
  3. Freeze the application into a single binary file or directory.
  4. Provide native installer (msi, dmg)
 
-If you choose Option 3, consider using one of these tools:
- * `fbs`_
- * `PyInstaller`_
- * `cx_Freeze`_
- * `py2exe`_
- * `py2app`_
- * `briefcase`_
+If you are considering Option 3, then starting with 6.4, we ship a new tool called `pyside6-deploy`
+that deploys your PySide6 application to all desktop platforms - Windows, Linux, and macOS. To know
+more about how to use the tool see :ref:`pyside6-deploy`. For Android deployment, see
+:ref:`pyside6-android-deploy`. Additionally, you can also use other popular deployment tools shown
+below:
+
+* `fbs`_
+* `PyInstaller`_
+* `cx_Freeze`_
+* `py2exe`_
+* `py2app`_
+* `briefcase`_
 
 .. _fbs: https://build-system.fman.io/
 .. _PyInstaller: https://www.pyinstaller.org/
@@ -30,8 +35,10 @@ If you choose Option 3, consider using one of these tools:
 .. _py2app: https://py2app.readthedocs.io/en/latest/
 .. _briefcase: https://briefcase.readthedocs.io
 
-Since |project| is a cross-platform framework, we focus on solutions for the three major
-platforms that Qt supports: Windows, Linux, and macOS.
+Although you can deploy PySide6 application using these tools, it is recommended to use
+`pyside6-deploy` as it is easier to use and also to get the most optimized executable. Since
+|project| is a cross-platform framework, we focus on solutions for the three major platforms that
+Qt supports: Windows, Linux, and macOS.
 
 The following table summarizes the platform support for those packaging tools:
 
@@ -138,6 +145,8 @@ Here's a set of tutorials on how to use these tools:
     :name: mastertoc
     :maxdepth: 2
 
+    deployment-pyside6-deploy.rst
+    deployment-pyside6-android-deploy.rst
     deployment-fbs.rst
     deployment-pyinstaller.rst
     deployment-cxfreeze.rst
diff --git a/sources/pyside6/doc/developer/adapt_qt.rst b/sources/pyside6/doc/developer/adapt_qt.rst
new file mode 100644
index 000000000..aec81fb0f
--- /dev/null
+++ b/sources/pyside6/doc/developer/adapt_qt.rst
@@ -0,0 +1,54 @@
+.. _developer-adapt-qt:
+
+Adapt to new Qt versions
+========================
+
+Adapting to source changes
+--------------------------
+
+The dev branch of PySide is switched to a new Qt minor version
+after its API review is finished and the API is stable.
+
+Until that happens, a patch should be continuously developed
+to adapt to this version.
+
+The `new classes page <https://doc-snapshots.qt.io/qt6-6.7/newclasses67.html>`_
+is a good source of information for new API.
+
+New classes and should be added to the type system file (using
+a ``since`` attribute) and ``CMakeList.txt`` file of the respective module.
+
+Should the class not be available on all platforms, the respective
+``QT_CONFIG`` macro needs to be specified in the type system file and
+feature checks need to be added to ``CMakeList.txt`` (see for example
+``QPermission``).
+
+The process consists of running a build and evaluating the log file.
+The script
+`shiboken2tasks.py <https://code.qt.io/cgit/qt-creator/qt-creator.git/tree/scripts/shiboken2tasks.py>`_
+from the *Qt Creator* repository can be used to convert the shiboken warnings
+into a `task file <https://doc.qt.io/qtcreator/creator-task-lists.html>`_
+for display in the build issues pane of *Qt Creator*.
+
+Warnings about new enumerations will be shown there; they should be added
+to type system file using a ``since`` attribute.
+
+Warnings about not finding a function signature for modification
+also need to be handled; mostly this is a sign of a function parameter
+being changed from ``int`` to ``qsizetype`` or similar.
+
+If the build succeeds, a test run should be done.
+
+The Qt source code should be checked for new overloads
+(indicated by ``QT6_DECL_NEW_OVERLOAD_TAIL`` starting from 6.7).
+The resolution needs to be decided for each individual case,
+mostly by removing old functions and using ``<declare-function>``
+to declare new API.
+
+Bumping the version
+-------------------
+
+To instruct ``COIN`` to use the next version of Qt, adapt the files
+``coin/dependencies.yaml`` and/or ``product_dependencies.yaml`` accordingly.
+Next, the wheel names should be changed by adapting
+``sources/shiboken6/.cmake.conf`` and ``sources/pyside6/.cmake.conf``.
diff --git a/sources/pyside6/doc/developer/add_module.rst b/sources/pyside6/doc/developer/add_module.rst
index 321a34723..2eb962207 100644
--- a/sources/pyside6/doc/developer/add_module.rst
+++ b/sources/pyside6/doc/developer/add_module.rst
@@ -18,7 +18,7 @@ Add bindings
 - Add it to ``build_scripts/wheel_files.py`` (plugins, translations).
 - Copy an existing module to ``sources/pyside6/PySide6/<name>``.
 - Adapt the ``typesystem.xml`` and ``CMakeList.txt`` (using for example
-  Qt Creator's case-preserving replace function).
+  *Qt Creator*'s case-preserving replace function).
 - Make sure the dependencies are correct.
 - Find the exported public classes, add them to the ``typesystem.xml`` file,
   checking whether they are ``value-type`` or ``object-type``. Add their enums
@@ -33,8 +33,8 @@ Add bindings
   typically hidden behind a progress message.
 - A convenient way of doing this is using
   ``qt-creator/scripts/shiboken2tasks.py`` from the
-  `Qt Creator repository <https://code.qt.io/cgit/qt-creator/qt-creator.git>`_
-  converting them to a ``.tasks`` file which can be loaded into Qt Creator's
+  `*Qt Creator* repository <https://code.qt.io/cgit/qt-creator/qt-creator.git>`_
+  converting them to a ``.tasks`` file which can be loaded into *Qt Creator*'s
   issue pane.
 - Link errors may manifest when ``generate_pyi`` imports the module trying
   to create signatures. They indicate a missing source file entry
@@ -44,6 +44,15 @@ Add bindings
    of using ``#include <QtModule/header.h>`` since module include paths
    are not passed in PySide.
 
+Distribution
+------------
+
+- Determine to which wheel the module belongs according to
+  `Qt Modules <https://doc.qt.io/qt-6/qtmodules.html>`_.
+- Add the module to ``build_scripts/wheel_files.py`` for use by
+  ``create_wheels.py``.
+- Add the module to one of the ``README.pyside6_*.md`` files.
+
 Add documentation
 -----------------
 
diff --git a/sources/pyside6/doc/developer/add_port_example.rst b/sources/pyside6/doc/developer/add_port_example.rst
index 1188b8c4c..b99641f45 100644
--- a/sources/pyside6/doc/developer/add_port_example.rst
+++ b/sources/pyside6/doc/developer/add_port_example.rst
@@ -10,6 +10,25 @@ You can either design an example from scratch or inspired in another
 application, or simply you can port an existing Qt example that does not have
 a Python counterpart.
 
+Example code should be free of `flake8 <https://pypi.org/project/flake8/>`_
+warnings; this is enforced by a bot. A configuration file is provided
+at the root of the repository. Offending lines can be excluded by a
+``noqa`` directive if there is a good reason to do so.
+
+Keep in mind we do allow 100 columns for line length.
+
+Additionally, please use `isort <https://pypi.org/project/isort/>`_ to keep the
+imports ordered and consistent with other examples.
+
+For example:
+
+.. code-block:: bash
+
+  $ flake8 --config pyside-setup/.flake8 your_file.py
+  $ isort your_file.py
+
+
+
 Add a new example
 -----------------
 
@@ -21,6 +40,13 @@ Add a new example
 - If you want the example to be automatically displayed on the
   example gallery, include a ``doc`` directory that contains a ``rst``
   file and a screenshot. Check other examples for formatting questions.
+- When writing the ``rst`` file, you can include code snippets using
+  the ``literalinclude`` directive specifying the relative path
+  as listed in the ``.pyproject`` file. The `example_gallery` tool will
+  expand this (see the `pointconfiguration` example).
+- For the code displayed in the tabs, you can create ``rstinc`` files
+  in the ``doc`` directory containing some description explaining them
+  (see the `samplebinding` example).
 
 Port a Qt example
 -----------------
@@ -33,7 +59,9 @@ Port a Qt example
 - Add a ``.pyproject`` file (verify later on that docs build).
 - Add a ``doc`` directory and descriptive ``.rst`` file,
   and a screenshot if suitable (use ``optipng`` to reduce file size).
-- Add the """Port of the ... example from Qt 6""" doc string.
+- Add the ``"""Port of the ... example from Qt 6"""`` doc string.
 - Try to port variable and function names to snake case convention.
-- Verify that a flake check is mostly silent.
 - Remove C++ documentation from ``sources/pyside6/doc/additionaldocs.lst``.
+
+.. note:: Example screenshots in ``.png`` should be optimized by
+          running ``optipng -o 7 -strip all``. Alternatively, the ``.webp`` format can be used.
diff --git a/sources/pyside6/doc/developer/add_tool.rst b/sources/pyside6/doc/developer/add_tool.rst
index 4c341eb0a..732e6b915 100644
--- a/sources/pyside6/doc/developer/add_tool.rst
+++ b/sources/pyside6/doc/developer/add_tool.rst
@@ -10,32 +10,42 @@ tools to solve issues, or improve some project workflows.
 Add a new tool
 --------------
 
+Tools not available to end users
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This depicts the tools that are not shipped with Qt for Python wheels and are used to aid
+Qt for Python development
+
 - Place your tool in the ``tools`` directory.
 - If your project has more than one file, create a directory.
 - Create a ``.pyproject`` file including all the relevant files
   for your tool.
-- If you would like to interface the tool for end users,
-  you need to create an entry point for the wheel creation,
-  and also copy the files in the wheel creation process.
-
-
-Add a Qt tool wrapper
----------------------
-
-- Add script and optional library under ``sources/pyside-tools``.
-- Install the files (``sources/pyside-tools/CMakeLists.txt``).
-- Include the tool in the deprecated 'setup.py bdist_wheel' process:
-
-   - Add the tool in ``build_scripts/__init__.py``.
 
-   - Copy the files to the wheels in ``build_scripts/platforms/*.py``.
+Tools available to end users
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-   - Add an entry to ``sources/pyside6/doc/package_details.rst``.
-
-- Include the tool in the new wheel creation process:
+- Place your tool in the ``sources/pyside-tools`` directory.
+- If your project has more than one file, create a directory.
+- Create a ``.pyproject`` file including all the relevant files
+  for your tool.
+- Add the relevant files in ``sources/pyside-tools/CMakeLists.txt``.
+- Add the tool in ``sources/pyside-tools/pyside_tool.py``.
+- Add the tool in ``build_scripts/__init__.py`` to create the setuptools entry points
+  i.e. this enable using the tool from the console as "pyside6-<tool_name>"
+- Add an entry to ``sources/pyside6/doc/gettingstarted/package_details.rst``.
+- Include the necessary Qt binaries explicitly on ``build_scripts/wheel_files.py``
+- Build with ``--standalone``, verify it is working.
 
-   - Add an entry to ``create_wheels.py``.
 
-   - Include the Qt binaries explicitly on ``build_scripts/wheel_files.py``
+Add a Qt tool wrapper
+---------------------
 
-- Build with ``--standalone``, verify it is working.
+- Add the relevant files in ``sources/pyside-tools/CMakeLists.txt``.
+- Add the tool in ``sources/pyside-tools/pyside_tool.py``.
+- Add the tool in ``build_scripts/__init__.py`` to create the setuptools entry points
+  i.e. this enable using the tool from the console as "pyside6-<tool_name>"
+- Add an entry to ``sources/pyside6/doc/tools/index.rst`` and the detailed
+  documentation to ``sources/pyside6/doc/tools/<tool_name>.rst``.
+- Include the necessary Qt binaries explicitly on ``build_scripts/wheel_files.py``
+- Add the necessary files to ``build_scripts/wheel_files.py``.
+- Build with ``--standalone``, verify it is working. Also, check if the wheel bundles the tool.
diff --git a/sources/pyside6/doc/developer/documentation.rst b/sources/pyside6/doc/developer/documentation.rst
new file mode 100644
index 000000000..517bd46f1
--- /dev/null
+++ b/sources/pyside6/doc/developer/documentation.rst
@@ -0,0 +1,73 @@
+.. _developer-documentation:
+
+Fixing Documentation issues
+===========================
+
+Fixing texts
+------------
+
+Shiboken's ``<inject-documentation>`` element can be used to add texts.
+It's ``"replace"`` mode is currently not implemented, though.
+
+Fixing snippets
+---------------
+
+Snippets can replaced by placing a Python equivalent under ``sources/pyside6/doc/snippets``.
+The directory structure matches that of Qt. To replace a snippet with the id `0` in
+``qtbase/examples/foo/snippet.cpp``, place a file ``qtbase/examples/foo/snippet_0.cpp.py``
+under that directory (one snippet per file with the snippet id appended to the base name).
+
+More complicated mappings can be added to ``tools/snippets_translate/override.py``.
+
+# Recreating the module descriptions after a Qt major version change
+
+The source tree contains .rst files containing the module description in
+doc/extras (named for example "QtCore.rst"). They are extracted/adapted from
+the C++ module descriptions. If there is no module description file, shiboken
+will extract the module description from the webxml files generated by qdoc.
+This ends up in the build directory under doc/rst/PySide6/&lt;module&gt;/index.rst.
+It can be used as a starting point for a module description file. C++
+specific information like build instructions should be removed.
+
+The descriptions may link to tutorials which can be added to additionaldocs.lst
+for webxml extraction.
+
+Maintaining additionaldocs.lst
+------------------------------
+
+The file is a list of additional documentation files. These are basically Qt
+tutorials referenced by the documentation. They will receive some Python
+adaption by shiboken/sphinx.
+
+The list can be created by the below script and some hand-editing. It will find
+almost all documents. Quite a number of them might be unreferenced, but there
+is no good way of filtering for this.
+Pages of examples that exist in Python should be removed.
+
+.. code-block:: bash
+
+    for F in *.webxml
+    do
+        echo "$F" | egrep '(-index)|(-module)|(-qmlmodule)\.webxml$' > /dev/null
+        if [ $? -ne 0 ]
+        then
+            if fgrep '<para>' "$F" > /dev/null # Exclude reference only
+            then
+                egrep "(<class )|(<namespace )" $F > /dev/null || echo $F
+            fi
+        fi
+    done
+
+Inheritance graphs
+------------------
+
+``inheritance_diagram.pyproject`` lists the script involved in inheritance
+graph generation, ``inheritance_diagram.py`` being the main one used by sphinx.
+The others have main-test drivers for checking.
+
+There are 2 scripts used for determining the inheritance:
+* ``json_inheritance.py`` (env var ``INHERITANCE_FILE``) reads a
+  inheritance.json file containing the class hierarchy generated by
+  shiboken's doc generator.
+
+* ``import_inheritance.py`` actually tries to import the class (legacy)
diff --git a/sources/pyside6/doc/developer/enumfeatures_doc.rst b/sources/pyside6/doc/developer/enumfeatures_doc.rst
index b3edbe7b6..91b7b6346 100644
--- a/sources/pyside6/doc/developer/enumfeatures_doc.rst
+++ b/sources/pyside6/doc/developer/enumfeatures_doc.rst
@@ -1,3 +1,5 @@
+.. _enum-features:
+
 The Set of Enum Features
 ========================
 
@@ -17,7 +19,7 @@ This is the table of all flags used to control the creation of Python enums.
 ======================  =====  ======================================================
 Flag Name               Value
 ======================  =====  ======================================================
-ENOPT_OLD_ENUM           0x00  (False) Disable new enums
+ENOPT_OLD_ENUM           0x00  (False) No longer possible since PySide 6.6
 ENOPT_NEW_ENUM           0x01  (True) The default for PySide 6.4, full implementation
 ENOPT_INHERIT_INT        0x02  Turn all Enum into IntEnum and Flag into IntFlag
 ENOPT_GLOBAL_SHORTCUT    0x04  Re-add shortcuts for global enums
@@ -29,8 +31,8 @@ ENOPT_NO_MISSING         0x80  Don't allow missing values in Enum
 ======================  =====  ======================================================
 
 Such a set of flags can be defined either by the environment variable
-``PYSIDE63_OPTION_PYTHON_ENUM`` or set by the Python variable
-``sys.pyside63_option_python_enum`` before PySide6 is imported.
+``PYSIDE6_OPTION_PYTHON_ENUM`` or set by the Python variable
+``sys.pyside6_option_python_enum`` before PySide6 is imported.
 The environment variable also supports arbitrary integer expressions
 by using ``ast.literal_eval``.
 
diff --git a/sources/pyside6/doc/developer/extras.rst b/sources/pyside6/doc/developer/extras.rst
index 6b34ea4db..9788b539d 100644
--- a/sources/pyside6/doc/developer/extras.rst
+++ b/sources/pyside6/doc/developer/extras.rst
@@ -8,6 +8,7 @@ it's currently in a different repository (``qt/qtqa``):
   `qtqa repository <https://code.qt.io/cgit/qt/qtqa.git>`_.
 
 To test the wheels:
+
 - Create a virtual environment and activate it.
 - Install the dependencies listed on the ``requirements.txt`` file.
 - Install all the wheels: ``shiboken6``, ``shiboken6-generator``,
@@ -22,3 +23,33 @@ Build on the command line
 =========================
 
 - Consider using ``build_scripts/qp5_tool.py``.
+
+Build with address sanitizer (Linux)
+====================================
+
+ASAN needs to be told to not exit on memory leaks and its library
+needs to be pre-loaded. Assuming the library is found
+at ``/usr/lib/gcc/x86_64-linux-gnu/11``:
+
+.. code-block:: bash
+
+    export ASAN_OPTIONS=detect_leaks=0
+    export LD_PRELOAD=/usr/lib/gcc/x86_64-linux-gnu/11/libasan.so
+    python setup.py build [...] --sanitize-address
+
+De-Virtualize the Python Files
+==============================
+
+The Python files in the Shiboken module are completely virtual, i.E.
+they are nowhere existent in the file system for security reasons.
+
+For debugging purposes or to change something, it might be desirable
+to move these files into the normal file system, again.
+
+- Setting the environment variable "SBK_EMBED" once to false unpacks these
+  files when PySide6 or shiboken6 are imported. The files are written
+  into "side-packages/shiboken6/files.dir" and are used from then on.
+
+- Setting the variable to true removes "files.dir".
+
+- Without the "SBK_EMBED" variable, the embedding status remains sticky.
diff --git a/sources/pyside6/doc/developer/feature-motivation.rst b/sources/pyside6/doc/developer/feature-motivation.rst
index 33bcf1651..1509ea724 100644
--- a/sources/pyside6/doc/developer/feature-motivation.rst
+++ b/sources/pyside6/doc/developer/feature-motivation.rst
@@ -84,12 +84,11 @@ all methods of all classes used in this module are changing their name.
 
 The algorithm to change names is this:
 
- * if the name has less than 3 chars, or
- * if two upper chars are adjacent, or
- * if the name starts with ``gl`` (which marks OpenGL),
- * the name is returned unchanged. Otherwise
-
- * a single upper char ``C`` is replaced by ``_c``
+* if the name has less than 3 chars, or
+* if two upper chars are adjacent, or
+* if the name starts with ``gl`` (which marks OpenGL),
+* the name is returned unchanged. Otherwise
+* a single upper char ``C`` is replaced by ``_c``
 
 
 The true_property feature
@@ -231,8 +230,9 @@ Example:
 .. code-block:: python
 
     >>> from PySide6 import *
+    >>> from PySide6.support.signature import get_signature
     >>> import pprint
-    >>> pprint.pprint(QtCore.QTimer.singleShot.__signature__)
+    >>> pprint.pprint(get_signature(QtCore.QTimer.singleShot))
     [<Signature (arg__1: int, arg__2: Callable) -> None>,
      <Signature (msec: int, receiver: PySide6.QtCore.QObject, member: bytes) -> None>,
      <Signature (msec: int, timerType: PySide6.QtCore.Qt.TimerType,
@@ -284,7 +284,11 @@ a ``QtCore.pyi`` file next to ``QtCore.abi3.so`` or ``QtCore.pyd`` on Windows.
 
 When using ``__feature__`` often with common IDEs, you may want to provide
 a feature-aware version of ``.pyi`` files to get a correct display. The simplest
-way to change them all in-place is the command
+way to change them all in-place is the command:
+
+.. code-block:: bash
+
+    pyside6-genpyi all --feature snake_case true_property
 
 
 Using __feature__ with UIC files
@@ -295,9 +299,5 @@ are _not_ converted, intentionally. Mixing them with feature selections in other
 Python modules should always work, because switching will happen as needed, selected
 by the currently active module. (Please report to us if this fails for an example)
 
-.. code-block:: python
-
-    pyside6-genpyi all --feature snake_case true_property
-
 
 .. _`Import-Hooks`:  https://docs.python.org/3/reference/import.html#import-hooks
diff --git a/sources/pyside6/doc/developer/index.rst b/sources/pyside6/doc/developer/index.rst
index 23bd21681..92c84259d 100644
--- a/sources/pyside6/doc/developer/index.rst
+++ b/sources/pyside6/doc/developer/index.rst
@@ -16,6 +16,8 @@ Development Topics
    add_module.rst
    add_port_example.rst
    add_tool.rst
+   documentation.rst
+   adapt_qt.rst
    extras.rst
 
 Implementation details
diff --git a/sources/pyside6/doc/developer/signature_doc.rst b/sources/pyside6/doc/developer/signature_doc.rst
index 3bd28ad68..a6c703dab 100644
--- a/sources/pyside6/doc/developer/signature_doc.rst
+++ b/sources/pyside6/doc/developer/signature_doc.rst
@@ -136,71 +136,52 @@ Really important are the **parser**, **mapping**, **errorhandler**, **enum_sig**
 or be compatible with embedding and installers.
 
 
-loader.py
-+++++++++
+**loader.py**
+    This module assembles and imports the ``inspect`` module, and then exports the
+    ``create_signature`` function. This function takes a fake function and some
+    attributes and builds a ``__signature__`` object with the inspect module.
 
-This module assembles and imports the ``inspect`` module, and then exports the
-``create_signature`` function. This function takes a fake function and some
-attributes and builds a ``__signature__`` object with the inspect module.
 
+**parser.py**
+    This module takes a class signatures string from C++ and parses it into the
+    needed properties for the ``create_signature`` function. Its entry point is the
+    ``pyside_type_init`` function, which is called from the C module via ``loader.py``.
 
-parser.py
-+++++++++
 
-This module takes a class signatures string from C++ and parses it into the
-needed properties for the ``create_signature`` function. Its entry point is the
-``pyside_type_init`` function, which is called from the C module via ``loader.py``.
+**mapping.py**
+    The purpose of the mapping module is maintaining a list of replacement strings
+    that map from the *signature text* in C to the property strings that Python
+    needs. A lot of mappings are resolved by rather complex expressions in ``parser.py``,
+    but a few hundred cases are better to spell explicitly, here.
 
+**errorhandler.py**
+    Since ``Qt For Python 5.12``, we no longer use the builtin type error messages from C++.
+    Instead, we get much better results with the signature module. At the same time,
+    this enforced supporting shiboken as well, and the signature module was no longer
+    optional.
 
-mapping.py
-++++++++++
+**enum_sig.py**
+    The diverse applications of the signature module all needed to iterate over modules,
+    classes and functions. In order to centralize this enumeration, the process has
+    been factored out as a context manager. The user has only to supply functions
+    that do the actual formatting.
 
-The purpose of the mapping module is maintaining a list of replacement strings
-that map from the *signature text* in C to the property strings that Python
-needs. A lot of mappings are resolved by rather complex expressions in ``parser.py``,
-but a few hundred cases are better to spell explicitly, here.
+    See for example the .pyi generator ``pyside6/PySide6/support/generate_pyi.py``.
 
+**layout.py**
+    As more applications used the signature module, different formatting of signatures
+    was needed. To support that, we created the function ``create_signature``, which
+    has a parameter to choose from some predefined layouts.
 
-errorhandler.py
-+++++++++++++++
 
-Since ``Qt For Python 5.12``, we no longer use the builtin type error messages from C++.
-Instead, we get much better results with the signature module. At the same time,
-this enforced supporting shiboken as well, and the signature module was no longer
-optional.
+**typing27.py**
+    Python 2 has no typing module at all. This is a backport of the minimum that is needed.
 
 
-enum_sig.py
-+++++++++++
-
-The diverse applications of the signature module all needed to iterate over modules,
-classes and functions. In order to centralize this enumeration, the process has
-been factored out as a context manager. The user has only to supply functions
-that do the actual formatting.
-
-See for example the .pyi generator ``pyside6/PySide6/support/generate_pyi.py``.
-
-
-layout.py
-+++++++++
-
-As more applications used the signature module, different formatting of signatures
-was needed. To support that, we created the function ``create_signature``, which
-has a parameter to choose from some predefined layouts.
-
-
-*typing27.py*
-+++++++++++++
-
-Python 2 has no typing module at all. This is a backport of the minimum that is needed.
-
-
-*backport_inspect.py*
-+++++++++++++++++++++
-
-Python 2 has an inspect module, but lacks the signature functions, completely.
-This module adds the missing functionality, which is merged at runtime into
-the inspect module.
+**backport_inspect.py**
+    Python 2 has an inspect module, but lacks the signature functions, completely.
+    This module adds the missing functionality, which is merged at runtime into
+    the inspect module.
 
 
 Multiple Arities
@@ -337,7 +318,7 @@ A shortcut for this command is ``pyside6-genpyi``.
 
 A useful command to change all .pyi files to use all features is
 
-.. code-block:: python
+.. code-block:: bash
 
     pyside6-genpyi all --feature snake_case true_property
 
@@ -372,11 +353,9 @@ This was implemented in ``Qt For Python 5.12.1``.
 Literature
 ----------
 
-    `PEP 362 – Function Signature Object <https://www.python.org/dev/peps/pep-0362/>`__
-
-    `PEP 484 – Type Hints <https://www.python.org/dev/peps/pep-0484/>`__
-
-    `PEP 3107 – Function Annotations <https://www.python.org/dev/peps/pep-3107/>`__
+* `PEP 362 – Function Signature Object <https://www.python.org/dev/peps/pep-0362/>`__
+* `PEP 484 – Type Hints <https://www.python.org/dev/peps/pep-0484/>`__
+* `PEP 3107 – Function Annotations <https://www.python.org/dev/peps/pep-3107/>`__
 
 
 *Personal Remark: This module is dedicated to our lovebird "Püppi", who died on 2017-09-15.*
diff --git a/sources/pyside6/doc/extras/QtBluetooth.rst b/sources/pyside6/doc/extras/QtBluetooth.rst
index dda05f20b..965896752 100644
--- a/sources/pyside6/doc/extras/QtBluetooth.rst
+++ b/sources/pyside6/doc/extras/QtBluetooth.rst
@@ -56,7 +56,7 @@ the environment variable ``QT_EVENT_DISPATCHER_CORE_FOUNDATION=1`` to
 circumvent this issue.
 
 Applications that don't use Classic Bluetooth will find a subset of
-`QtBluetooth <https://doc.qt.io/qt-6/qtbluetooth-module.html>`_ is available,
+`QtBluetooth`_ is available,
 as CoreBluetooth (Bluetooth LE) do not require either of
 :class:`QApplication<PySide6.QtWidgets.QApplication>` or
 :class:`QGuiApplication<PySide6.QtGui.QGuiApplication>` .
@@ -71,32 +71,32 @@ Guides
 Logging Categories
 ^^^^^^^^^^^^^^^^^^
 
-The `QtBluetooth <https://doc.qt.io/qt-6/qtbluetooth-module.html>`_ module
+The `QtBluetooth`_ module
 exports the following :class:`logging categories<~.Configuring Categories>` :
 
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |Logging Category    |Description                                                                                                   |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth        |Enables logging of cross platform code path in `QtBluetooth <https://doc.qt.io/qt-6/qtbluetooth-module.html>`_|
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth.android|Enables logging of the Android implementation                                                                 |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth.bluez  |Enables logging of the BLuez/Linux implementation                                                             |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth.ios    |Enables logging of the iOS implementation                                                                     |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth.osx    |Enables logging of the macOS implementation                                                                   |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
-    |qt.bluetooth.windows|Enables logging of the Qt for Windows implementation                                                          |
-    +--------------------+--------------------------------------------------------------------------------------------------------------+
+    +--------------------+-------------------------------------------------------------+
+    |Logging Category    |Description                                                  |
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth        |Enables logging of cross platform code path in `QtBluetooth`_|
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth.android|Enables logging of the Android implementation                |
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth.bluez  |Enables logging of the BLuez/Linux implementation            |
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth.ios    |Enables logging of the iOS implementation                    |
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth.osx    |Enables logging of the macOS implementation                  |
+    +--------------------+-------------------------------------------------------------+
+    |qt.bluetooth.windows|Enables logging of the Qt for Windows implementation         |
+    +--------------------+-------------------------------------------------------------+
 
 Logging categories can be used to enable additional warning and debug output
-for `QtBluetooth <https://doc.qt.io/qt-6/qtbluetooth-module.html>`_ . More
-detailed information about logging can be found in
+for `QtBluetooth`_ . More detailed information about logging can be found in
 :class:`QLoggingCategory<~.QLoggingCategory>` . A quick way to enable all
-`QtBluetooth <https://doc.qt.io/qt-6/qtbluetooth-module.html>`_ logging is to
-add the following line to the ``main()`` function:
+`QtBluetooth`_ logging is to add the following line to the ``main()``
+function::
 
-    ::
+    QLoggingCategory.setFilterRules("qt.bluetooth* = true")
 
-            QLoggingCategory.setFilterRules("qt.bluetooth* = true")
+
+.. _QtBluetooth: https://doc.qt.io/qt-6/qtbluetooth-module.html
diff --git a/sources/pyside6/doc/extras/QtCharts.rst b/sources/pyside6/doc/extras/QtCharts.rst
index 8ff2a0386..8f2d768bf 100644
--- a/sources/pyside6/doc/extras/QtCharts.rst
+++ b/sources/pyside6/doc/extras/QtCharts.rst
@@ -15,3 +15,7 @@ directive:
         from PySide6 import QtCharts
 
 The module also provides `QML types <https://doc.qt.io/qt-6/qtcharts-qmlmodule.html>`_ .
+
+.. note:: An instance of QApplication is required for the QML types as the
+   module depends on Qt's \l{Graphics View Framework} for rendering.
+   QGuiApplication is not sufficient.
diff --git a/sources/pyside6/doc/extras/QtCore.ClassInfo.rst b/sources/pyside6/doc/extras/QtCore.ClassInfo.rst
index 0cb6d32ed..75445e1fc 100644
--- a/sources/pyside6/doc/extras/QtCore.ClassInfo.rst
+++ b/sources/pyside6/doc/extras/QtCore.ClassInfo.rst
@@ -1,11 +1,9 @@
 .. currentmodule:: PySide6.QtCore
-.. _ClassInfo:
+.. py:decorator:: ClassInfo
 
-ClassInfo
-*********
-
-This class is used to associate extra information to the class, which is available
-using QObject.metaObject(). Qt and PySide doesn't use this information.
+This decorator is used to associate extra information to the class, which is available
+using ``QObject.metaObject()``. This information is used by the
+*Qt D-Bus* and *Qt Qml* modules.
 
 The extra information takes the form of a dictionary with key and value in a literal string.
 
@@ -16,13 +14,13 @@ If the key needs to contain special characters (spaces, commas, '::', start with
 it is also possible to pass a python dictionary with arbitrary strings for both the key and
 value and enabling special characters in the key.
 
-.. note:: This Class is a implementation of Q_CLASSINFO macro.
+.. note:: This decorator is a implementation of the Q_CLASSINFO macro.
 
 
 Example
 -------
 
-::
+.. code-block:: python
 
     # Recommended syntax
     @ClassInfo(Author='PySide Team', URL='http://www.pyside.org')
diff --git a/sources/pyside6/doc/extras/QtCore.Property.rst b/sources/pyside6/doc/extras/QtCore.Property.rst
index 1912b8d23..9ed7de427 100644
--- a/sources/pyside6/doc/extras/QtCore.Property.rst
+++ b/sources/pyside6/doc/extras/QtCore.Property.rst
@@ -1,8 +1,5 @@
 .. currentmodule:: PySide6.QtCore
-.. _Property:
-
-Property
-********
+.. py:class:: Property
 
 Detailed Description
 --------------------
@@ -16,7 +13,7 @@ They are equivalent to the ``Q_PROPERTY`` macro in the `Qt Docs`_.
 Here is an example that illustrates how to use this
 function:
 
-.. code-block::
+.. code-block:: python
    :linenos:
 
     from PySide6.QtCore import QObject, Property
@@ -40,20 +37,20 @@ function:
 
 The full options for ``QtCore.Property`` can be found with ``QtCore.Property.__doc__``:
 
-.. code-block::
-
-   Property(self, type: type,
-            fget: Optional[Callable] = None,
-            fset: Optional[Callable] = None,
-            freset: Optional[Callable] = None,
-            fdel: Optional[Callable] = None,
-            doc: str = '',
-            notify: Optional[Callable] = None,
-            designable: bool = True,
-            scriptable: bool = True,
-            stored: bool = True, user: bool = False,
-            constant: bool = False,
-            final: bool = False) -> PySide6.QtCore.Property
+.. code-block:: python
+
+    Property(self, type: type,
+             fget: Optional[Callable] = None,
+             fset: Optional[Callable] = None,
+             freset: Optional[Callable] = None,
+             fdel: Optional[Callable] = None,
+             doc: str = '',
+             notify: Optional[Callable] = None,
+             designable: bool = True,
+             scriptable: bool = True,
+             stored: bool = True, user: bool = False,
+             constant: bool = False,
+             final: bool = False) -> PySide6.QtCore.Property
 
 Normally, only ``type``, ``fget``and ``fset`` are used.
 
@@ -68,16 +65,16 @@ requires a ``type`` parameter.
 
 In the above example, the following lines would be equivalent properties:
 
-.. code-block::
+.. code-block:: python
 
-        pp = QtCore.Property(int, readPP, setPP)    # PySide version
-        pp = property(readPP, setPP)                # Python version
+    pp = QtCore.Property(int, readPP, setPP)    # PySide version
+    pp = property(readPP, setPP)                # Python version
 
 As you know from the `Python Docs`_, ``Python`` allows to break the property
 creation into multiple steps, using the decorator syntax. We can do this in
 ``PySide`` as well:
 
-.. code-block::
+.. code-block:: python
    :linenos:
 
     from PySide6.QtCore import QObject, Property
@@ -110,12 +107,15 @@ If you are using properties of your objects in QML expressions,
 QML requires that the property changes are notified. Here is an
 example illustrating how to do this:
 
-.. code-block::
+.. code-block:: python
    :linenos:
 
     from PySide6.QtCore import QObject, Signal, Property
 
     class Person(QObject):
+
+        name_changed = Signal()
+
         def __init__(self, name):
             QObject.__init__(self)
             self._person_name = name
@@ -123,10 +123,6 @@ example illustrating how to do this:
         def _name(self):
             return self._person_name
 
-        @Signal
-        def name_changed(self):
-            pass
-
         name = Property(str, _name, notify=name_changed)
 
 .. _`Python Docs`:  https://docs.python.org/3/library/functions.html?highlight=property#property
diff --git a/sources/pyside6/doc/extras/QtCore.QEnum.rst b/sources/pyside6/doc/extras/QtCore.QEnum.rst
index d42da91ab..7ea35d8af 100644
--- a/sources/pyside6/doc/extras/QtCore.QEnum.rst
+++ b/sources/pyside6/doc/extras/QtCore.QEnum.rst
@@ -1,23 +1,19 @@
 .. currentmodule:: PySide6.QtCore
-.. _QEnum:
-
-QEnum/QFlag
-***********
-
-This class decorator is equivalent to the `Q_ENUM` macro from Qt.
-The decorator is used to register an Enum to the meta-object system,
-which is available via `QObject.staticMetaObject`.
-The enumerator must be in a QObject derived class to be registered.
+.. py:decorator:: QEnum
 
+This class decorator is equivalent to the `Q_ENUM` macro from Qt. The decorator
+is used to register a Python Enum derived class to the meta-object system,
+which is available via `QObject.staticMetaObject`. The enumerator must be in a
+QObject derived class to be registered.
 
 Example
 -------
 
 ::
 
-    from enum import Enum, Flag, auto
+    from enum import Enum, auto
 
-    from PySide6.QtCore import QEnum, QFlag, QObject
+    from PySide6.QtCore import QEnum, QObject
 
     class Demo(QObject):
 
@@ -25,67 +21,7 @@ Example
         class Orientation(Enum):
             North, East, South, West = range(4)
 
-        class Color(Flag):
-            RED = auto()
-            BLUE = auto()
-            GREEN = auto()
-            WHITE = RED | BLUE | GREEN
-
-        QFlag(Color)    # identical to @QFlag usage
-
-
-Caution:
---------
-
-QEnum registers a Python Enum derived class.
-QFlag treats a variation of the Python Enum, the Flag class.
-
-Please do not confuse that with the Qt QFlags concept. Python does
-not use that concept, it has its own class hierarchy, instead.
-For more details, see the `Python enum documentation <https://docs.python.org/3/library/enum.html>`_.
-
-
-Details about Qt Flags:
------------------------
-
-There are some small differences between Qt flags and Python flags.
-In Qt, we have for instance these declarations:
-
-::
-
-    enum    QtGui::RenderHint { Antialiasing, TextAntialiasing, SmoothPixmapTransform,
-                                HighQualityAntialiasing, NonCosmeticDefaultPen }
-    flags   QtGui::RenderHints
-
-The equivalent Python notation would look like this:
-
-::
-
-    @QFlag
-    class RenderHints(enum.Flag)
-        Antialiasing = auto()
-        TextAntialiasing = auto()
-        SmoothPixmapTransform = auto()
-        HighQualityAntialiasing = auto()
-        NonCosmeticDefaultPen = auto()
-
-
-As another example, the Qt::AlignmentFlag flag has 'AlignmentFlag' as the enum
-name, but 'Alignment' as the type name. Non flag enums have the same type and
-enum names.
-
-::
-
-    enum Qt::AlignmentFlag
-    flags Qt::Alignment
-
-The Python way to specify this would be
-
-::
-
-    @QFlag
-    class Alignment(enum.Flag):
-        ...
+See :deco:`QFlag` for registering Python Flag derived classes.
 
-Meanwhile we have converted all enums and flags to Python Enums (optional in ``PySide 6.3``,
-default in ``PySide 6.4``), see the :ref:`NewEnumSystem` section.
+Meanwhile all enums and flags have been converted to Python Enums
+(default since ``PySide 6.4``), see the :ref:`NewEnumSystem` section.
diff --git a/sources/pyside6/doc/extras/QtCore.QFlag.rst b/sources/pyside6/doc/extras/QtCore.QFlag.rst
new file mode 100644
index 000000000..dd4f02800
--- /dev/null
+++ b/sources/pyside6/doc/extras/QtCore.QFlag.rst
@@ -0,0 +1,74 @@
+.. currentmodule:: PySide6.QtCore
+.. py:decorator:: QFlag
+
+QFlag handles a variation of the Python Enum, the Flag class.
+
+Please do not confuse that with the Qt QFlags concept. Python does
+not use that concept, it has its own class hierarchy, instead.
+For more details, see the `Python enum documentation <https://docs.python.org/3/library/enum.html>`_.
+
+Example
+-------
+
+::
+
+    from enum import Flag, auto
+
+    from PySide6.QtCore import QFlag, QObject
+
+    class Demo(QObject):
+
+        @QFlag
+        class Color(Flag):
+            RED = auto()
+            BLUE = auto()
+            GREEN = auto()
+            WHITE = RED | BLUE | GREEN
+
+
+Details about Qt Flags:
+-----------------------
+
+There are some small differences between Qt flags and Python flags.
+In Qt, we have for instance these declarations:
+
+::
+
+    enum    QtGui::RenderHint { Antialiasing, TextAntialiasing, SmoothPixmapTransform,
+                                HighQualityAntialiasing, NonCosmeticDefaultPen }
+    flags   QtGui::RenderHints
+
+The equivalent Python notation would look like this:
+
+::
+
+    @QFlag
+    class RenderHints(enum.Flag)
+        Antialiasing = auto()
+        TextAntialiasing = auto()
+        SmoothPixmapTransform = auto()
+        HighQualityAntialiasing = auto()
+        NonCosmeticDefaultPen = auto()
+
+
+As another example, the Qt::AlignmentFlag flag has 'AlignmentFlag' as the enum
+name, but 'Alignment' as the type name. Non flag enums have the same type and
+enum names.
+
+::
+
+    enum Qt::AlignmentFlag
+    flags Qt::Alignment
+
+The Python way to specify this would be
+
+::
+
+    @QFlag
+    class Alignment(enum.Flag):
+        ...
+
+See :deco:`QEnum` for registering Python Enum derived classes.
+
+Meanwhile all enums and flags have been converted to Python Enums
+(default since ``PySide 6.4``), see the :ref:`NewEnumSystem` section.
diff --git a/sources/pyside6/doc/extras/QtCore.Signal.rst b/sources/pyside6/doc/extras/QtCore.Signal.rst
index b50c34148..c83a76a83 100644
--- a/sources/pyside6/doc/extras/QtCore.Signal.rst
+++ b/sources/pyside6/doc/extras/QtCore.Signal.rst
@@ -1,8 +1,5 @@
 .. currentmodule:: PySide6.QtCore
-.. _Signal:
-
-Signal
-******
+.. py:class:: Signal
 
 Synopsis
 --------
@@ -10,19 +7,19 @@ Synopsis
 Functions
 ^^^^^^^^^
 
-+---------------------------------------------------------------------------------------------+
-|def :meth:`connect<Signal.connect>` (receiver)                                               |
-+---------------------------------------------------------------------------------------------+
-|def :meth:`disconnect<Signal.disconnect>` (receiver)                                         |
-+---------------------------------------------------------------------------------------------+
-|def :meth:`emit<Signal.disconnect>` (\*args)                                                 |
-+---------------------------------------------------------------------------------------------+
++-----------------------------------------------------+
+|def :meth:`connect<Signal.connect>` (receiver)       |
++-----------------------------------------------------+
+|def :meth:`disconnect<Signal.disconnect>` (receiver) |
++-----------------------------------------------------+
+|def :meth:`emit<Signal.disconnect>` (\*args)         |
++-----------------------------------------------------+
 
 Detailed Description
 --------------------
 
-    The :class:`~.Signal` class provides a way to declare and connect Qt
-    signals in a pythonic way.
+The :class:`~.Signal` class provides a way to declare and connect Qt
+signals in a pythonic way.
 
 .. class:: PySide6.QtCore.Signal([type1 [, type2...]] [, name="" [, arguments=[]]])
 
diff --git a/sources/pyside6/doc/extras/QtCore.Slot.rst b/sources/pyside6/doc/extras/QtCore.Slot.rst
index 55c3d9fb7..98a1d465b 100644
--- a/sources/pyside6/doc/extras/QtCore.Slot.rst
+++ b/sources/pyside6/doc/extras/QtCore.Slot.rst
@@ -1,53 +1,42 @@
 .. currentmodule:: PySide6.QtCore
-.. _Slot:
+.. py:decorator:: Slot([type1 [, type2...]] [, name="" [, result=None, [tag=""]]])
 
-Slot
-****
+   :param name: str
+   :param result: type
+   :param tag: str
 
-Detailed Description
---------------------
+``Slot`` takes a list of Python types of the arguments.
 
-    PySide6 adopt PyQt's new signal and slot syntax as-is. The PySide6
-    implementation is functionally compatible with the PyQt one, with the
-    exceptions listed below.
+The optional named argument ``name`` defines the slot name. If nothing is
+passed, the slot name will be the decorated function name.
 
-    PyQt's new signal and slot style utilizes method and decorator names
-    specific to their implementation. These will be generalized according to
-    the table below:
+The optional named argument ``result`` specifies the return type.
 
-    =======  =======================  =============
-    Module   PyQt factory function    PySide class
-    =======  =======================  =============
-    QtCore   pyqtSignal               Signal
-    QtCore   pyqtSlot                 Slot
-    =======  =======================  =============
+The optional named argument ``tag`` specifies a value to be returned
+by ``QMetaMethod.tag()``.
 
-    .. class:: PySide6.QtCore.Slot([type1 [, type2...]] [, name="" [, result=None]])
+This implementation is functionally compatible with the PyQt one.
 
-            :param name: str
-            :param result: type
+=======  ===========  ======
+Module   PyQt         PySide
+=======  ===========  ======
+QtCore   pyqtSignal   Signal
+QtCore   pyqtSlot     Slot
+=======  ===========  ======
 
-    ``Slot`` takes a list of Python types of the arguments.
-
-    The optional named argument ``name`` defines the slot name. If nothing is
-    passed, the slot name will be the decorated function name.
-
-    The optional named argument ``result`` specifies the return type.
-
-    .. seealso:: :ref:`signals-and-slots`
+.. seealso:: :ref:`signals-and-slots`
 
 Q_INVOKABLE
 -----------
 
-    There is no equivalent of the Q_INVOKABLE macro of Qt
-    since PySide6 slots can actually have return values.
-    If you need to create a invokable method that returns some value,
-    declare it as a slot, e.g.:
-
-    ::
+There is no equivalent of the Q_INVOKABLE macro of Qt
+since PySide6 slots can actually have return values.
+If you need to create a invokable method that returns some value,
+declare it as a slot, e.g.:
 
-        class Foo(QObject):
+::
 
-            @Slot(float, result=int)
-            def getFloatReturnInt(self, f):
-                return int(f)
+    class Foo(QObject):
+        @Slot(float, result=int)
+        def getFloatReturnInt(self, f):
+            return int(f)
diff --git a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerContainerExtension.rst b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerContainerExtension.rst
index 1baa9e369..a3e5ef511 100644
--- a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerContainerExtension.rst
+++ b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerContainerExtension.rst
@@ -1,10 +1,9 @@
 .. currentmodule:: PySide6.QtDesigner
-.. _QPyDesignerContainerExtension:
-
-QPyDesignerContainerExtension
-*****************************
+.. py:class:: QPyDesignerContainerExtension
 
 QPyDesignerContainerExtension is the base class for implementing
-`QDesignerContainerExtension <https://doc.qt.io/qt-6/qdesignercontainerextension.html>`_
-for a Qt Designer custom widget plugin in Python.
+`QDesignerContainerExtension class`_
+for a *Qt Widgets Designer* custom widget plugin in Python.
 It provides the required inheritance from **QObject**.
+
+.. _QDesignerContainerExtension class: https://doc.qt.io/qt-6/qdesignercontainerextension.html
diff --git a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerCustomWidgetCollection.rst b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerCustomWidgetCollection.rst
index 00260860b..615ca4eec 100644
--- a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerCustomWidgetCollection.rst
+++ b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerCustomWidgetCollection.rst
@@ -1,8 +1,5 @@
 .. currentmodule:: PySide6.QtDesigner
-.. _QPyDesignerCustomWidgetCollection:
-
-QPyDesignerCustomWidgetCollection
-*********************************
+.. py:class:: QPyDesignerCustomWidgetCollection
 
 Synopsis
 --------
@@ -19,20 +16,21 @@ Functions
 Detailed Description
 --------------------
 
-    The :class:`~.QPyDesignerCustomWidgetCollection` implements
-    `QDesignerCustomWidgetCollectionInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetcollectioninterface.html>`_
-    and provides static helper functions for registering custom widgets by
-    type or by implementing
-    `QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_ .
+The :class:`~.QPyDesignerCustomWidgetCollection` implements
+`QDesignerCustomWidgetCollectionInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetcollectioninterface.html>`_
+and provides static helper functions for registering custom widgets by
+type or by implementing
+`QDesignerCustomWidgetInterface`_ .
 
-    The usage is explained in :ref:`designer_custom_widgets`.
+The usage is explained in :ref:`designer_custom_widgets`.
 
 .. py:staticmethod:: QPyDesignerCustomWidgetCollection.registerCustomWidget(type[, xml=""[, tool_tip=""[, icon=""[, group=""[container=False]]]]])
 
-   Registers an instance of a Python-implemented QWidget by type with Qt Designer.
+   Registers an instance of a Python-implemented QWidget by type with
+   *Qt Widgets Designer*.
 
    The optional keyword arguments correspond to the getters of
-   `QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_ :
+   `QDesignerCustomWidgetInterface`_ :
 
    :param str xml: A snippet of XML code in ``.ui`` format that specifies how the widget is created and sets initial property values.
    :param str tool_tip: Tool tip to be shown in the widget box.
@@ -46,7 +44,9 @@ Detailed Description
 .. py:staticmethod:: QPyDesignerCustomWidgetCollection.addCustomWidget(custom_widget)
 
     Adds a custom widget (implementation of
-    `QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_)
-    with Qt Designer.
+    `QDesignerCustomWidgetInterface`_)
+    with *Qt Widgets Designer*.
 
    :param QDesignerCustomWidgetInterface custom_widget: Custom widget instance
+
+.. _QDesignerCustomWidgetInterface: https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html
diff --git a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerMemberSheetExtension.rst b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerMemberSheetExtension.rst
index c52aafdf5..ef2356221 100644
--- a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerMemberSheetExtension.rst
+++ b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerMemberSheetExtension.rst
@@ -1,10 +1,9 @@
 .. currentmodule:: PySide6.QtDesigner
-.. _QPyDesignerMemberSheetExtension:
-
-QPyDesignerMemberSheetExtension
-*******************************
+.. py:class:: QPyDesignerMemberSheetExtension
 
 QPyDesignerMemberSheetExtension is the base class for implementing
-`QDesignerMemberSheetExtension <https://doc.qt.io/qt-6/qdesignermembersheetextension.html>`_
-for a Qt Designer custom widget plugin in Python.
+`QDesignerMemberSheetExtension class`_
+for a *Qt Widgets Designer* custom widget plugin in Python.
 It provides the required inheritance from **QObject**.
+
+.. _QDesignerMemberSheetExtension class: https://doc.qt.io/qt-6/qdesignermembersheetextension.html
diff --git a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerTaskMenuExtension.rst b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerTaskMenuExtension.rst
index 004c94693..e5e13122d 100644
--- a/sources/pyside6/doc/extras/QtDesigner.QPyDesignerTaskMenuExtension.rst
+++ b/sources/pyside6/doc/extras/QtDesigner.QPyDesignerTaskMenuExtension.rst
@@ -1,10 +1,9 @@
 .. currentmodule:: PySide6.QtDesigner
-.. _QPyDesignerTaskMenuExtension:
-
-QPyDesignerTaskMenuExtension
-****************************
+.. py:class:: QPyDesignerTaskMenuExtension
 
 QPyDesignerTaskMenuExtension is the base class for implementing
-`QDesignerTaskMenuExtension <https://doc.qt.io/qt-6/qdesignertaskmenuextension.html>`_
-for a Qt Designer custom widget plugin in Python.
+`QDesignerTaskMenuExtension class`_
+for a *Qt Widgets Designer* custom widget plugin in Python.
 It provides the required inheritance from **QObject**.
+
+.. _QDesignerTaskMenuExtension class: https://doc.qt.io/qt-6/qdesignertaskmenuextension.html
diff --git a/sources/pyside6/doc/extras/QtDesigner.rst b/sources/pyside6/doc/extras/QtDesigner.rst
index c232128dd..844f25b7b 100644
--- a/sources/pyside6/doc/extras/QtDesigner.rst
+++ b/sources/pyside6/doc/extras/QtDesigner.rst
@@ -1,5 +1,6 @@
-Provides classes to create your own custom widget plugins for Qt Designer and
-classes to access Qt Designer components.
+Provides classes to create your own custom widget plugins for
+*Qt Widgets Designer* and classes to access *Qt Widgets Designer*
+components.
 
 In addition, the :class:`QFormBuilder<PySide6.QtDesigner.QFormBuilder>` class
 provides the possibility of constructing user interfaces from UI files at
diff --git a/sources/pyside6/doc/extras/QtMultimedia.rst b/sources/pyside6/doc/extras/QtMultimedia.rst
index f495ddc4e..527c2427b 100644
--- a/sources/pyside6/doc/extras/QtMultimedia.rst
+++ b/sources/pyside6/doc/extras/QtMultimedia.rst
@@ -29,7 +29,7 @@ directive:
 
     import PySide6.QtMultimedia
 
-The module also provides `QML types <https://doc.qt.io/qt-6/qtmultimedia-qmlmodule.html>`_ .
+The module also provides QML `types <https://doc.qt.io/qt-6/qtmultimedia-qmlmodule.html>`_ .
 
 Overviews and Important Topics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,27 +46,38 @@ QML Types
 
 The following table outlines some important QML types.
 
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |Type                                                                           |Description                                                                                                                                                                                                                                             |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`MediaPlayer <https://doc.qt.io/qt-6/qml-qtmultimedia-mediaplayer.html>`_      |Add audio/video playback functionality to a scene.                                                                                                                                                                                                      |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`CaptureSession <https://doc.qt.io/qt-6/qml-qtmultimedia-capturesession.html>`_|Create a session for capturing audio/video.                                                                                                                                                                                                             |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`Camera <https://doc.qt.io/qt-6/qml-qtmultimedia-camera.html>`_                |Access a camera connected to the system.                                                                                                                                                                                                                |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`AudioInput <https://doc.qt.io/qt-6/qml-qtmultimedia-audioinput.html>`_        |Access an audio input (microphone) connected to the system.                                                                                                                                                                                             |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`AudioOutput <https://doc.qt.io/qt-6/qml-qtmultimedia-audiooutput.html>`_      |Access an audio output (speaker, headphone) connected to the system.                                                                                                                                                                                    |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`VideoOutput <https://doc.qt.io/qt-6/qml-qtmultimedia-videooutput.html>`_      |Display video content.                                                                                                                                                                                                                                  |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`MediaRecorder <https://doc.qt.io/qt-6/qml-qtmultimedia-mediarecorder.html>`_  |Record audio/video from the `CaptureSession <https://doc.qt.io/qt-6/qml-qtmultimedia-capturesession.html>`_ .                                                                                                                                           |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`ImageCapture <https://doc.qt.io/qt-6/qml-qtmultimedia-imagecapture.html>`_    |Capture still images from the Camera.                                                                                                                                                                                                                   |
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-    |`Video <https://doc.qt.io/qt-6/qml-qtmultimedia-video.html>`_                  |Add Video playback functionality to a scene. Uses `MediaPlayer <https://doc.qt.io/qt-6/qml-qtmultimedia-mediaplayer.html>`_ and `VideoOutput <https://doc.qt.io/qt-6/qml-qtmultimedia-videooutput.html>`_ types to provide video playback functionality.|
-    +-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    +------------------+---------------------------------------------------------------------+
+    |Type              |Description                                                          |
+    +------------------+---------------------------------------------------------------------+
+    |`MediaPlayer`_    |Add audio/video playback functionality to a scene.                   |
+    +------------------+---------------------------------------------------------------------+
+    |`CaptureSession`_ |Create a session for capturing audio/video.                          |
+    +------------------+---------------------------------------------------------------------+
+    |`Camera`_         |Access a camera connected to the system.                             |
+    +------------------+---------------------------------------------------------------------+
+    |`AudioInput`_     |Access an audio input (microphone) connected to the system.          |
+    +------------------+---------------------------------------------------------------------+
+    |`AudioOutput`_    |Access an audio output (speaker, headphone) connected to the system. |
+    +------------------+---------------------------------------------------------------------+
+    |`VideoOutput`_    |Display video content.                                               |
+    +------------------+---------------------------------------------------------------------+
+    |`MediaRecorder`_  |Record audio/video from the `CaptureSession`_ .                      |
+    +------------------+---------------------------------------------------------------------+
+    |`ImageCapture`_   |Capture still images from the Camera.                                |
+    +------------------+---------------------------------------------------------------------+
+    |`Video`_          |Add Video playback functionality to a scene. Uses `MediaPlayer`_ and |
+    |                  |`VideoOutput`_ types to provide video playback functionality.        |
+    +------------------+---------------------------------------------------------------------+
+
+.. _MediaPlayer: https://doc.qt.io/qt-6/qml-qtmultimedia-mediaplayer.html
+.. _CaptureSession: https://doc.qt.io/qt-6/qml-qtmultimedia-capturesession.html
+.. _Camera: https://doc.qt.io/qt-6/qml-qtmultimedia-camera.html
+.. _AudioInput: https://doc.qt.io/qt-6/qml-qtmultimedia-audioinput.html
+.. _AudioOutput: https://doc.qt.io/qt-6/qml-qtmultimedia-audiooutput.html
+.. _VideoOutput: https://doc.qt.io/qt-6/qml-qtmultimedia-videooutput.html
+.. _MediaRecorder: https://doc.qt.io/qt-6/qml-qtmultimedia-mediarecorder.html
+.. _ImageCapture: https://doc.qt.io/qt-6/qml-qtmultimedia-imagecapture.html
+.. _Video: https://doc.qt.io/qt-6/qml-qtmultimedia-video.html
 
 C++ Classes
 ^^^^^^^^^^^
diff --git a/sources/pyside6/doc/extras/QtQml.ListProperty.rst b/sources/pyside6/doc/extras/QtQml.ListProperty.rst
new file mode 100644
index 000000000..eaa580c68
--- /dev/null
+++ b/sources/pyside6/doc/extras/QtQml.ListProperty.rst
@@ -0,0 +1,24 @@
+.. currentmodule:: PySide6.QtQml
+.. py:class:: ListProperty
+
+    The ``ListProperty`` class allows applications to expose list-like properties of
+    :class:`~PySide6.QtCore.QObject`-derived classes to QML.
+    The usage is shown in the :ref:`qml-object-and-list-property-types-example`
+    and the :ref:`qml-chapter5-listproperties` example.
+
+    .. py:method:: __init__(type, append, count=None, at=None, clear=None, removeLast=None, doc="", notify=None, designable=True, scriptable=True, stored=True, user=False, constant=False, final=False)
+
+      :param type type: Element type
+      :param callable append: A function to append an item
+      :param callable count: A function returning the list count
+      :param callable at: A function returning the item at an index
+      :param callable clear: A function to clear the list
+      :param removeLast: A function to remove the last item
+      :param str doc: Doc string
+      :param Signal notify: A signal emitted when a change occurs
+      :param bool designable: Not used in QML
+      :param bool scriptable: Not used in QML
+      :param bool stored: Whether the property is stored
+      :param bool user: Not used in QML
+      :param bool constant: Whether the property is constant
+      :param bool final: Whether the property is final
diff --git a/sources/pyside6/doc/extras/QtQml.QPyQmlParserStatus.rst b/sources/pyside6/doc/extras/QtQml.QPyQmlParserStatus.rst
index 58f609b03..10dde6b9a 100644
--- a/sources/pyside6/doc/extras/QtQml.QPyQmlParserStatus.rst
+++ b/sources/pyside6/doc/extras/QtQml.QPyQmlParserStatus.rst
@@ -1,10 +1,9 @@
 .. currentmodule:: PySide6.QtQml
-.. _QPyQmlParserStatus:
-
-QPyQmlParserStatus
-******************
+.. py:class:: QPyQmlParserStatus
 
 QPyQmlParserStatus is the base class for implementing
-`QQmlParserStatus <https://doc.qt.io/qt-6/qqmlparserstatus.html>`_
+`QQmlParserStatus class`_ .
 
 It provides the required inheritance from **QObject**.
+
+.. _QQmlParserStatus class: https://doc.qt.io/qt-6/qqmlparserstatus.html
diff --git a/sources/pyside6/doc/extras/QtQml.QPyQmlPropertyValueSource.rst b/sources/pyside6/doc/extras/QtQml.QPyQmlPropertyValueSource.rst
index 576b8baa0..bf7f8e98f 100644
--- a/sources/pyside6/doc/extras/QtQml.QPyQmlPropertyValueSource.rst
+++ b/sources/pyside6/doc/extras/QtQml.QPyQmlPropertyValueSource.rst
@@ -1,10 +1,9 @@
 .. currentmodule:: PySide6.QtQml
-.. _QPyQmlPropertyValueSource:
-
-QPyQmlPropertyValueSource
-*************************
+.. py:class:: QPyQmlPropertyValueSource
 
 QPyQmlPropertyValueSource is the base class for implementing
-`QQmlPropertyValueSource <https://doc.qt.io/qt-6/qqmlpropertyvaluesource.html>`_
+`QQmlPropertyValueSource class`_ .
 
 It provides the required inheritance from **QObject**.
+
+.. _QQmlPropertyValueSource class: https://doc.qt.io/qt-6/qqmlpropertyvaluesource.html
diff --git a/sources/pyside6/doc/extras/QtQml.QmlAnonymous.rst b/sources/pyside6/doc/extras/QtQml.QmlAnonymous.rst
index a805b0763..44aa0ea21 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlAnonymous.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlAnonymous.rst
@@ -1,22 +1,17 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlAnonymous:
-
-QmlAnonymous
-************
-
 .. py:decorator:: QmlAnonymous
 
-   Declares the enclosing type to be available, but anonymous in QML. The type
-   cannot be created or used to declare properties in QML, but when passed from
-   C++, it is recognized. In QML, you can use properties of this type if they
-   are declared in C++.
+Declares the enclosing type to be available, but anonymous in QML. The type
+cannot be created or used to declare properties in QML, but when passed from
+C++, it is recognized. In QML, you can use properties of this type if they
+are declared in C++.
 
-   .. code-block:: python
+.. code-block:: python
 
-      QML_IMPORT_NAME = "com.library.name"
-      QML_IMPORT_MAJOR_VERSION = 1
-      QML_IMPORT_MINOR_VERSION = 0 # Optional
+    QML_IMPORT_NAME = "com.library.name"
+    QML_IMPORT_MAJOR_VERSION = 1
+    QML_IMPORT_MINOR_VERSION = 0 # Optional
 
-      @QmlAnonymous
-      class ClassForQml(QObject):
-          # ...
+    @QmlAnonymous
+    class ClassForQml(QObject):
+        # ...
diff --git a/sources/pyside6/doc/extras/QtQml.QmlAttached.rst b/sources/pyside6/doc/extras/QtQml.QmlAttached.rst
index e3fefb6b2..4331b03f9 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlAttached.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlAttached.rst
@@ -1,9 +1,4 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlAttached:
-
-QmlAttached
-***********
-
 .. py:decorator:: QmlAttached
 
 This decorator declares that the enclosing type attaches the type passed as
diff --git a/sources/pyside6/doc/extras/QtQml.QmlElement.rst b/sources/pyside6/doc/extras/QtQml.QmlElement.rst
index 2746fbc0b..66397b2d9 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlElement.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlElement.rst
@@ -1,30 +1,25 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlElement:
-
-QmlElement
-**********
-
 .. py:decorator:: QmlElement
 
-   This decorator registers a class it is attached to for use in QML, using
-   global variables to specify the import name and version.
+This decorator registers a class it is attached to for use in QML, using
+global variables to specify the import name and version.
 
-   .. code-block:: python
+.. code-block:: python
 
-      QML_IMPORT_NAME = "com.library.name"
-      QML_IMPORT_MAJOR_VERSION = 1
-      QML_IMPORT_MINOR_VERSION = 0 # Optional
+    QML_IMPORT_NAME = "com.library.name"
+    QML_IMPORT_MAJOR_VERSION = 1
+    QML_IMPORT_MINOR_VERSION = 0 # Optional
 
-      @QmlElement
-      class ClassForQml(QObject):
-          # ...
+    @QmlElement
+    class ClassForQml(QObject):
+        # ...
 
-   Afterwards the class may be used in QML:
+Afterwards the class may be used in QML:
 
-   .. code-block:: python
+.. code-block:: python
 
-      import com.library.name 1.0
+    import com.library.name 1.0
 
-      ClassForQml {
-         // ...
-      }
+    ClassForQml {
+       // ...
+    }
diff --git a/sources/pyside6/doc/extras/QtQml.QmlExtended.rst b/sources/pyside6/doc/extras/QtQml.QmlExtended.rst
index f9ed5a106..af113a9c8 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlExtended.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlExtended.rst
@@ -1,9 +1,4 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlExtended:
-
-QmlExtended
-***********
-
 .. py:decorator:: QmlExtended
 
 Declares that the enclosing type uses the type passed as an extension to
diff --git a/sources/pyside6/doc/extras/QtQml.QmlForeign.rst b/sources/pyside6/doc/extras/QtQml.QmlForeign.rst
index c58be3cb9..90b821e9b 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlForeign.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlForeign.rst
@@ -1,33 +1,28 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlForeign:
-
-QmlForeign
-**********
-
 .. py:decorator:: QmlForeign
 
-   This decorator can be used to change the type that is created by QML.
+This decorator can be used to change the type that is created by QML.
 
-   This is useful for registering types that cannot be amended by adding the
-   QmlElement decorator, for example because they belong to 3rdparty libraries.
+This is useful for registering types that cannot be amended by adding the
+QmlElement decorator, for example because they belong to 3rdparty libraries.
 
-   .. code-block:: python
+.. code-block:: python
 
-      QML_IMPORT_NAME = "com.library.name"
-      QML_IMPORT_MAJOR_VERSION = 1
-      QML_IMPORT_MINOR_VERSION = 0 # Optional
+    QML_IMPORT_NAME = "com.library.name"
+    QML_IMPORT_MAJOR_VERSION = 1
+    QML_IMPORT_MINOR_VERSION = 0 # Optional
 
-      @QmlNamedElement("QWidget")
-      @QmlForeign(QWidget)
-      class ForeignWidgetHelperClass(QObject):
+    @QmlNamedElement("QWidget")
+    @QmlForeign(QWidget)
+    class ForeignWidgetHelperClass(QObject):
           ...
 
-   Afterwards the class may be used in QML:
+Afterwards the class may be used in QML:
 
-   .. code-block:: javascript
+.. code-block:: javascript
 
-      import com.library.name 1.0
+    import com.library.name 1.0
 
-      QWidget {
-         // ...
-      }
+    QWidget {
+        // ...
+    }
diff --git a/sources/pyside6/doc/extras/QtQml.QmlNamedElement.rst b/sources/pyside6/doc/extras/QtQml.QmlNamedElement.rst
index d603e2e83..79eb9d7ad 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlNamedElement.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlNamedElement.rst
@@ -1,31 +1,26 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlNamedElement:
-
-QmlNamedElement
-***************
-
 .. py:decorator:: QmlNamedElement
 
-   This decorator registers a class it is attached to for use in QML under
-   a name different from the class name, using global variables to specify
-   the import name and version.
+This decorator registers a class it is attached to for use in QML under
+a name different from the class name, using global variables to specify
+the import name and version.
 
-   .. code-block:: python
+.. code-block:: python
 
-      QML_IMPORT_NAME = "com.library.name"
-      QML_IMPORT_MAJOR_VERSION = 1
-      QML_IMPORT_MINOR_VERSION = 0 # Optional
+    QML_IMPORT_NAME = "com.library.name"
+    QML_IMPORT_MAJOR_VERSION = 1
+    QML_IMPORT_MINOR_VERSION = 0 # Optional
 
-      @QmlNamedElement("ClassForQml")
-      class ClassWithSomeName(QObject):
+    @QmlNamedElement("ClassForQml")
+    class ClassWithSomeName(QObject):
           ...
 
-   Afterwards the class may be used in QML:
+Afterwards the class may be used in QML:
 
-   .. code-block:: javascript
+.. code-block:: javascript
 
-      import com.library.name 1.0
+    import com.library.name 1.0
 
-      ClassForQml {
-         // ...
-      }
+    ClassForQml {
+       // ...
+    }
diff --git a/sources/pyside6/doc/extras/QtQml.QmlSingleton.rst b/sources/pyside6/doc/extras/QtQml.QmlSingleton.rst
index d3d3bf4a7..402c18d55 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlSingleton.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlSingleton.rst
@@ -1,13 +1,8 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlSingleton:
-
-QmlSingleton
-************
-
 .. py:decorator:: QmlSingleton
 
 Declares the decorated type to be a singleton in QML. This only takes effect if
-the type is a Q_OBJECT and is available in QML (by having a QmlElement decorator).
+the type is a QObject and is available in QML (by having a QmlElement decorator).
 The QQmlEngine will try to create a singleton instance using the type's default
 constructor.
 
@@ -20,6 +15,19 @@ constructor.
     @QmlElement
     @QmlSingleton
     class ClassForQml(QObject):
-        # ...
+        ...
+
+It is also possible to use a static ``create()`` method which receives
+the engine as a parameter:
+
+.. code-block:: python
+
+    @QmlElement
+    @QmlSingleton
+    class ClassForQml(QObject):
+
+        @staticmethod
+        def create(engine):
+            ...
 
 .. note:: The order of the decorators matters; ``QmlSingleton`` needs to be preceded by ``QmlElement``.
diff --git a/sources/pyside6/doc/extras/QtQml.QmlUncreatable.rst b/sources/pyside6/doc/extras/QtQml.QmlUncreatable.rst
index 72fde741d..b7a28801f 100644
--- a/sources/pyside6/doc/extras/QtQml.QmlUncreatable.rst
+++ b/sources/pyside6/doc/extras/QtQml.QmlUncreatable.rst
@@ -1,9 +1,4 @@
 .. currentmodule:: PySide6.QtQml
-.. _QmlUncreatable:
-
-QmlUncreatable
-**************
-
 .. py:decorator:: QmlUncreatable
 
 Declares that the decorated type shall not be creatable from QML. This takes
@@ -26,6 +21,6 @@ Passing None or no argument will cause a standard message to be used instead.
     @QmlElement
     @QmlUncreatable("BaseClassForQml is an abstract base class")
     class BaseClassForQml(QObject):
-        # ...
+        ...
 
 .. note:: The order of the decorators matters; ``QmlUncreatable`` needs to be preceded by ``QmlElement``.
diff --git a/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonInstance.rst b/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonInstance.rst
deleted file mode 100644
index 19d59893e..000000000
--- a/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonInstance.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-.. currentmodule:: PySide6.QtQml
-.. _qmlRegisterSingletonInstance:
-
-qmlRegisterSingletonInstance
-****************************
-
-.. py:function:: qmlRegisterSingletonInstance(pytype: type,\
-                                              uri: str,\
-                                              versionMajor: int,\
-                                              versionMinor: int,\
-                                              typeName: str,\
-                                              instanceObject: object) -> int
-
-   :param type pytype: Python class
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str typeName: name exposed to QML
-   :param object instanceObject: singleton object to be registered
-   :return: int (the QML type id)
-
-   This function registers a singleton Python object *instanceObject*, with a particular *uri* and
-   *typeName*. Its version is a combination of *versionMajor* and *versionMinor*.
-
-   Use this function to register an object of the given type *pytype* as a singleton type.
diff --git a/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonType.rst b/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonType.rst
deleted file mode 100644
index 32231a391..000000000
--- a/sources/pyside6/doc/extras/QtQml.qmlRegisterSingletonType.rst
+++ /dev/null
@@ -1,46 +0,0 @@
-.. currentmodule:: PySide6.QtQml
-.. _qmlRegisterSingletonType:
-
-qmlRegisterSingletonType
-************************
-
-.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str) -> int
-
-   :param type pytype: Python class
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str typeName: name exposed to QML
-   :return: int (the QML type id)
-
-   This function registers a Python type as a singleton in the QML system.
-
-   Alternatively, the :ref:`QmlSingleton` decorator can be used.
-
-.. py:function:: qmlRegisterSingletonType(pytype: type, uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int
-
-   :param type pytype: Python class
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str typeName: name exposed to QML
-   :param object callback: Python callable (to handle Python type)
-   :return: int (the QML type id)
-
-   This function registers a Python type as a singleton in the QML system using
-   the provided callback (which gets a QQmlEngine as a parameter) to generate
-   the singleton.
-
-
-.. py:function:: qmlRegisterSingletonType(uri: str, versionMajor: int, versionMinor: int, typeName: str, callback: object) -> int
-
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str typeName: name exposed to QML
-   :param object callback: Python callable (to handle QJSValue)
-   :return: int (the QML type id)
-
-   This function registers a QJSValue as a singleton in the QML system using
-   the provided callback (which gets a QQmlEngine as a parameter) to
-   generate the singleton.
diff --git a/sources/pyside6/doc/extras/QtQml.qmlRegisterType.rst b/sources/pyside6/doc/extras/QtQml.qmlRegisterType.rst
deleted file mode 100644
index 079e15bf1..000000000
--- a/sources/pyside6/doc/extras/QtQml.qmlRegisterType.rst
+++ /dev/null
@@ -1,41 +0,0 @@
-.. currentmodule:: PySide6.QtQml
-.. _qmlRegisterType:
-
-qmlRegisterType
-***************
-
-.. py:function:: qmlRegisterType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str) -> int
-
-   :param type pytype: Python class
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str qmlName: name exposed to QML
-   :return: int (the QML type id)
-
-   This function registers the Python *type* in the QML system with the
-   name *qmlName*, in the library imported from *uri* having the
-   version number composed from *versionMajor* and *versionMinor*.
-
-   For example, this registers a Python class 'MySliderItem' as a QML
-   type named 'Slider' for version '1.0' of a module called
-   'com.mycompany.qmlcomponents':
-
-   ::
-
-       qmlRegisterType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider")
-
-   Once this is registered, the type can be used in QML by importing
-   the specified module name and version number:
-
-   ::
-
-       import com.mycompany.qmlcomponents 1.0
-
-       Slider { ... }
-
-   Note that it's perfectly reasonable for a library to register types
-   to older versions than the actual version of the library.
-   Indeed, it is normal for the new library to allow QML written to
-   previous versions to continue to work, even if more advanced
-   versions of some of its types are available.
diff --git a/sources/pyside6/doc/extras/QtQml.qmlRegisterUncreatableType.rst b/sources/pyside6/doc/extras/QtQml.qmlRegisterUncreatableType.rst
deleted file mode 100644
index be25f5f1e..000000000
--- a/sources/pyside6/doc/extras/QtQml.qmlRegisterUncreatableType.rst
+++ /dev/null
@@ -1,38 +0,0 @@
-.. currentmodule:: PySide6.QtQml
-.. _qmlRegisterUncreatableType:
-
-
-qmlRegisterUncreatableType
-**************************
-
-
-.. py:function:: qmlRegisterUncreatableType(pytype: type, uri: str, versionMajor: int, versionMinor: int, qmlName: str, noCreationReason: str) -> int
-
-
-   :param type pytype: Python class
-   :param str uri: uri to use while importing the component in QML
-   :param int versionMajor: major version
-   :param int versionMinor: minor version
-   :param str qmlName: name exposed to QML
-   :param str noCreationReason: Error message shown when trying to create the QML type
-   :return: int (the QML type id)
-
-   This function registers the Python *type* in the QML system as an uncreatable type with the
-   name *qmlName*, in the library imported from *uri* having the
-   version number composed from *versionMajor* and *versionMinor*,
-   showing *noCreationReason* as an error message when creating the type is attempted.
-
-   For example, this registers a Python class 'MySliderItem' as a QML
-   type named 'Slider' for version '1.0' of a module called
-   'com.mycompany.qmlcomponents':
-
-   ::
-       qmlRegisterUncreatableType(MySliderItem, "com.mycompany.qmlcomponents", 1, 0, "Slider", "Slider cannot be created.")
-
-   Note that it's perfectly reasonable for a library to register types
-   to older versions than the actual version of the library.
-   Indeed, it is normal for the new library to allow QML written to
-   previous versions to continue to work, even if more advanced
-   versions of some of its types are available.
-
-   Alternatively, the :ref:`QmlUncreatable` decorator can be used.
diff --git a/sources/pyside6/doc/extras/QtQuickTest.rst b/sources/pyside6/doc/extras/QtQuickTest.rst
new file mode 100644
index 000000000..52f13590b
--- /dev/null
+++ b/sources/pyside6/doc/extras/QtQuickTest.rst
@@ -0,0 +1,58 @@
+ Qt Quick Test is a unit test framework for QML applications. Test cases are
+ written as JavaScript functions within a QML TestCase type:
+
+.. code-block:: JavaScript
+
+    import QtQuick
+    import QtTest
+
+    TestCase {
+        name: "MathTests"
+
+        function test_math() {
+            compare(2 + 2, 4, "2 + 2 = 4")
+        }
+
+        function test_fail() {
+            compare(2 + 2, 5, "2 + 2 = 5")
+        }
+    }
+
+Functions whose names start with ``test_`` are treated as test cases to be
+executed.
+
+QML API
+^^^^^^^
+
+The `QML types <https://doc.qt.io/qt-6/qttest-qmlmodule.html>`_
+in Qt Quick Test are available through the ``QtTest`` import.
+To use the types, add the following import statement to your ``.qml`` file:
+
+.. code-block:: JavaScript
+
+    import QtTest
+
+Running Tests
+^^^^^^^^^^^^^
+
+Test cases are launched by a harness that consists of the following code:
+
+.. code-block:: Python
+
+    import sys
+    from PySide6.QtQuickTest import QUICK_TEST_MAIN
+
+    QUICK_TEST_MAIN("example", sys.argv)
+
+Where "example" is the identifier to use to uniquely identify this set of
+tests.
+
+Test execution can be controlled by a number of command line options (pass
+``-h`` for help).
+
+Executing Code Before QML Tests
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To execute code before any of the QML tests are run, the
+:py:func:`QUICK_TEST_MAIN_WITH_SETUP` function can be used. This can be useful
+for setting context properties on the QML engine, amongst other things.
diff --git a/sources/pyside6/doc/extras/QtUiTools.loadUiType.rst b/sources/pyside6/doc/extras/QtUiTools.loadUiType.rst
deleted file mode 100644
index 8a8c4bef0..000000000
--- a/sources/pyside6/doc/extras/QtUiTools.loadUiType.rst
+++ /dev/null
@@ -1,36 +0,0 @@
-.. currentmodule:: PySide6.QtUiTools
-.. _loadUiType:
-
-loadUiType
-***********
-
-.. py:function:: loadUiType(uifile: str) -> tuple(object, object)
-
-   :param str uifile: The name of the `.ui` file
-   :return: tuple(object, object)
-
-    This function generates and loads a `.ui` file at runtime, and it returns
-    a `tuple` containing the reference to the Python class, and the base class.
-
-    We recommend not to use this approach as the workflow should be to generate a Python file
-    from the `.ui` file, and then import and load it to use it, but we do understand that
-    there are some corner cases when such functionality is required.
-
-    The internal process relies on `uic` being in the PATH.
-    The `pyside6-uic` wrapper uses a shipped `uic` that is located in the
-    `site-packages/PySide6/uic`, so PATH needs to be updated to use that if there
-    is no `uic` in the system.
-
-    A simple use case is::
-
-        from PySide6.QtUiTools import loadUiType
-
-        generated_class, base_class = loadUiType("themewidget.ui")
-        # the values will be:
-        #  (<class '__main__.Ui_ThemeWidgetForm'>, <class 'PySide6.QtWidgets.QWidget'>)
-
-        widget = base_class()
-        form = generated_class()
-        form.setupUi(widget)
-        # form.a_widget_member.a_method_of_member()
-        widget.show()
diff --git a/sources/pyside6/doc/extras/QtUiTools.rst b/sources/pyside6/doc/extras/QtUiTools.rst
index 6861605bb..e83aa0357 100644
--- a/sources/pyside6/doc/extras/QtUiTools.rst
+++ b/sources/pyside6/doc/extras/QtUiTools.rst
@@ -1,5 +1,5 @@
-Qt Designer forms are processed at run-time to produce
-dynamically-generated user interfaces.  In order to generate a form at
+*Qt Widgets Designer* forms are processed at run-time to produce
+dynamically-generated user interfaces. In order to generate a form at
 run-time, a resource file containing a UI file is needed.
 
 A form loader object, provided by the ``QUiLoader`` class, is used to
diff --git a/sources/pyside6/doc/extras/QtWidgets.rst b/sources/pyside6/doc/extras/QtWidgets.rst
index 8c91d3e31..784421aac 100644
--- a/sources/pyside6/doc/extras/QtWidgets.rst
+++ b/sources/pyside6/doc/extras/QtWidgets.rst
@@ -52,7 +52,7 @@ widget reports its size requirements to the layout through the
 :meth:`sizePolicy<PySide6.QtWidgets.QWidget.sizePolicy>` properties,
 and the layout distributes the available space accordingly.
 
-:ref:`Qt Designer<using_ui_files>` is a powerful tool for interactively
+:ref:`Qt Widgets Designer<using_ui_files>` is a powerful tool for interactively
 creating and arranging widgets in layouts.
 
 Model/View Classes
diff --git a/sources/pyside6/doc/faq.rst b/sources/pyside6/doc/faq.rst
index c1a27b3c2..4171df947 100644
--- a/sources/pyside6/doc/faq.rst
+++ b/sources/pyside6/doc/faq.rst
@@ -23,14 +23,14 @@ Frequently Asked Questions
   Before the official release, everything was in one big wheel, so it made sense to split these
   into separate wheels, each for the major projects currently in development:
 
-   * **pyside6**: contains all the PySide6 modules to use the Qt framework; also depends on the
-     shiboken6 module.
-   * **shiboken6**: contains the shiboken6 module with helper functions for PySide6.
-   * **shiboken6_generator**: contains the generator binary that can work with a C++ project and a
-     typesystem to generate Python bindings.
-     If you want to generate bindings for a Qt/C++ project, there won't be any linking to the Qt
-     shared libraries; you need to do this by hand. We recommend building PySide6 from scratch
-     to have everything properly linked.
+  * **pyside6**: contains all the PySide6 modules to use the Qt framework; also depends on the
+    shiboken6 module.
+  * **shiboken6**: contains the shiboken6 module with helper functions for PySide6.
+  * **shiboken6_generator**: contains the generator binary that can work with a C++ project and a
+    typesystem to generate Python bindings.
+    If you want to generate bindings for a Qt/C++ project, there won't be any linking to the Qt
+    shared libraries; you need to do this by hand. We recommend building PySide6 from scratch
+    to have everything properly linked.
 
 **Why is the shiboken6_generator not installed automatically?**
   It's not necessary to install the shiboken6_generator to use PySide6. The package is a result of
diff --git a/sources/pyside6/doc/faq/typesoffiles.rst b/sources/pyside6/doc/faq/typesoffiles.rst
index 71d38f809..3155b24fc 100644
--- a/sources/pyside6/doc/faq/typesoffiles.rst
+++ b/sources/pyside6/doc/faq/typesoffiles.rst
@@ -36,9 +36,10 @@ functionality to your applications.
 User Interface Definition File ``.ui``
 --------------------------------------
 
-When using Qt Designer, you can create user interfaces using Qt Widgets with
-the WYSIWYG form editor, this interface is represented as a widget tree using
-XML. Here is an extract of the beginning of a ``.ui`` file:
+When using *Qt Widgets Designer*, you can create user interfaces using
+Qt Widgets with the WYSIWYG form editor, this interface is represented
+as a widget tree using XML. Here is an extract of the beginning of a
+``.ui`` file:
 
 .. code-block:: xml
 
@@ -58,7 +59,6 @@ XML. Here is an extract of the beginning of a ``.ui`` file:
        <string>MainWindow</string>
       </property>
       <widget class="QWidget" name="centralWidget">
-    ...
 
 The `pyside6-uic` tool generates Python code from these `.ui` files,
 which you can import from your main files, so it is not necessary
@@ -97,8 +97,8 @@ the QML file, and optionally, elements defined in Python that are exposed
 to QML to be used.
 
 You can write ``.qml`` files by hand, but also you can use tools like the
-QML Designer that is embedded in Qt Creator. Additionally, there are commercial
-tools like Qt Design Studio that allow you to load designs from other design
+*QML Designer* that is embedded in *Qt Creator*. Additionally, there are commercial
+tools like *Qt Design Studio* that allow you to load designs from other design
 applications.
 
 Here you can find an example of how a ``.qml`` file looks like.
@@ -128,11 +128,11 @@ message on it.
 Qt Creator Python Project File ``.pyproject``
 ---------------------------------------------
 
-For Qt Creator to load and handle Python based projects, a special file is
+For *Qt Creator* to load and handle Python based projects, a special file is
 needed, because C++ based projects could be handle from ``.qmake`` or
 ``CMakeLists.txt`` file, which are not used with Python-based projects.
 
-Old versions of Qt Creator, provided a simple format with the ``.pyqtc``
+Old versions of *Qt Creator*, provided a simple format with the ``.pyqtc``
 extension, which were plain-text files with one-file-per-line::
 
     library/server.py
diff --git a/sources/pyside6/doc/faq/whatisqt.rst b/sources/pyside6/doc/faq/whatisqt.rst
index 2dee661a7..3b42a9403 100644
--- a/sources/pyside6/doc/faq/whatisqt.rst
+++ b/sources/pyside6/doc/faq/whatisqt.rst
@@ -25,7 +25,7 @@ As a framework, Qt has many components, which are distributed by components
 and modules, for example, `qtbase <https://code.qt.io/cgit/qt/qtbase.git/>`_
 is the base component that holds many modules, like: ``QtCore``, ``QtGui``,
 ``QtWidgets``, ``QtNetwork``, etc.
-All those  modules contains many classes that you can directly use, like the
+All those modules contains many classes that you can directly use, like the
 case of the `Classes of QtCore <https://doc.qt.io/qt-6/qtcore-module.html>`_
 from which you can find classes like ``QFile``, ``QTime``, ``QByteArray``, etc.
 
@@ -65,8 +65,8 @@ is not to affect the user experience compared to other included applications.
 
 .. note:: You can adapt these applications to use your self-made style, but
    you need to be aware that the goal of Widgets is to respect the system
-   style, be careful when changing colors. Check this `simple tutorial
-   <widgetstyling>`_ on how to do so.
+   style, be careful when changing colors. Check this
+   :ref:`simple tutorial <widgetstyling>` on how to do so.
 
 QML
 ---
diff --git a/sources/pyside6/doc/faq/whatisshiboken.rst b/sources/pyside6/doc/faq/whatisshiboken.rst
index e867fadd4..bf6d19ab3 100644
--- a/sources/pyside6/doc/faq/whatisshiboken.rst
+++ b/sources/pyside6/doc/faq/whatisshiboken.rst
@@ -4,11 +4,9 @@ Binding Generation: What Is Shiboken?
 =====================================
 
 When you install ``PySide6`` you might have notice that also ``Shiboken6``
-is installed as a dependency:
+is installed as a dependency::
 
-.. code-block:: bash
-
-    (env) [qt ~]$ pip install pyside6
+    $ pip install pyside6
     Collecting pyside6
       Downloading PySide6-6.0.0-6.0.0-cp36.cp37.cp38.cp39-abi3-manylinux1_x86_64.whl (170.5 MB)
          |████████████████████████████████| 170.5 MB 42 kB/s
diff --git a/sources/pyside6/doc/faq/whichide.rst b/sources/pyside6/doc/faq/whichide.rst
index ec005a188..3afa79b7f 100644
--- a/sources/pyside6/doc/faq/whichide.rst
+++ b/sources/pyside6/doc/faq/whichide.rst
@@ -4,7 +4,7 @@ Which IDEs Are Compatible?
 ==========================
 
 |project|, as any other Python module, can be used in any Python-compatible
-IDE, but not all of them will provide extra functionality like Qt Creator does.
+IDE, but not all of them will provide extra functionality like *Qt Creator* does.
 
 Besides writing files, there are some external steps you might want to perform
 in order to help the development of your applications:
@@ -15,8 +15,8 @@ From a terminal:
   :command:`pyside6-uic -i form.ui -o ui_form.py`
 * Generating a Python file from a ``.qrc`` file:
   :command:`pyside6-rcc -i resources.qrc -o rc_resources.py`
-* Opening Qt Designer with the command :command:`pyside6-designer` to
-  edit/create ``.ui`` files.
+* Opening *Qt Widgets Designer* with the command :command:`pyside6-designer`
+  to edit/create ``.ui`` files.
 
 External add-ons/plugins from your favorite IDE might include configuration
 steps to run these commands, or open external tools like Designer and
@@ -47,8 +47,10 @@ that you can install from VS Code while writing the following on the Quick Open
 PyCharm
 -------
 
-You can configure PyCharm to enable external tools, in |project| terms, Qt Designer, and
-Qt Creator. Go to ``File > Settings > tools > PyCharm External Tools``, and include the following
+You can configure PyCharm to enable external tools, in |project| terms,
+*Qt Widgets Designer*, and *Qt Creator*. Go to
+``File > Settings > tools > PyCharm External Tools``, and include the following
 information to add them to your project.
-Later, you will be able to right click a ``.ui`` file, and select ``Qt Designer``,
-``pyside6-uic``, or any tool that you configured this way.
+Later, you will be able to right click a ``.ui`` file, and select
+``Qt Widgets Designer``, ``pyside6-uic``, or any tool that you configured this
+way.
diff --git a/sources/pyside6/doc/faq/whyqtforpython.rst b/sources/pyside6/doc/faq/whyqtforpython.rst
index 6046249b9..0f0ab9aaf 100644
--- a/sources/pyside6/doc/faq/whyqtforpython.rst
+++ b/sources/pyside6/doc/faq/whyqtforpython.rst
@@ -10,7 +10,7 @@ Why Qt for Python?
 
     <div style="float: right; padding-left: 20px; max-width: 30%;
     background-color: #e9eff5; padding-top: 5px;">
-      <img src="../../_images/tiobe.png"
+      <img src="../_images/tiobe.png"
           style="width: 90%;"
           alt="TIOBE index for Python" />
       <p style="font-size: 80%;">
@@ -67,13 +67,9 @@ Creating Qt applications in Python requires only a few lines of code,
 and not much configuration is required to execute it. As an /unfair/
 example, let's check the code of a simple hello world application:
 
+.. tab-set::
 
-.. panels::
-   :container: container-lg
-
-   :column: col-lg-6 p-2
-
-   .. tabbed:: C++ Header
+   .. tab-item:: C++ Header
 
        .. code-block:: cpp
 
@@ -96,7 +92,7 @@ example, let's check the code of a simple hello world application:
 
           #endif // MAINWINDOW_H
 
-   .. tabbed:: C++ Implementation
+   .. tab-item::  C++ Implementation
 
        .. code-block:: cpp
 
@@ -115,7 +111,7 @@ example, let's check the code of a simple hello world application:
               m_button->setText("Ready");
           }
 
-   .. tabbed:: C++ Main
+   .. tab-item:: C++ Main
 
        .. code-block:: cpp
 
@@ -130,10 +126,9 @@ example, let's check the code of a simple hello world application:
               return app.exec(d);
           }
 
-   ---
-   :column: col-lg-6 p-2
+.. tab-set::
 
-   .. tabbed:: Python
+   .. tab-item:: Python
 
       .. code-block:: python
 
diff --git a/sources/pyside6/doc/gettingstarted/index.rst b/sources/pyside6/doc/gettingstarted/index.rst
index 36da0bea9..51d8bea26 100644
--- a/sources/pyside6/doc/gettingstarted/index.rst
+++ b/sources/pyside6/doc/gettingstarted/index.rst
@@ -4,7 +4,7 @@ Getting Started
 .. important:: This page is focused on building |project| **from source**.
   If you just want to install |pymodname|, you need to run: :command:`pip install pyside6`.
 
-  For more details, refer to our `Quick Start`_ guide. Additionally, you can check the
+  For more details, refer to our :ref:`quick-start` guide. Additionally, you can check the
   :ref:`FAQ <faq>` related to the project.
 
 .. _Quick Start: quickstart.html
@@ -17,14 +17,16 @@ On **Linux** you might get them with your operating system package manager, on *
 you might get them with ``brew``, and on **Windows** you can download the installer from each
 website.
 
- * **Python**: 3.7+ `[official Python website] <https://www.python.org/downloads/>`_
- * **Qt:** 6.4+ `[online installer] <https://download.qt.io/official_releases/online_installers/>`_
- * **CMake:** 3.18+ `[official CMake website] <https://cmake.org/download/>`_
- * **Git:** 2.0+. `[official Git website] <https://git-scm.com/downloads>`_
- * **libclang:** The libclang library, recommended: version 10 for 6.0+.
-   Prebuilt versions for each OS can be `downloaded here`_.
+* **Python**: 3.9+ `[official Python website] <https://www.python.org/downloads/>`_
+* **Qt:** 6.8+ `[online installer] <https://download.qt.io/official_releases/online_installers/>`_
+* **CMake:** 3.18+ `[official CMake website] <https://cmake.org/download/>`_
+* **Git:** 2.0+. `[official Git website] <https://git-scm.com/downloads>`_
+* **libclang:** The libclang library, recommended: version 16+ for 6.8+.
+  Prebuilt versions for each OS can be `downloaded here`_.
+* Check the `Supported Platforms of Qt`_
 
 .. _downloaded here: https://download.qt.io/development_releases/prebuilt/libclang/
+.. _`Supported Platforms of Qt` : https://doc.qt.io/qt-6/supported-platforms.html
 
 Guides per platform
 -------------------
@@ -41,20 +43,44 @@ Guides per platform
 
 You can refer to the following pages for platform specific instructions:
 
-.. raw:: html
-
-    <table class="special">
-        <colgroup>
-            <col style="width: 200px" />
-            <col style="width: 200px" />
-            <col style="width: 200px" />
-        </colgroup>
-        <tr>
-            <td><a href="gettingstarted-windows.html"><p><strong>Windows</strong></p></a></td>
-            <td><a href="gettingstarted-macOS.html"><p><strong>macOS</strong></p></a></td>
-            <td><a href="gettingstarted-linux.html"><p><strong>Linux</strong></p></a></td>
-        </tr>
-    </table>
+.. grid:: 1 3 3 3
+    :gutter: 2
+
+    .. grid-item-card::
+        :img-top: ../images/windows.svg
+        :class-item: text-center
+
+        +++
+        .. button-ref:: windows
+            :color: primary
+            :outline:
+            :expand:
+
+            Windows
+
+    .. grid-item-card::
+        :img-top: ../images/macos.svg
+        :class-item: text-center
+
+        +++
+        .. button-ref:: macOS
+            :color: primary
+            :outline:
+            :expand:
+
+            macOS
+
+    .. grid-item-card::
+        :img-top: ../images/linux.svg
+        :class-item: text-center
+
+        +++
+        .. button-ref:: linux
+            :color: primary
+            :outline:
+            :expand:
+
+            Linux
 
 .. important:: |project| does not yet support WebAssembly and the mobile operating systems (Android or iOS).
                Most Linux-based embedded OS provide PySide with their official
@@ -78,6 +104,8 @@ using **ninja** (instead of make), and considering only the **module subset** of
 :mod:`QtCore <PySide6.QtCore>`, :mod:`QtGui <PySide6.QtGui>`, and
 :mod:`QtWidgets <PySide6.QtWidgets>`.
 
+`CMake Unity Build Mode`_ is used by default for speed-up.
+
 Other important options to consider are:
  * ``--cmake``, to specify the path to the cmake binary,
  * ``--reuse-build``, to rebuild only the modified files,
@@ -115,7 +143,7 @@ Cross Compilation
 -----------------
 
 Starting from 6.3, it is possible to cross-compile Shiboken (module), and
-PySide.  This functionality is still in Technical Preview, which means it could
+PySide. This functionality is still in Technical Preview, which means it could
 change in the future releases.
 
 .. important:: The only supported configuration is using a host Linux
@@ -149,7 +177,7 @@ Prerequisites
 ~~~~~~~~~~~~~
 
 First and foremost, you need to have access to the target device because you
-need to copy several system files (sysroot).  We recommend a Linux OS that has
+need to copy several system files (sysroot). We recommend a Linux OS that has
 the latest Qt versions, like `Manjaro ARM`_ or `Archlinux ARM`_.
 
 * (target) Install Qt 6.3+ on the system using the package manager.
@@ -162,7 +190,7 @@ the latest Qt versions, like `Manjaro ARM`_ or `Archlinux ARM`_.
 
 After installing these prerequisites, copy the ``target`` sysroot to your
 ``host`` computer. This process is tricky, because copying system files from
-another computer might cause problems with the symbolic links.  Here you
+another computer might cause problems with the symbolic links. Here you
 have two options to achieve that.
 
 Option A: Copying the files
@@ -247,7 +275,7 @@ and unpacked it.
 
 With those compilers, now you need a CMake toolchain file. This is
 a configuration file to set the compilers and sysroot information, together
-with extra options like compilation flags, and other details.  You can use the
+with extra options like compilation flags, and other details. You can use the
 following file as an example, but keep in mind they might vary:
 
 .. code-block:: cmake
@@ -379,20 +407,28 @@ Starting from 6.3, the documentation is not being built by default.
 When using the second option described in this section, make sure to use the
 ``--build-docs`` option.
 
+Install the specific documentation requirements in your Python virtual
+environment::
+
+    pip install -r requirements-doc.txt
+
+You can find the ``requirements-doc.txt`` file in the root of the repository.
+
 Starting from 5.15, there are two options to build the documentation:
 
-1. Building rst-only documentation (no API)
+1. Building the base documentation (no API)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The process of parsing Qt headers to generate the PySide API documentation can take several
-minutes, this means that modifying a specific section of the rst files we currently have, might
-become a hard task.
+minutes, this means that modifying a specific section of the documentation we currently have, might
+become a hard task. You may only care about the base documentation, which comprises all the
+documentation except for the API documentation.
 
-For this, you can install :command:`sphinx` on a virtual environment, and execute the following command::
+To generate this, execute the following command::
 
-    python setup.py build_rst_docs
+    python setup.py build_base_docs
 
-which will generate a ``html/`` directory with the following structure::
+This will generate an ``html/`` directory with the following structure::
 
     html
     └── pyside6
@@ -408,35 +444,30 @@ files.
 This is useful when updating the general sections of the documentation, adding tutorials,
 modifying the build instructions, and more.
 
-.. note:: In case you are interested in generating the Example Gallery, you
-          would need to first run ``python tools/example_gallery/main.py`` to
-          generate the examples ``rst`` for the gallery.
+.. note:: In case you are interested in only generating the Example Gallery,
+          you would need to run ``python tools/example_gallery/main.py`` to
+          generate the examples ``documentation`` for the gallery. This will
+          also be used internally by the ``build_base_docs`` target
 
 
-2. Building the documentation (rst + API)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+2. Building the documentation (Base + API)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The documentation is being generated using **qdoc** to get the API information, and also **sphinx**
 for the local Python related notes.
 
 The system requires the ``libxml2`` and ``libxslt`` libraries.
-In the Python environment, ``graphviz`` needs to be installed on top
-of the modules listed in ``requirements.txt`` before running the
-installation process::
 
-    pip install graphviz
-
-After installing ``graphviz``, the ``dot`` command needs to be in PATH, otherwise,
+After installing ``graphviz`` (included in the ``requirements-doc.txt`` file),
+the ``dot`` command needs to be in PATH, otherwise,
 the process will fail. Installing ``graphviz`` system-wide is also an option.
 
 Since the process relies on a Qt installation, you need to specify where the
-``qtbase`` directory of a Qt source tree is located, either by using
-the command line option ``--qt-src-dir`` or setting the environment variable::
-
-    export QT_SRC_DIR=/path/to/qtbase
+``qtbase`` directory of a Qt source tree is located by passing it to
+the command line option ``--qt-src-dir``.
 
 Once the common ``setup.py`` build process finishes (remember to use
-``--build-docs`` to enable the documentation build, and ``--doc-build-inline``
+``--build-docs`` to enable the documentation build, and ``--doc-build-online``
 to get the HTML files), you can go to the generated
 ``build/<your_env_name>/build/pyside6`` directory, and run::
 
@@ -445,9 +476,9 @@ to get the HTML files), you can go to the generated
 You can add ``-j X``, to perform the build process in parallel with
 X processes.
 
-.. note:: The :command:`apidoc` make target builds offline documentation in QCH (Qt Creator Help)
-   format by default. You can switch to building for the online use with the ``--doc-build-online``
-   configure option.
+.. note:: The :command:`apidoc` make target builds offline documentation in ``QCH``
+   (Qt Compressed Help) format by default. You can switch to building for the
+   online use with the ``--doc-build-online`` configure option.
 
 The target executes several steps:
 
@@ -457,7 +488,7 @@ The target executes several steps:
 
 Re-running the command will not execute step 1 unless the file
 ``qdoc-output/webxml/qtcore-index.webxml`` is removed from the build tree.
-Similarly, step 2 will not be executed unless the file ``rst/PySide6/QtCore/index.rst``
+Similarly, step 2 will not be executed unless the file ``base/PySide6/QtCore/index.rst``
 is removed.
 
 Finally, you will get a ``html`` directory containing all the generated documentation. The offline
@@ -467,21 +498,32 @@ can find ``Shiboken.qch`` in the build directory, ``build/<your_env_name>/build/
 If you want to temporarily change a ``.rst`` file to examine the impact on
 formatting, you can re-run ``sphinx`` in the ``doc`` directory::
 
-    sphinx-build rst html
+    sphinx-build base html
 
 Viewing offline documentation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The offline documentation (QCH) can be viewed using the Qt Creator IDE or Qt Assistant, which is
-a standalone application for viewing QCH files.
+The offline documentation (QCH) can be viewed using the *Qt Creator* IDE or
+*Qt Assistant*, which is a standalone application for viewing QCH files.
 
-To view the QCH using Qt Creator, following the instructions outlined in
-`Using Qt Creator Help Mode <https://doc.qt.io/qtcreator/creator-help.html>`_. If you chose to
-use Qt Assistant instead, use the following command to register the QCH file before launching
-Qt Assistant::
+To view the QCH using *Qt Creator*, following the instructions outlined in
+`Using Qt Creator Help Mode <https://doc.qt.io/qtcreator/creator-help.html>`_.
+If you chose to use *Qt Assistant* instead, use the following command to register
+the QCH file before launching *Qt Assistant*::
 
     assistant -register PySide.qch
 
+Troubleshooting documentation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The documentation uses intersphinx to link from the PySide to the
+Shiboken documentation. This can fail if
+
+* the default ``QCH`` format is used; in which case the required ``objects.inv``
+  files are not generated. Use ``--doc-build-online``.
+* base and full doc builds are mixed, resulting in wrong values for the
+  intersphinx location in the CMake files. Re-run ``cmake`` to fix this.
+
 Using the internal tools
 ------------------------
 
@@ -527,3 +569,4 @@ A set of tools can be found under the ``tools/`` directory inside the ``pyside-s
 .. _repository: https://github.com/liyanage/macosx-shell-scripts/
 .. _`wiki page`: https://wiki.qt.io/Qt_for_Python_Missing_Bindings
 .. _BeautifulSoup: https://www.crummy.com/software/BeautifulSoup/
+.. _`CMake Unity Build Mode` : https://cmake.org/cmake/help/latest/prop_tgt/UNITY_BUILD.html
diff --git a/sources/pyside6/doc/gettingstarted/linux.rst b/sources/pyside6/doc/gettingstarted/linux.rst
index 7d4000da2..eb1b5869d 100644
--- a/sources/pyside6/doc/gettingstarted/linux.rst
+++ b/sources/pyside6/doc/gettingstarted/linux.rst
@@ -4,11 +4,12 @@ Getting Started on Linux
 Requirements
 ------------
 
- * GCC
- * ``sphinx`` package for the documentation (optional).
- * Depending on your linux distribution, the following dependencies might also be required:
+* GCC
+* ``sphinx`` package for the documentation (optional).
+* Depending on your linux distribution, the following dependencies might also be required:
 
-    * ``libgl-dev``, ``python-dev``, ``python-distutils``, and ``python-setuptools``.
+  * ``libgl-dev``, ``python-dev``, and ``python-setuptools``.
+* Check the platform dependencies of `Qt for Linux/X11`_.
 
 Building from source
 --------------------
@@ -29,12 +30,12 @@ Setting up CLANG
 
 If you don't have libclang already in your system, you can download from the Qt servers::
 
-    wget https://download.qt.io/development_releases/prebuilt/libclang/libclang-release_100-based-linux-Rhel7.6-gcc5.3-x86_64.7z
+    wget https://download.qt.io/development_releases/prebuilt/libclang/libclang-release_18.1.5-based-linux-Rhel8.6-gcc10.3-x86_64.7z
 
 Extract the files, and leave it on any desired path, and set the environment
 variable required::
 
-    7z x libclang-release_100-based-linux-Rhel7.6-gcc5.3-x86_64.7z
+    7z x libclang-release_18.1.5-based-linux-Rhel8.6-gcc10.3-x86_64.7z
     export LLVM_INSTALL_DIR=$PWD/libclang
 
 Getting the source
@@ -44,39 +45,43 @@ Cloning the official repository can be done by::
 
     git clone https://code.qt.io/pyside/pyside-setup
 
-Checking out the version that we want to build, for example 6.0::
+Checking out the version that we want to build, for example 6.8::
 
-    cd pyside-setup && git checkout 6.2
+    cd pyside-setup && git checkout 6.8
 
 Install the general dependencies::
 
     pip install -r requirements.txt
 
+For building the documentation::
+
+    pip install -r requirements-doc.txt
+
 .. note:: Keep in mind you need to use the same version as your Qt installation.
-          Additionally, :command:`git checkout -b 6.2 --track origin/6.2` could be a better option
+          Additionally, :command:`git checkout -b 6.8 --track origin/6.8` could be a better option
           in case you want to work on it.
 
 Building and Installing (setuptools)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The `setuptools` approach uses the `setup.py` file to execute the build,
+The ``setuptools`` approach uses the ``setup.py`` file to execute the build,
 install, and packaging steps.
 
 Check your Qt installation path, to specifically use that version of qtpaths to build PySide.
-for example, :command:`/opt/Qt/6.0.0/gcc_64/bin/qtpaths`.
+for example, :command:`/opt/Qt/6.8.0/gcc_64/bin/qtpaths`.
 
 Build can take a few minutes, so it is recommended to use more than one CPU core::
 
-    python setup.py build --qtpaths=/opt/Qt/6.4.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
+    python setup.py build --qtpaths=/opt/Qt/6.8.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
 
 To install on the current directory, just run::
 
-    python setup.py install --qtpaths=/opt/Qt/6.4.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
+    python setup.py install --qtpaths=/opt/Qt/6.8.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
 
 Building and Installing (cmake)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The `setuptools` approach includes internal `CMake` calls when
+The ``setuptools`` approach includes internal ``CMake`` calls when
 building and installing the project, but a CMake-only approach is only
 recommended for packaging the project for distribution builds.
 
@@ -85,7 +90,7 @@ Assumming that Qt is in PATH, for example, the configure step can be done with::
     cmake -B /path/to/the/build/directory \
           -S /path/to/the/pyside-setup \
           -DCMAKE_INSTALL_PREFIX=/where/to/install \
-          -DPYTHON_EXECUTABLE=/path/to/interpreter
+          -DPython_EXECUTABLE=/path/to/interpreter
 
 .. note:: You can add `-DFORCE_LIMITED_API=yes` in case you want to have a
    build which will be compatible with Python 3.7+.
@@ -110,3 +115,5 @@ You can execute one of the examples to verify the process is properly working.
 Remember to properly set the environment variables for Qt and PySide::
 
     python examples/widgets/widgets/tetrix.py
+
+.. _`Qt for Linux/X11`: https://doc.qt.io/qt-6/linux.html
diff --git a/sources/pyside6/doc/gettingstarted/macOS.rst b/sources/pyside6/doc/gettingstarted/macOS.rst
index 7c3784b02..accffbe92 100644
--- a/sources/pyside6/doc/gettingstarted/macOS.rst
+++ b/sources/pyside6/doc/gettingstarted/macOS.rst
@@ -4,14 +4,16 @@ Getting Started on macOS
 Requirements
 ------------
 
- * `XCode`_ 8.2 (macOS 10.11), 8.3.3 (macOS 10.12), 9 (macOS 10.13), 10.1 (macOS 10.14)
- * ``sphinx`` package for the documentation (optional).
- * Depending on your OS, the following dependencies might also be required:
+* `XCode`_ 8.2 (macOS 10.11), 8.3.3 (macOS 10.12), 9 (macOS 10.13), 10.1 (macOS 10.14)
+* ``sphinx`` package for the documentation (optional).
+* Depending on your OS, the following dependencies might also be required:
 
-   * ``libgl-dev``, ``python-dev``, ``python-distutils``, and ``python-setuptools``.
+  * ``libgl-dev``, ``python-dev``, and ``python-setuptools``.
 
-.. _XCode: https://developer.apple.com/xcode/
+* Check the platform dependencies of `Qt for macOS`_.
 
+.. _XCode: https://developer.apple.com/xcode/
+.. _`Qt for macOS`: https://doc.qt.io/qt-6/macos.html
 
 Building from source
 --------------------
@@ -32,12 +34,12 @@ Setting up CLANG
 
 If you don't have libclang already in your system, you can download from the Qt servers::
 
-    wget https://download.qt.io/development_releases/prebuilt/libclang/libclang-release_100-based-mac.7z
+    wget https://download.qt.io/development_releases/prebuilt/libclang/libclang-release_18.1.5-based-macos-universal.7z
 
 Extract the files, and leave it on any desired path, and set the environment
 variable required::
 
-    7z x libclang-release_100-based-mac.7z
+    7z x libclang-release_18.1.5-based-macos-universal.7z
     export LLVM_INSTALL_DIR=$PWD/libclang
 
 Getting PySide
@@ -47,32 +49,36 @@ Cloning the official repository can be done by::
 
     git clone https://code.qt.io/pyside/pyside-setup
 
-Checking out the version that we want to build, for example, 6.2::
+Checking out the version that we want to build, for example, 6.8::
 
-    cd pyside-setup && git checkout 6.2
+    cd pyside-setup && git checkout 6.8
 
 Install the general dependencies::
 
     pip install -r requirements.txt
 
+For building the documentation::
+
+    pip install -r requirements-doc.txt
+
 .. note:: Keep in mind you need to use the same version as your Qt installation
 
 Building PySide
 ~~~~~~~~~~~~~~~
 
 Check your Qt installation path, to specifically use that version of qtpaths to build PySide.
-for example, ``/opt/Qt/6.4.0/gcc_64/bin/qtpaths``.
+for example, ``/opt/Qt/6.8.0/gcc_64/bin/qtpaths``.
 
 Build can take a few minutes, so it is recommended to use more than one CPU core::
 
-    python setup.py build --qtpaths=/opt/Qt/6.4.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
+    python setup.py build --qtpaths=/opt/Qt/6.8.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
 
 Installing PySide
 ~~~~~~~~~~~~~~~~~
 
 To install on the current directory, just run::
 
-    python setup.py install --qtpaths=/opt/Qt/6.4.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
+    python setup.py install --qtpaths=/opt/Qt/6.8.0/gcc_64/bin/qtpaths --build-tests --ignore-git --parallel=8
 
 Test installation
 ~~~~~~~~~~~~~~~~~
diff --git a/sources/pyside6/doc/gettingstarted/package_details.rst b/sources/pyside6/doc/gettingstarted/package_details.rst
index e7cfa2e64..113edb686 100644
--- a/sources/pyside6/doc/gettingstarted/package_details.rst
+++ b/sources/pyside6/doc/gettingstarted/package_details.rst
@@ -71,70 +71,5 @@ which is the original QtCore library.
 Tools Included
 --------------
 
-Following the same idea from the modules, we also include in the packages
-(wheels) Qt tools that are important for any Qt application development
-workflow, like ``uic``, ``rcc``, etc.
-
-All the tools **must** be used from the PySide wrappers, and not directly.
-For example, if exploring the ``site-packages/`` directory on your installation
-you find ``uic.exe`` (on Windows), you should not click on that, and use
-``pyside6-uic.exe`` instead.
-The reason for this is the proper setup of PATHs, plugins, and more,
-to properly work with the installed Python package.
-
-Here you can find all the tools we include in |project| starting
-from 6.3.0, grouped by different topics:
-
-Project development
-~~~~~~~~~~~~~~~~~~~
-
-* ``pyside6-project``, to build Qt Designer forms (``.ui`` files),
-  resource files (``.qrc``) and QML type files (``.qmltype``) from
-  a ``.pyproject`` file.
-
-Widget Development
-~~~~~~~~~~~~~~~~~~
-
-* ``pyside6-designer``, drag-and-drop tool for designing Widget UIs (generates ``.ui`` files).
-* ``pyside6-uic``, to generate Python code from ``.ui`` form files.
-* ``pyside6-rcc``, to generate serialized data from ``.qrc`` resources files.
-  Keep in mind these files can be used in other non-widget projects.
-
-QML Development
-~~~~~~~~~~~~~~~
-
-* ``pyside6-qmllint``, that verifies the syntactic validity of QML files.
-* ``pyside6-qmltyperegistrar``, to read metatypes files and generate
-  files that contain the necessary code to register all the types marked with
-  relevant macros.
-* ``pyside6-qmlimportscanner``, to identify the QML modules imported from a
-    project/QML files and dump the result as a JSON array.
-
-Translations
-~~~~~~~~~~~~
-
-* ``pyside6-linguist``, for translating text in applications.
-* ``pyside6-lrelease``, to create run-time translation files for the application.
-* ``pyside6-lupdate``, to synchronize source code and translations.
-
-Qt Help
-~~~~~~~
-
-* ``pyside6-assistant``, for viewing online documentation in Qt Help file format.
-  Read more about the formats on the `QtHelp Framework`_ page.
-
-.. _`QtHelp Framework`: https://doc.qt.io/qt-6/qthelp-framework.html
-
-PySide Utilities
-~~~~~~~~~~~~~~~~
-
-* ``pyside6-genpyi``, to generate Python stubs (``.pyi`` files) for Qt modules.
-* ``pyside6-metaobjectdump``, a tool to print out the metatype information in
-  JSON to be used as input for ``qmltyperegistrar``.
-
-Deployment
-~~~~~~~~~~
-
-* ``pyside6-deploy``, to deploy desktop applications in Linux, Windows and macOS environments.
-
-
+PySide6 comes bundled with a set of tools that assist in making the development experience with
+PySide6 more efficient. The list of tools can be found :ref:`here <package_tools>`.
diff --git a/sources/pyside6/doc/gettingstarted/porting_from2.rst b/sources/pyside6/doc/gettingstarted/porting_from2.rst
index 2d5c8414f..6699f54e0 100644
--- a/sources/pyside6/doc/gettingstarted/porting_from2.rst
+++ b/sources/pyside6/doc/gettingstarted/porting_from2.rst
@@ -36,14 +36,14 @@ import statements:
 
 .. code-block:: python
 
-    from PySide2.QtWidgets import QApplication...
+    from PySide2.QtWidgets import QApplication
     from PySide2 import QtCore
 
 needs to be changed to:
 
 .. code-block:: python
 
-    from PySide6.QtWidgets import QApplication...
+    from PySide6.QtWidgets import QApplication
     from PySide6 import QtCore
 
 
@@ -66,28 +66,28 @@ Class/Function Deprecations
 Then, the code base needs to be checked for usage of deprecated API and adapted
 accordingly. For example:
 
- * The High DPI scaling attributes ``Qt.AA_EnableHighDpiScaling``,
-   ``Qt.AA_DisableHighDpiScaling`` and ``Qt.AA_UseHighDpiPixmaps`` are
-   deprecated. High DPI is by default enabled in Qt 6 and cannot be turned off.
- * ``QDesktopWidget`` has been removed. ``QScreen`` should be used instead,
-   which can be retrieved using ``QWidget.screen()``,
-   ``QGuiApplication.primaryScreen()`` or ``QGuiApplication.screens()``.
- * ``QFontMetrics.width()`` has been renamed to ``horizontalAdvance()``.
- * ``QMouseEvent.pos()`` and ``QMouseEvent.globalPos()`` returning a ``QPoint``
-   as well as ``QMouseEvent.x()`` and ``QMouseEvent.y()`` returning ``int``
-   are now deprecated. ``QMouseEvent.position()`` and
-   ``QMouseEvent.globalPosition()`` returning a ``QPointF`` should be used
-   instead.
- * ``Qt.MidButton`` has been renamed to ``Qt.MiddleButton``.
- * ``QOpenGLVersionFunctionsFactory.get()`` instead of
-   ``QOpenGLContext.versionFunctions()`` should be used to obtain
-   *Open GL* functions.
- * ``QRegExp`` has been replaced by ``QRegularExpression``.
- * ``QWidget.mapToGlobal()`` and ``QWidget.mapFromGlobal()`` now also accept
-   and return ``QPointF``.
- * Functions named ``exec_`` (classes ``QCoreApplication``, ``QDialog``,
-   ``QEventLoop``) have been renamed to ``exec`` which became possible
-   in Python 3.
+* The High DPI scaling attributes ``Qt.AA_EnableHighDpiScaling``,
+  ``Qt.AA_DisableHighDpiScaling`` and ``Qt.AA_UseHighDpiPixmaps`` are
+  deprecated. High DPI is by default enabled in Qt 6 and cannot be turned off.
+* ``QDesktopWidget`` has been removed. ``QScreen`` should be used instead,
+  which can be retrieved using ``QWidget.screen()``,
+  ``QGuiApplication.primaryScreen()`` or ``QGuiApplication.screens()``.
+* ``QFontMetrics.width()`` has been renamed to ``horizontalAdvance()``.
+* ``QMouseEvent.pos()`` and ``QMouseEvent.globalPos()`` returning a ``QPoint``
+  as well as ``QMouseEvent.x()`` and ``QMouseEvent.y()`` returning ``int``
+  are now deprecated. ``QMouseEvent.position()`` and
+  ``QMouseEvent.globalPosition()`` returning a ``QPointF`` should be used
+  instead.
+* ``Qt.MidButton`` has been renamed to ``Qt.MiddleButton``.
+* ``QOpenGLVersionFunctionsFactory.get()`` instead of
+  ``QOpenGLContext.versionFunctions()`` should be used to obtain
+  *Open GL* functions.
+* ``QRegExp`` has been replaced by ``QRegularExpression``.
+* ``QWidget.mapToGlobal()`` and ``QWidget.mapFromGlobal()`` now also accept
+  and return ``QPointF``.
+* Functions named ``exec_`` (classes ``QCoreApplication``, ``QDialog``,
+  ``QEventLoop``) have been renamed to ``exec`` which became possible
+  in Python 3.
 
 More information can be found in the
 `Porting to Qt 6 <https://doc.qt.io/qt-6/portingguide.html>`_ Guide
diff --git a/sources/pyside6/doc/gettingstarted/windows.rst b/sources/pyside6/doc/gettingstarted/windows.rst
index 5fec92bca..4451bb1fd 100644
--- a/sources/pyside6/doc/gettingstarted/windows.rst
+++ b/sources/pyside6/doc/gettingstarted/windows.rst
@@ -7,15 +7,17 @@ selected when using the online installer.
 Requirements
 ------------
 
- * `MSVC2022`_ or (MSVC2019) for Python 3 on Windows,
- * `OpenSSL`_ (optional for SSL support, Qt must have been configured using the same SSL library).
- * ``sphinx`` package for the documentation (optional).
+* `MSVC2022`_ for Python 3 on Windows,
+* `OpenSSL`_ (optional for SSL support, Qt must have been configured using the same SSL library).
+* ``sphinx`` package for the documentation (optional).
+* Check the platform dependencies of `Qt for Windows`_.
 
-.. note:: Python 3.8.0 was missing some API required for PySide/Shiboken so it's not possible
-    to use it for a Windows build.
+.. note:: The Python provided by the Microsoft Store is not compatible with PySide. Please
+    use https://www.python.org/downloads/ to get a Python Interpreter.
 
 .. _MSVC2022: https://visualstudio.microsoft.com/downloads/
 .. _OpenSSL: https://sourceforge.net/projects/openssl/
+.. _`Qt for Windows`: https://doc.qt.io/qt-6/windows.html
 
 Building from source on Windows 10
 ----------------------------------
@@ -36,7 +38,7 @@ Setting up CLANG
 
 libclang can be downloaded from the
 `Qt servers <https://download.qt.io/development_releases/prebuilt/libclang>`_.
-for example, ``libclang-release_130-based-windows-vs2019_64.7z``.
+for example, ``libclang-release_18.1.5-based-windows-vs2019_64.7z``.
 
 Note that from version 12 onwards, the prebuilt Windows binaries from
 `LLVM <https://www.llvm.org>`_ no longer contain CMake configuration files; so
@@ -55,26 +57,47 @@ Cloning the official repository can be done by::
 
     git clone https://code.qt.io/pyside/pyside-setup
 
-Checking out the version that we want to build, for example, 6.2::
+Checking out the version that we want to build, for example, 6.8::
 
-    cd pyside-setup && git checkout 6.2
+    cd pyside-setup && git checkout 6.8
 
 Install the general dependencies::
 
     pip install -r requirements.txt
 
+For building the documentation::
+
+    pip install -r requirements-doc.txt
+
 .. note:: Keep in mind you need to use the same version as your Qt installation
 
 Building PySide
 ~~~~~~~~~~~~~~~
 
 Check your Qt installation path, to specifically use that version of qtpaths to build PySide.
-for example, ``C:\Qt\6.4.0\msvc2019_64\bin\qtpaths.exe``.
+for example, ``C:\Qt\6.8.0\msvc2019_64\bin\qtpaths.exe``.
 
 Build can take a few minutes, so it is recommended to use more than one CPU core::
 
     python setup.py build --qtpaths=c:\path\to\qtpaths.exe --openssl=c:\path\to\openssl\bin --build-tests --ignore-git --parallel=8
 
+.. _creating_windows_debug_builds:
+
+Creating Debug Builds
+~~~~~~~~~~~~~~~~~~~~~
+
+* Choose *Custom Installation* when installing Python and tick the options for
+  debug binaries and libraries
+
+* Use ``venv`` to create a virtual environment and pass the debug binary::
+
+   python_d.exe -m venv testenv_d
+
+* Use ``python_d.exe`` to invoke ``setup.py``
+
+.. note:: Make sure you add the ``--debug`` option to the ``python setup.py install`` to produce a debug build
+
+
 Installing PySide
 ~~~~~~~~~~~~~~~~~
 
diff --git a/sources/pyside6/doc/images/Examples.svg b/sources/pyside6/doc/images/Examples.svg
index 98116957e..a506e7798 100644
--- a/sources/pyside6/doc/images/Examples.svg
+++ b/sources/pyside6/doc/images/Examples.svg
@@ -1,24 +1,34 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="49px" height="48px" viewBox="0 0 49 48" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <!-- Generator: Sketch 44.1 (41455) - http://www.bohemiancoding.com/sketch -->
-    <title>web-development</title>
-    <desc>Created with Sketch.</desc>
-    <defs>
-        <linearGradient x1="100%" y1="100%" x2="-22.8515625%" y2="-33.2356771%" id="linearGradient-1">
-            <stop stop-color="#6FFF80" offset="0%"></stop>
-            <stop stop-color="#43CE57" offset="37.2587344%"></stop>
-            <stop stop-color="#425FD0" offset="100%"></stop>
-        </linearGradient>
-    </defs>
-    <g id="Mainpage" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Mainpage_Layout_V4_Megamenu" transform="translate(-1084.000000, -1756.000000)" fill="url(#linearGradient-1)">
-            <g id="Content" transform="translate(-44.000000, 1530.000000)">
-                <g id="WhatQtis" transform="translate(194.000000, 0.000000)">
-                    <g id="Block3_Hover" transform="translate(726.316067, 114.000000)">
-                        <path d="M214.4,115.2 C215.2816,115.2 216,115.9176 216,116.8 C216,117.6824 215.2816,118.4 214.4,118.4 C213.5176,118.4 212.8,117.6824 212.8,116.8 C212.8,115.9176 213.5176,115.2 214.4,115.2 L214.4,115.2 Z M217.6,116.8 C217.6,117.6824 218.3176,118.4 219.2,118.4 C220.0816,118.4 220.8,117.6824 220.8,116.8 C220.8,115.9176 220.0816,115.2 219.2,115.2 C218.3176,115.2 217.6,115.9176 217.6,116.8 L217.6,116.8 Z M222.4,116.8 C222.4,117.6824 223.1176,118.4 224,118.4 C224.8816,118.4 225.6,117.6824 225.6,116.8 C225.6,115.9176 224.8816,115.2 224,115.2 C223.1176,115.2 222.4,115.9176 222.4,116.8 L222.4,116.8 Z M215.2,128 L216.8,128 C217.2424,128 217.6,127.6416 217.6,127.2 C217.6,126.7584 217.2424,126.4 216.8,126.4 L215.2,126.4 C214.7576,126.4 214.4,126.7584 214.4,127.2 C214.4,127.6416 214.7576,128 215.2,128 L215.2,128 Z M215.2,131.2 L216.8,131.2 C217.2424,131.2 217.6,130.8416 217.6,130.4 C217.6,129.9584 217.2424,129.6 216.8,129.6 L215.2,129.6 C214.7576,129.6 214.4,129.9584 214.4,130.4 C214.4,130.8416 214.7576,131.2 215.2,131.2 L215.2,131.2 Z M215.2,134.4 L216.8,134.4 C217.2424,134.4 217.6,134.0416 217.6,133.6 C217.6,133.1584 217.2424,132.8 216.8,132.8 L215.2,132.8 C214.7576,132.8 214.4,133.1584 214.4,133.6 C214.4,134.0416 214.7576,134.4 215.2,134.4 L215.2,134.4 Z M215.2,137.6 L216.8,137.6 C217.2424,137.6 217.6,137.2416 217.6,136.8 C217.6,136.3584 217.2424,136 216.8,136 L215.2,136 C214.7576,136 214.4,136.3584 214.4,136.8 C214.4,137.2416 214.7576,137.6 215.2,137.6 L215.2,137.6 Z M215.2,140.8 L216.8,140.8 C217.2424,140.8 217.6,140.4416 217.6,140 C217.6,139.5584 217.2424,139.2 216.8,139.2 L215.2,139.2 C214.7576,139.2 214.4,139.5584 214.4,140 C214.4,140.4416 214.7576,140.8 215.2,140.8 L215.2,140.8 Z M215.2,144 L216.8,144 C217.2424,144 217.6,143.6416 217.6,143.2 C217.6,142.7584 217.2424,142.4 216.8,142.4 L215.2,142.4 C214.7576,142.4 214.4,142.7584 214.4,143.2 C214.4,143.6416 214.7576,144 215.2,144 L215.2,144 Z M215.2,147.2 L216.8,147.2 C217.2424,147.2 217.6,146.8416 217.6,146.4 C217.6,145.9584 217.2424,145.6 216.8,145.6 L215.2,145.6 C214.7576,145.6 214.4,145.9584 214.4,146.4 C214.4,146.8416 214.7576,147.2 215.2,147.2 L215.2,147.2 Z M215.2,150.4 L216.8,150.4 C217.2424,150.4 217.6,150.0416 217.6,149.6 C217.6,149.1584 217.2424,148.8 216.8,148.8 L215.2,148.8 C214.7576,148.8 214.4,149.1584 214.4,149.6 C214.4,150.0416 214.7576,150.4 215.2,150.4 L215.2,150.4 Z M215.2,153.6 L216.8,153.6 C217.2424,153.6 217.6,153.2416 217.6,152.8 C217.6,152.3584 217.2424,152 216.8,152 L215.2,152 C214.7576,152 214.4,152.3584 214.4,152.8 C214.4,153.2416 214.7576,153.6 215.2,153.6 L215.2,153.6 Z M242.4,128 C242.8424,128 243.2,127.6416 243.2,127.2 C243.2,126.7584 242.8424,126.4 242.4,126.4 L239.2,126.4 C238.7576,126.4 238.4,126.7584 238.4,127.2 C238.4,127.6416 238.7576,128 239.2,128 L242.4,128 L242.4,128 Z M235.2,130.4 C235.2,130.8416 235.5576,131.2 236,131.2 L244,131.2 C244.4424,131.2 244.8,130.8416 244.8,130.4 C244.8,129.9584 244.4424,129.6 244,129.6 L236,129.6 C235.5576,129.6 235.2,129.9584 235.2,130.4 L235.2,130.4 Z M220,131.2 L232.8,131.2 C233.2424,131.2 233.6,130.8416 233.6,130.4 C233.6,129.9584 233.2424,129.6 232.8,129.6 L220,129.6 C219.5576,129.6 219.2,129.9584 219.2,130.4 C219.2,130.8416 219.5576,131.2 220,131.2 L220,131.2 Z M220,128 L228,128 C228.4424,128 228.8,127.6416 228.8,127.2 C228.8,126.7584 228.4424,126.4 228,126.4 L220,126.4 C219.5576,126.4 219.2,126.7584 219.2,127.2 C219.2,127.6416 219.5576,128 220,128 L220,128 Z M236,126.4 L231.2,126.4 C230.7576,126.4 230.4,126.7584 230.4,127.2 C230.4,127.6416 230.7576,128 231.2,128 L236,128 C236.4424,128 236.8,127.6416 236.8,127.2 C236.8,126.7584 236.4424,126.4 236,126.4 L236,126.4 Z M248,133.6 C248,133.1584 247.6424,132.8 247.2,132.8 L234.4,132.8 C233.9576,132.8 233.6,133.1584 233.6,133.6 C233.6,134.0416 233.9576,134.4 234.4,134.4 L247.2,134.4 C247.6424,134.4 248,134.0416 248,133.6 L248,133.6 Z M242.4,137.6 C242.8424,137.6 243.2,137.2416 243.2,136.8 C243.2,136.3584 242.8424,136 242.4,136 L236,136 C235.5576,136 235.2,136.3584 235.2,136.8 C235.2,137.2416 235.5576,137.6 236,137.6 L242.4,137.6 L242.4,137.6 Z M220,137.6 L232.8,137.6 C233.2424,137.6 233.6,137.2416 233.6,136.8 C233.6,136.3584 233.2424,136 232.8,136 L220,136 C219.5576,136 219.2,136.3584 219.2,136.8 C219.2,137.2416 219.5576,137.6 220,137.6 L220,137.6 Z M220,134.4 L223.2,134.4 C223.6424,134.4 224,134.0416 224,133.6 C224,133.1584 223.6424,132.8 223.2,132.8 L220,132.8 C219.5576,132.8 219.2,133.1584 219.2,133.6 C219.2,134.0416 219.5576,134.4 220,134.4 L220,134.4 Z M226.4,132.8 C225.9576,132.8 225.6,133.1584 225.6,133.6 C225.6,134.0416 225.9576,134.4 226.4,134.4 L231.2,134.4 C231.6424,134.4 232,134.0416 232,133.6 C232,133.1584 231.6424,132.8 231.2,132.8 L226.4,132.8 L226.4,132.8 Z M237.6,146.4 C237.6,145.9584 237.2424,145.6 236.8,145.6 L234.4,145.6 C233.9576,145.6 233.6,145.9584 233.6,146.4 C233.6,146.8416 233.9576,147.2 234.4,147.2 L236.8,147.2 C237.2424,147.2 237.6,146.8416 237.6,146.4 L237.6,146.4 Z M220,147.2 L223.2,147.2 C223.6424,147.2 224,146.8416 224,146.4 C224,145.9584 223.6424,145.6 223.2,145.6 L220,145.6 C219.5576,145.6 219.2,145.9584 219.2,146.4 C219.2,146.8416 219.5576,147.2 220,147.2 L220,147.2 Z M231.2,145.6 L226.4,145.6 C225.9576,145.6 225.6,145.9584 225.6,146.4 C225.6,146.8416 225.9576,147.2 226.4,147.2 L231.2,147.2 C231.6424,147.2 232,146.8416 232,146.4 C232,145.9584 231.6424,145.6 231.2,145.6 L231.2,145.6 Z M220,150.4 L229.6,150.4 C230.0424,150.4 230.4,150.0416 230.4,149.6 C230.4,149.1584 230.0424,148.8 229.6,148.8 L220,148.8 C219.5576,148.8 219.2,149.1584 219.2,149.6 C219.2,150.0416 219.5576,150.4 220,150.4 L220,150.4 Z M232.8,150.4 L234.4,150.4 C234.8424,150.4 235.2,150.0416 235.2,149.6 C235.2,149.1584 234.8424,148.8 234.4,148.8 L232.8,148.8 C232.3576,148.8 232,149.1584 232,149.6 C232,150.0416 232.3576,150.4 232.8,150.4 L232.8,150.4 Z M220,153.6 L224.8,153.6 C225.2424,153.6 225.6,153.2416 225.6,152.8 C225.6,152.3584 225.2424,152 224.8,152 L220,152 C219.5576,152 219.2,152.3584 219.2,152.8 C219.2,153.2416 219.5576,153.6 220,153.6 L220,153.6 Z M227.2,152.8 C227.2,153.2416 227.5576,153.6 228,153.6 L236,153.6 C236.4424,153.6 236.8,153.2416 236.8,152.8 C236.8,152.3584 236.4424,152 236,152 L228,152 C227.5576,152 227.2,152.3584 227.2,152.8 L227.2,152.8 Z M244.8,140 C244.8,139.5584 244.4424,139.2 244,139.2 L231.2,139.2 C230.7576,139.2 230.4,139.5584 230.4,140 C230.4,140.4416 230.7576,140.8 231.2,140.8 L244,140.8 C244.4424,140.8 244.8,140.4416 244.8,140 L244.8,140 Z M239.2,143.2 C239.2,142.7584 238.8424,142.4 238.4,142.4 L232.8,142.4 C232.3576,142.4 232,142.7584 232,143.2 C232,143.6416 232.3576,144 232.8,144 L238.4,144 C238.8424,144 239.2,143.6416 239.2,143.2 L239.2,143.2 Z M220,144 L229.6,144 C230.0424,144 230.4,143.6416 230.4,143.2 C230.4,142.7584 230.0424,142.4 229.6,142.4 L220,142.4 C219.5576,142.4 219.2,142.7584 219.2,143.2 C219.2,143.6416 219.5576,144 220,144 L220,144 Z M220,140.8 L228,140.8 C228.4424,140.8 228.8,140.4416 228.8,140 C228.8,139.5584 228.4424,139.2 228,139.2 L220,139.2 C219.5576,139.2 219.2,139.5584 219.2,140 C219.2,140.4416 219.5576,140.8 220,140.8 L220,140.8 Z M256,149.6 L256,152.8 C256,153.2416 255.6424,153.6 255.2,153.6 L253.9816,153.6 C253.8976,153.8384 253.8008,154.072 253.692,154.3 L254.5528,155.1608 C254.8656,155.4736 254.8656,155.98 254.5528,156.292 L252.2904,158.5544 C252.1408,158.7048 251.9376,158.7888 251.7248,158.7888 C251.5128,158.7888 251.3096,158.7048 251.1592,158.5544 L250.2976,157.6928 C250.0704,157.8008 249.8376,157.8976 249.5992,157.9816 L249.5992,159.2 C249.5992,159.6416 249.2416,160 248.7992,160 L245.5992,160 C245.1568,160 244.7992,159.6416 244.7992,159.2 L244.7992,157.9816 C244.5616,157.8976 244.3288,157.8008 244.1008,157.692 L243.24,158.5528 C242.94,158.8528 242.4088,158.8528 242.1088,158.5528 L239.8464,156.2904 C239.5336,155.9784 239.5336,155.472 239.8464,155.1592 L240.7072,154.2984 C240.5992,154.0704 240.5024,153.8376 240.4184,153.6 L239.2,153.6 C238.7576,153.6 238.4,153.2416 238.4,152.8 L238.4,149.6 C238.4,149.1584 238.7576,148.8 239.2,148.8 L240.4184,148.8 C240.5024,148.5616 240.5992,148.328 240.708,148.1 L239.8472,147.2392 C239.5344,146.9264 239.5344,146.42 239.8472,146.108 L242.1088,143.8456 C242.4088,143.5456 242.94,143.5456 243.24,143.8456 L244.1016,144.7072 C244.3288,144.5984 244.5624,144.5016 244.8008,144.4176 L244.8008,143.2 C244.8008,142.7584 245.1584,142.4 245.6008,142.4 L248.8,142.4 C249.2424,142.4 249.6,142.7584 249.6,143.2 L249.6,144.4176 C249.8384,144.5016 250.072,144.5984 250.2984,144.7064 L251.16,143.8456 C251.4728,143.5344 251.9792,143.5336 252.2912,143.8464 L254.5536,146.1088 C254.8664,146.4208 254.8664,146.9272 254.5536,147.24 L253.6928,148.1008 C253.8016,148.3288 253.8976,148.5624 253.9816,148.8 L255.2,148.8 C255.6424,148.8 256,149.1584 256,149.6 L256,149.6 Z M254.4,150.4 L253.3896,150.4 C253.0248,150.4 252.7064,150.1528 252.6152,149.7992 C252.4848,149.2928 252.2848,148.8088 252.0192,148.3608 C251.8344,148.0464 251.8848,147.6464 252.1432,147.388 L252.8568,146.6744 L251.7256,145.5432 L251.012,146.2568 C250.7528,146.5144 250.352,146.5648 250.0392,146.3792 C249.5928,146.116 249.1088,145.916 248.6,145.784 C248.2472,145.6928 248,145.3744 248,145.0096 L248,144 L246.4008,144 L246.4008,145.0096 C246.4008,145.3744 246.1536,145.6928 245.8008,145.784 C245.292,145.916 244.8072,146.116 244.36,146.38 C244.0472,146.5656 243.6472,146.5152 243.388,146.256 L242.6744,145.5424 L241.544,146.6736 L242.2568,147.3872 C242.5152,147.6456 242.5656,148.0456 242.3808,148.36 C242.1152,148.8072 241.9152,149.292 241.7848,149.7992 C241.6936,150.1528 241.3752,150.4 241.0104,150.4 L240,150.4 L240,152 L241.0104,152 C241.3752,152 241.6936,152.2472 241.7848,152.6 C241.9152,153.1064 242.1152,153.5904 242.3808,154.0384 C242.5656,154.3528 242.5152,154.7528 242.2568,155.0112 L241.5432,155.7248 L242.6744,156.856 L243.388,156.1424 C243.6472,155.884 244.048,155.8336 244.3608,156.0192 C244.8112,156.2848 245.2944,156.4848 245.7976,156.6144 C246.152,156.7048 246.3992,157.024 246.3992,157.3888 L246.3992,158.4 L247.9992,158.4 L247.9992,157.3896 C247.9992,157.0248 248.2464,156.7056 248.6,156.6152 C249.1064,156.4848 249.5904,156.284 250.0384,156.02 C250.352,155.8344 250.7536,155.8848 251.0112,156.1432 L251.7248,156.8576 L252.856,155.7264 L252.1424,155.0128 C251.8832,154.7544 251.8336,154.3536 252.0192,154.0392 C252.2848,153.5912 252.4848,153.1072 252.6152,152.6008 C252.7064,152.2472 253.0248,152 253.3896,152 L254.4,152 L254.4,150.4 L254.4,150.4 Z M249.6,151.2 C249.6,152.5232 248.5232,153.6 247.2,153.6 C245.8768,153.6 244.8,152.5232 244.8,151.2 C244.8,149.8768 245.8768,148.8 247.2,148.8 C248.5232,148.8 249.6,149.8768 249.6,151.2 L249.6,151.2 Z M248,151.2 C248,150.7592 247.6416,150.4 247.2,150.4 C246.7584,150.4 246.4,150.7592 246.4,151.2 C246.4,151.6408 246.7584,152 247.2,152 C247.6416,152 248,151.6408 248,151.2 L248,151.2 Z M239.2,158.4 L212,158.4 C210.6768,158.4 209.6,157.3232 209.6,156 L209.6,124 C209.6,123.5584 209.2424,123.2 208.8,123.2 C208.3576,123.2 208,123.5584 208,124 L208,156 C208,158.2056 209.7944,160 212,160 L239.2,160 C239.6424,160 240,159.6416 240,159.2 C240,158.7584 239.6424,158.4 239.2,158.4 L239.2,158.4 Z M252,112 L212,112 C209.7944,112 208,113.7944 208,116 L208,120.8 C208,121.2416 208.3576,121.6 208.8,121.6 L252,121.6 C252.4424,121.6 252.8,121.2416 252.8,120.8 C252.8,120.3584 252.4424,120 252,120 L209.6,120 L209.6,116 C209.6,114.6768 210.6768,113.6 212,113.6 L252,113.6 C253.3232,113.6 254.4,114.6768 254.4,116 L254.4,143.2 C254.4,143.6416 254.7576,144 255.2,144 C255.6424,144 256,143.6416 256,143.2 L256,116 C256,113.7944 254.2056,112 252,112 L252,112 Z" id="web-development"></path>
-                    </g>
-                </g>
-            </g>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 25.4.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 75 75" style="enable-background:new 0 0 75 75;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_1_);}
+	.st1{fill:none;}
+</style>
+<g id="icon">
+	<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="87.5133" y1="87.5133" x2="-26.0279" y2="-26.0279">
+		<stop  offset="0" style="stop-color:#6FFE80"/>
+		<stop  offset="0.3726" style="stop-color:#43CE58"/>
+		<stop  offset="1" style="stop-color:#425FCF"/>
+	</linearGradient>
+	<path class="st0" d="M75,6.2v62.5c0,3.4-2.8,6.2-6.2,6.2H6.2C2.8,75,0,72.2,0,68.8v-50c0-0.7,0.6-1.2,1.2-1.2s1.2,0.6,1.2,1.2v50
+		c0,2.1,1.7,3.8,3.8,3.8h62.5c2.1,0,3.8-1.7,3.8-3.8V6.2c0-2.1-1.7-3.8-3.8-3.8H6.2c-2.1,0-3.8,1.7-3.8,3.8v6.2h66.2
+		c0.7,0,1.2,0.6,1.2,1.2S69.4,15,68.8,15H1.2C0.6,15,0,14.4,0,13.8V6.2C0,2.8,2.8,0,6.2,0h62.5C72.2,0,75,2.8,75,6.2L75,6.2z
+		 M7.5,7.5C7.5,8.9,8.6,10,10,10s2.5-1.1,2.5-2.5S11.4,5,10,5S7.5,6.1,7.5,7.5L7.5,7.5z M15,7.5c0,1.4,1.1,2.5,2.5,2.5
+		S20,8.9,20,7.5S18.9,5,17.5,5S15,6.1,15,7.5L15,7.5z M22.5,7.5c0,1.4,1.1,2.5,2.5,2.5s2.5-1.1,2.5-2.5S26.4,5,25,5
+		S22.5,6.1,22.5,7.5L22.5,7.5z M63.8,53.7H51.2V41.2c0-0.7-0.6-1.2-1.2-1.2c-8.3,0-15,6.7-15,15s6.7,15,15,15s15-6.7,15-15
+		C65,54.3,64.4,53.7,63.8,53.7z M50,67.5c-6.9,0-12.5-5.6-12.5-12.5c0-6.5,4.9-11.8,11.2-12.4v13.7h13.7
+		C61.8,62.6,56.5,67.5,50,67.5z M55,35c-0.7,0-1.2,0.6-1.2,1.2v15h15c0.7,0,1.2-0.6,1.2-1.2C70,41.7,63.3,35,55,35z M56.2,48.7V37.6
+		c5.9,0.6,10.6,5.3,11.2,11.2H56.2z M38.7,24.9l-6.3,16.7c-0.2,0.5-0.6,0.8-1.1,0.8c-0.5,0-1-0.3-1.2-0.8l-2.5-5.9l-7.6,19.6
+		c-0.2,0.5-0.7,0.8-1.2,0.8c0,0,0,0-0.1,0c-0.5,0-1-0.4-1.1-0.9L9.9,26.8l-2.4,7.3c-0.2,0.7-0.9,1-1.6,0.8c-0.7-0.2-1-0.9-0.8-1.6
+		l3.8-11.2c0.2-0.5,0.7-0.9,1.2-0.9c0.6,0,1,0.4,1.2,0.9L19,51L26.3,32c0.2-0.5,0.6-0.8,1.1-0.8c0,0,0,0,0,0c0.5,0,1,0.3,1.1,0.8
+		l2.5,5.9l6.4-17.1c0.2-0.5,0.7-0.8,1.2-0.8c0.5,0,1,0.3,1.2,0.8l2.9,8.5l4.9-7.5c0.2-0.4,0.7-0.6,1.1-0.6c0.4,0,0.8,0.3,1.1,0.6
+		l3.9,6.9l2.7-4.4c0.2-0.4,0.6-0.6,1.1-0.6c0,0,0,0,0,0c0.4,0,0.8,0.2,1.1,0.6l2.5,4c0.4,0.6,0.2,1.4-0.4,1.7
+		c-0.6,0.4-1.4,0.2-1.7-0.4l-1.4-2.3l-2.7,4.5c-0.2,0.4-0.6,0.6-1.1,0.6c-0.4,0-0.9-0.2-1.1-0.6l-4-7l-5.1,7.9
+		c-0.3,0.4-0.7,0.6-1.2,0.6c-0.5-0.1-0.9-0.4-1-0.8L38.7,24.9z"/>
+</g>
+<g id="_x37_5px_frame">
+	<rect x="0" y="0" class="st1" width="75" height="75"/>
+</g>
+</svg>
diff --git a/sources/pyside6/doc/images/Tooling.svg b/sources/pyside6/doc/images/Tooling.svg
new file mode 100644
index 000000000..98116957e
--- /dev/null
+++ b/sources/pyside6/doc/images/Tooling.svg
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="49px" height="48px" viewBox="0 0 49 48" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: Sketch 44.1 (41455) - http://www.bohemiancoding.com/sketch -->
+    <title>web-development</title>
+    <desc>Created with Sketch.</desc>
+    <defs>
+        <linearGradient x1="100%" y1="100%" x2="-22.8515625%" y2="-33.2356771%" id="linearGradient-1">
+            <stop stop-color="#6FFF80" offset="0%"></stop>
+            <stop stop-color="#43CE57" offset="37.2587344%"></stop>
+            <stop stop-color="#425FD0" offset="100%"></stop>
+        </linearGradient>
+    </defs>
+    <g id="Mainpage" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="Mainpage_Layout_V4_Megamenu" transform="translate(-1084.000000, -1756.000000)" fill="url(#linearGradient-1)">
+            <g id="Content" transform="translate(-44.000000, 1530.000000)">
+                <g id="WhatQtis" transform="translate(194.000000, 0.000000)">
+                    <g id="Block3_Hover" transform="translate(726.316067, 114.000000)">
+                        <path d="M214.4,115.2 C215.2816,115.2 216,115.9176 216,116.8 C216,117.6824 215.2816,118.4 214.4,118.4 C213.5176,118.4 212.8,117.6824 212.8,116.8 C212.8,115.9176 213.5176,115.2 214.4,115.2 L214.4,115.2 Z M217.6,116.8 C217.6,117.6824 218.3176,118.4 219.2,118.4 C220.0816,118.4 220.8,117.6824 220.8,116.8 C220.8,115.9176 220.0816,115.2 219.2,115.2 C218.3176,115.2 217.6,115.9176 217.6,116.8 L217.6,116.8 Z M222.4,116.8 C222.4,117.6824 223.1176,118.4 224,118.4 C224.8816,118.4 225.6,117.6824 225.6,116.8 C225.6,115.9176 224.8816,115.2 224,115.2 C223.1176,115.2 222.4,115.9176 222.4,116.8 L222.4,116.8 Z M215.2,128 L216.8,128 C217.2424,128 217.6,127.6416 217.6,127.2 C217.6,126.7584 217.2424,126.4 216.8,126.4 L215.2,126.4 C214.7576,126.4 214.4,126.7584 214.4,127.2 C214.4,127.6416 214.7576,128 215.2,128 L215.2,128 Z M215.2,131.2 L216.8,131.2 C217.2424,131.2 217.6,130.8416 217.6,130.4 C217.6,129.9584 217.2424,129.6 216.8,129.6 L215.2,129.6 C214.7576,129.6 214.4,129.9584 214.4,130.4 C214.4,130.8416 214.7576,131.2 215.2,131.2 L215.2,131.2 Z M215.2,134.4 L216.8,134.4 C217.2424,134.4 217.6,134.0416 217.6,133.6 C217.6,133.1584 217.2424,132.8 216.8,132.8 L215.2,132.8 C214.7576,132.8 214.4,133.1584 214.4,133.6 C214.4,134.0416 214.7576,134.4 215.2,134.4 L215.2,134.4 Z M215.2,137.6 L216.8,137.6 C217.2424,137.6 217.6,137.2416 217.6,136.8 C217.6,136.3584 217.2424,136 216.8,136 L215.2,136 C214.7576,136 214.4,136.3584 214.4,136.8 C214.4,137.2416 214.7576,137.6 215.2,137.6 L215.2,137.6 Z M215.2,140.8 L216.8,140.8 C217.2424,140.8 217.6,140.4416 217.6,140 C217.6,139.5584 217.2424,139.2 216.8,139.2 L215.2,139.2 C214.7576,139.2 214.4,139.5584 214.4,140 C214.4,140.4416 214.7576,140.8 215.2,140.8 L215.2,140.8 Z M215.2,144 L216.8,144 C217.2424,144 217.6,143.6416 217.6,143.2 C217.6,142.7584 217.2424,142.4 216.8,142.4 L215.2,142.4 C214.7576,142.4 214.4,142.7584 214.4,143.2 C214.4,143.6416 214.7576,144 215.2,144 L215.2,144 Z M215.2,147.2 L216.8,147.2 C217.2424,147.2 217.6,146.8416 217.6,146.4 C217.6,145.9584 217.2424,145.6 216.8,145.6 L215.2,145.6 C214.7576,145.6 214.4,145.9584 214.4,146.4 C214.4,146.8416 214.7576,147.2 215.2,147.2 L215.2,147.2 Z M215.2,150.4 L216.8,150.4 C217.2424,150.4 217.6,150.0416 217.6,149.6 C217.6,149.1584 217.2424,148.8 216.8,148.8 L215.2,148.8 C214.7576,148.8 214.4,149.1584 214.4,149.6 C214.4,150.0416 214.7576,150.4 215.2,150.4 L215.2,150.4 Z M215.2,153.6 L216.8,153.6 C217.2424,153.6 217.6,153.2416 217.6,152.8 C217.6,152.3584 217.2424,152 216.8,152 L215.2,152 C214.7576,152 214.4,152.3584 214.4,152.8 C214.4,153.2416 214.7576,153.6 215.2,153.6 L215.2,153.6 Z M242.4,128 C242.8424,128 243.2,127.6416 243.2,127.2 C243.2,126.7584 242.8424,126.4 242.4,126.4 L239.2,126.4 C238.7576,126.4 238.4,126.7584 238.4,127.2 C238.4,127.6416 238.7576,128 239.2,128 L242.4,128 L242.4,128 Z M235.2,130.4 C235.2,130.8416 235.5576,131.2 236,131.2 L244,131.2 C244.4424,131.2 244.8,130.8416 244.8,130.4 C244.8,129.9584 244.4424,129.6 244,129.6 L236,129.6 C235.5576,129.6 235.2,129.9584 235.2,130.4 L235.2,130.4 Z M220,131.2 L232.8,131.2 C233.2424,131.2 233.6,130.8416 233.6,130.4 C233.6,129.9584 233.2424,129.6 232.8,129.6 L220,129.6 C219.5576,129.6 219.2,129.9584 219.2,130.4 C219.2,130.8416 219.5576,131.2 220,131.2 L220,131.2 Z M220,128 L228,128 C228.4424,128 228.8,127.6416 228.8,127.2 C228.8,126.7584 228.4424,126.4 228,126.4 L220,126.4 C219.5576,126.4 219.2,126.7584 219.2,127.2 C219.2,127.6416 219.5576,128 220,128 L220,128 Z M236,126.4 L231.2,126.4 C230.7576,126.4 230.4,126.7584 230.4,127.2 C230.4,127.6416 230.7576,128 231.2,128 L236,128 C236.4424,128 236.8,127.6416 236.8,127.2 C236.8,126.7584 236.4424,126.4 236,126.4 L236,126.4 Z M248,133.6 C248,133.1584 247.6424,132.8 247.2,132.8 L234.4,132.8 C233.9576,132.8 233.6,133.1584 233.6,133.6 C233.6,134.0416 233.9576,134.4 234.4,134.4 L247.2,134.4 C247.6424,134.4 248,134.0416 248,133.6 L248,133.6 Z M242.4,137.6 C242.8424,137.6 243.2,137.2416 243.2,136.8 C243.2,136.3584 242.8424,136 242.4,136 L236,136 C235.5576,136 235.2,136.3584 235.2,136.8 C235.2,137.2416 235.5576,137.6 236,137.6 L242.4,137.6 L242.4,137.6 Z M220,137.6 L232.8,137.6 C233.2424,137.6 233.6,137.2416 233.6,136.8 C233.6,136.3584 233.2424,136 232.8,136 L220,136 C219.5576,136 219.2,136.3584 219.2,136.8 C219.2,137.2416 219.5576,137.6 220,137.6 L220,137.6 Z M220,134.4 L223.2,134.4 C223.6424,134.4 224,134.0416 224,133.6 C224,133.1584 223.6424,132.8 223.2,132.8 L220,132.8 C219.5576,132.8 219.2,133.1584 219.2,133.6 C219.2,134.0416 219.5576,134.4 220,134.4 L220,134.4 Z M226.4,132.8 C225.9576,132.8 225.6,133.1584 225.6,133.6 C225.6,134.0416 225.9576,134.4 226.4,134.4 L231.2,134.4 C231.6424,134.4 232,134.0416 232,133.6 C232,133.1584 231.6424,132.8 231.2,132.8 L226.4,132.8 L226.4,132.8 Z M237.6,146.4 C237.6,145.9584 237.2424,145.6 236.8,145.6 L234.4,145.6 C233.9576,145.6 233.6,145.9584 233.6,146.4 C233.6,146.8416 233.9576,147.2 234.4,147.2 L236.8,147.2 C237.2424,147.2 237.6,146.8416 237.6,146.4 L237.6,146.4 Z M220,147.2 L223.2,147.2 C223.6424,147.2 224,146.8416 224,146.4 C224,145.9584 223.6424,145.6 223.2,145.6 L220,145.6 C219.5576,145.6 219.2,145.9584 219.2,146.4 C219.2,146.8416 219.5576,147.2 220,147.2 L220,147.2 Z M231.2,145.6 L226.4,145.6 C225.9576,145.6 225.6,145.9584 225.6,146.4 C225.6,146.8416 225.9576,147.2 226.4,147.2 L231.2,147.2 C231.6424,147.2 232,146.8416 232,146.4 C232,145.9584 231.6424,145.6 231.2,145.6 L231.2,145.6 Z M220,150.4 L229.6,150.4 C230.0424,150.4 230.4,150.0416 230.4,149.6 C230.4,149.1584 230.0424,148.8 229.6,148.8 L220,148.8 C219.5576,148.8 219.2,149.1584 219.2,149.6 C219.2,150.0416 219.5576,150.4 220,150.4 L220,150.4 Z M232.8,150.4 L234.4,150.4 C234.8424,150.4 235.2,150.0416 235.2,149.6 C235.2,149.1584 234.8424,148.8 234.4,148.8 L232.8,148.8 C232.3576,148.8 232,149.1584 232,149.6 C232,150.0416 232.3576,150.4 232.8,150.4 L232.8,150.4 Z M220,153.6 L224.8,153.6 C225.2424,153.6 225.6,153.2416 225.6,152.8 C225.6,152.3584 225.2424,152 224.8,152 L220,152 C219.5576,152 219.2,152.3584 219.2,152.8 C219.2,153.2416 219.5576,153.6 220,153.6 L220,153.6 Z M227.2,152.8 C227.2,153.2416 227.5576,153.6 228,153.6 L236,153.6 C236.4424,153.6 236.8,153.2416 236.8,152.8 C236.8,152.3584 236.4424,152 236,152 L228,152 C227.5576,152 227.2,152.3584 227.2,152.8 L227.2,152.8 Z M244.8,140 C244.8,139.5584 244.4424,139.2 244,139.2 L231.2,139.2 C230.7576,139.2 230.4,139.5584 230.4,140 C230.4,140.4416 230.7576,140.8 231.2,140.8 L244,140.8 C244.4424,140.8 244.8,140.4416 244.8,140 L244.8,140 Z M239.2,143.2 C239.2,142.7584 238.8424,142.4 238.4,142.4 L232.8,142.4 C232.3576,142.4 232,142.7584 232,143.2 C232,143.6416 232.3576,144 232.8,144 L238.4,144 C238.8424,144 239.2,143.6416 239.2,143.2 L239.2,143.2 Z M220,144 L229.6,144 C230.0424,144 230.4,143.6416 230.4,143.2 C230.4,142.7584 230.0424,142.4 229.6,142.4 L220,142.4 C219.5576,142.4 219.2,142.7584 219.2,143.2 C219.2,143.6416 219.5576,144 220,144 L220,144 Z M220,140.8 L228,140.8 C228.4424,140.8 228.8,140.4416 228.8,140 C228.8,139.5584 228.4424,139.2 228,139.2 L220,139.2 C219.5576,139.2 219.2,139.5584 219.2,140 C219.2,140.4416 219.5576,140.8 220,140.8 L220,140.8 Z M256,149.6 L256,152.8 C256,153.2416 255.6424,153.6 255.2,153.6 L253.9816,153.6 C253.8976,153.8384 253.8008,154.072 253.692,154.3 L254.5528,155.1608 C254.8656,155.4736 254.8656,155.98 254.5528,156.292 L252.2904,158.5544 C252.1408,158.7048 251.9376,158.7888 251.7248,158.7888 C251.5128,158.7888 251.3096,158.7048 251.1592,158.5544 L250.2976,157.6928 C250.0704,157.8008 249.8376,157.8976 249.5992,157.9816 L249.5992,159.2 C249.5992,159.6416 249.2416,160 248.7992,160 L245.5992,160 C245.1568,160 244.7992,159.6416 244.7992,159.2 L244.7992,157.9816 C244.5616,157.8976 244.3288,157.8008 244.1008,157.692 L243.24,158.5528 C242.94,158.8528 242.4088,158.8528 242.1088,158.5528 L239.8464,156.2904 C239.5336,155.9784 239.5336,155.472 239.8464,155.1592 L240.7072,154.2984 C240.5992,154.0704 240.5024,153.8376 240.4184,153.6 L239.2,153.6 C238.7576,153.6 238.4,153.2416 238.4,152.8 L238.4,149.6 C238.4,149.1584 238.7576,148.8 239.2,148.8 L240.4184,148.8 C240.5024,148.5616 240.5992,148.328 240.708,148.1 L239.8472,147.2392 C239.5344,146.9264 239.5344,146.42 239.8472,146.108 L242.1088,143.8456 C242.4088,143.5456 242.94,143.5456 243.24,143.8456 L244.1016,144.7072 C244.3288,144.5984 244.5624,144.5016 244.8008,144.4176 L244.8008,143.2 C244.8008,142.7584 245.1584,142.4 245.6008,142.4 L248.8,142.4 C249.2424,142.4 249.6,142.7584 249.6,143.2 L249.6,144.4176 C249.8384,144.5016 250.072,144.5984 250.2984,144.7064 L251.16,143.8456 C251.4728,143.5344 251.9792,143.5336 252.2912,143.8464 L254.5536,146.1088 C254.8664,146.4208 254.8664,146.9272 254.5536,147.24 L253.6928,148.1008 C253.8016,148.3288 253.8976,148.5624 253.9816,148.8 L255.2,148.8 C255.6424,148.8 256,149.1584 256,149.6 L256,149.6 Z M254.4,150.4 L253.3896,150.4 C253.0248,150.4 252.7064,150.1528 252.6152,149.7992 C252.4848,149.2928 252.2848,148.8088 252.0192,148.3608 C251.8344,148.0464 251.8848,147.6464 252.1432,147.388 L252.8568,146.6744 L251.7256,145.5432 L251.012,146.2568 C250.7528,146.5144 250.352,146.5648 250.0392,146.3792 C249.5928,146.116 249.1088,145.916 248.6,145.784 C248.2472,145.6928 248,145.3744 248,145.0096 L248,144 L246.4008,144 L246.4008,145.0096 C246.4008,145.3744 246.1536,145.6928 245.8008,145.784 C245.292,145.916 244.8072,146.116 244.36,146.38 C244.0472,146.5656 243.6472,146.5152 243.388,146.256 L242.6744,145.5424 L241.544,146.6736 L242.2568,147.3872 C242.5152,147.6456 242.5656,148.0456 242.3808,148.36 C242.1152,148.8072 241.9152,149.292 241.7848,149.7992 C241.6936,150.1528 241.3752,150.4 241.0104,150.4 L240,150.4 L240,152 L241.0104,152 C241.3752,152 241.6936,152.2472 241.7848,152.6 C241.9152,153.1064 242.1152,153.5904 242.3808,154.0384 C242.5656,154.3528 242.5152,154.7528 242.2568,155.0112 L241.5432,155.7248 L242.6744,156.856 L243.388,156.1424 C243.6472,155.884 244.048,155.8336 244.3608,156.0192 C244.8112,156.2848 245.2944,156.4848 245.7976,156.6144 C246.152,156.7048 246.3992,157.024 246.3992,157.3888 L246.3992,158.4 L247.9992,158.4 L247.9992,157.3896 C247.9992,157.0248 248.2464,156.7056 248.6,156.6152 C249.1064,156.4848 249.5904,156.284 250.0384,156.02 C250.352,155.8344 250.7536,155.8848 251.0112,156.1432 L251.7248,156.8576 L252.856,155.7264 L252.1424,155.0128 C251.8832,154.7544 251.8336,154.3536 252.0192,154.0392 C252.2848,153.5912 252.4848,153.1072 252.6152,152.6008 C252.7064,152.2472 253.0248,152 253.3896,152 L254.4,152 L254.4,150.4 L254.4,150.4 Z M249.6,151.2 C249.6,152.5232 248.5232,153.6 247.2,153.6 C245.8768,153.6 244.8,152.5232 244.8,151.2 C244.8,149.8768 245.8768,148.8 247.2,148.8 C248.5232,148.8 249.6,149.8768 249.6,151.2 L249.6,151.2 Z M248,151.2 C248,150.7592 247.6416,150.4 247.2,150.4 C246.7584,150.4 246.4,150.7592 246.4,151.2 C246.4,151.6408 246.7584,152 247.2,152 C247.6416,152 248,151.6408 248,151.2 L248,151.2 Z M239.2,158.4 L212,158.4 C210.6768,158.4 209.6,157.3232 209.6,156 L209.6,124 C209.6,123.5584 209.2424,123.2 208.8,123.2 C208.3576,123.2 208,123.5584 208,124 L208,156 C208,158.2056 209.7944,160 212,160 L239.2,160 C239.6424,160 240,159.6416 240,159.2 C240,158.7584 239.6424,158.4 239.2,158.4 L239.2,158.4 Z M252,112 L212,112 C209.7944,112 208,113.7944 208,116 L208,120.8 C208,121.2416 208.3576,121.6 208.8,121.6 L252,121.6 C252.4424,121.6 252.8,121.2416 252.8,120.8 C252.8,120.3584 252.4424,120 252,120 L209.6,120 L209.6,116 C209.6,114.6768 210.6768,113.6 212,113.6 L252,113.6 C253.3232,113.6 254.4,114.6768 254.4,116 L254.4,143.2 C254.4,143.6416 254.7576,144 255.2,144 C255.6424,144 256,143.6416 256,143.2 L256,116 C256,113.7944 254.2056,112 252,112 L252,112 Z" id="web-development"></path>
+                    </g>
+                </g>
+            </g>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/sources/pyside6/doc/images/linux.svg b/sources/pyside6/doc/images/linux.svg
new file mode 100644
index 000000000..af05345a2
--- /dev/null
+++ b/sources/pyside6/doc/images/linux.svg
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.0"
+   viewBox="0 0 266 312"
+   id="svg4"
+   sodipodi:docname="linux.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs8" />
+  <sodipodi:namedview
+     id="namedview6"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="2.7916667"
+     inkscape:cx="119.46269"
+     inkscape:cy="156.35821"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg4" />
+  <path
+     d="M128.6640625 79.2793c0 1-1 1-1 1h-1c-1 0-1-1-2-2 0 0-1-1-1-2s0-1 1-1l2 1c1 1 2 2 2 3m-18-10c0-5-2-8-5-8 0 0 0 1-1 1v2h3c0 2 1 3 1 5h2m35-5c2 0 3 2 4 5h2c-1-1-1-2-1-3s0-2-1-3-2-2-3-2c0 0-1 1-2 1 0 1 1 1 1 2m-30 16c-1 0-1 0-1-1s0-2 1-3c2 0 3-1 3-1 1 0 1 1 1 1 0 1-1 2-3 4h-1m-11-1c-4-2-5-5-5-10 0-3 0-5 2-7 1-2 3-3 5-3s3 1 5 3c1 3 2 6 2 9v2h1v-1c1 0 1-2 1-6 0-3 0-6-2-9s-4-5-8-5c-3 0-6 2-7 5-2 4-2.4 7-2.4 12 0 4 1.4 8 5.4 12 1-1 2-1 3-2m125 141c1 0 1-.4 1-1.3 0-2.2-1-4.8-4-7.7-3-3-8-4.9-14-5.7-1-.1-2-.1-2-.1-1-.2-1-.2-2-.2-1-.1-3-.3-4-.5 3-9.3 4-17.5 4-24.7 0-10-2-17-6-23s-8-9-13-10c-1 1-1 1-1 2 5 2 10 6 13 12 3 7 4 13 4 20 0 5.6-1 13.9-5 24.5-4 1.6-8 5.3-11 11.1 0 .9 0 1.4 1 1.4 0 0 1-.9 2-2.6 2-1.7 3-3.4 5-5.1 3-1.7 5-2.6 8-2.6 5 0 10 .7 13 2.1 4 1.3 6 2.7 7 4.3 1 1.5 2 2.9 3 4.2 0 1.3 1 1.9 1 1.9m-92-145c-1-1-1-3-1-5 0-4 0-6 2-9 2-2 4-3 6-3 3 0 5 2 7 4 1 3 2 5 2 8 0 5-2 8-6 9 0 0 1 1 2 1 2 0 3 1 5 2 1-6 2-10 2-15 0-6-1-10-3-13-3-3-6-4-10-4-3 0-6 1-9 3-2 3-3 5-3 8 0 5 1 9 3 13 1 0 2 1 3 1m12 16c-13 9-23 13-31 13-7 0-14-3-20-8 1 2 2 4 3 5l6 6c4 4 9 6 14 6 7 0 15-4 25-11l9-6c2-2 4-4 4-7 0-1 0-2-1-2-1-2-6-5-16-8-9-4-16-6-20-6-3 0-8 2-15 6-6 4-10 8-10 12 0 0 1 1 2 3 6 5 12 8 18 8 8 0 18-4 31-14v2c1 0 1 1 1 1m23 202c4 7.52 11 11.3 19 11.3 2 0 4-.3 6-.9 2-.4 4-1.1 5-1.9 1-.7 2-1.4 3-2.2 2-.7 2-1.2 3-1.7l17-14.7c4-3.19 8-5.98 13-8.4 4-2.4 8-4 10-4.9 3-.8 5-2 7-3.6 1-1.5 2-3.4 2-5.8 0-2.9-2-5.1-4-6.7s-4-2.7-6-3.4-4-2.3-7-5c-2-2.6-4-6.2-5-10.9l-1-5.8c-1-2.7-1-4.7-2-5.8 0-.3 0-.4-1-.4s-3 .9-4 2.6c-2 1.7-4 3.6-6 5.6-1 2-4 3.8-6 5.5-3 1.7-6 2.6-8 2.6-8 0-12-2.2-15-6.5-2-3.2-3-6.9-4-11.1-2-1.7-3-2.6-5-2.6-5 0-7 5.2-7 15.7v31.1c0 .9-1 2.9-1 6-1 3.1-1 6.62-1 10.6l-2 11.1v.17m-145-5.29c9.3 1.36 20 4.27 32.1 8.71 12.1 4.4 19.5 6.7 22.2 6.7 7 0 12.8-3.1 17.6-9.09 1-1.94 1-4.22 1-6.84 0-9.45-5.7-21.4-17.1-35.9l-6.8-9.1c-1.4-1.9-3.1-4.8-5.3-8.7-2.1-3.9-4-6.9-5.5-9-1.3-2.3-3.4-4.6-6.1-6.9-2.6-2.3-5.6-3.8-8.9-4.6-4.2.8-7.1 2.2-8.5 4.1s-2.2 4-2.4 6.2c-.3 2.1-.9 3.5-1.9 4.2-1 .6-2.7 1.1-5 1.6-.5 0-1.4 0-2.7.1h-2.7c-5.3 0-8.9.6-10.8 1.6-2.5 2.9-3.8 6.2-3.8 9.7 0 1.6.4 4.3 1.2 8.1.8 3.7 1.2 6.7 1.2 8.8 0 4.1-1.2 8.2-3.7 12.3-2.5 4.3-3.8 7.5-3.8 9.78 1 3.88 7.6 6.61 19.7 8.21m33.3-90.9c0-6.9 1.8-14.5 5.5-23.5 3.6-9 7.2-15 10.7-19-.2-1-.7-1-1.5-1l-1-1c-2.9 3-6.4 10-10.6 20-4.2 9-6.4 17.3-6.4 23.4 0 4.5 1.1 8.4 3.1 11.8 2.2 3.3 7.5 8.1 15.9 14.2l10.6 6.9c11.3 9.8 17.3 16.6 17.3 20.6 0 2.1-1 4.2-4 6.5-2 2.4-4.7 3.6-7 3.6-.2 0-.3.2-.3.7 0 .1 1 2.1 3.1 6 4.2 5.7 13.2 8.5 25.2 8.5 22 0 39-9 52-27 0-5 0-8.1-1-9.4v-3.7c0-6.5 1-11.4 3-14.6s4-4.7 7-4.7c2 0 4 .7 6 2.2 1-7.7 1-14.4 1-20.4 0-9.1 0-16.6-2-23.6-1-6-3-11-5-15l-6-9c-2-3-3-6-5-9-1-4-2-7-2-12-3-5-5-10-8-15-2-5-4-10-6-14l-9 7c-10 7-18 10-25 10-6 0-11-1-14-5l-6-5c0 3-1 7-3 11l-6.3 12c-2.8 7-4.3 11-4.6 14-.4 2-.7 4-.9 4l-7.5 15c-8.1 15-12.2 28.9-12.2 40.4 0 2.3.2 4.7.6 7.1-4.5-3.1-6.7-7.4-6.7-13m71.6 94.6c-13 0-23 1.76-30 5.25v-.3c-5 6-10.6 9.1-18.4 9.1-4.9 0-12.6-1.9-23-5.7-10.5-3.6-19.8-6.36-27.9-8.18-.8-.23-2.6-.57-5.5-1.03-2.8-.45-5.4-.91-7.7-1.37-2.1-.45-4.5-1.13-7.1-2.05-2.5-.79-4.5-1.82-6-3.07-1.38-1.26-2.06-2.68-2.06-4.27 0-1.6.34-3.31 1.02-5.13.64-1.1 1.34-2.2 2.04-3.2.7-1.1 1.3-2.1 1.7-3.1.6-.9 1-1.8 1.4-2.8.4-.9.8-1.8 1-2.9.2-1 .4-2 .4-3s-.4-4-1.2-9.3c-.8-5.2-1.2-8.5-1.2-9.9 0-4.4 1-7.9 3.2-10.4s4.3-3.8 6.5-3.8h11.5c.9 0 2.3-.5 4.4-1.7.7-1.6 1.3-2.9 1.7-4.1.5-1.2.7-2.1.9-2.5.2-.6.4-1.2.6-1.7.4-.7.9-1.5 1.6-2.3-.8-1-1.2-2.3-1.2-3.9 0-1.1 0-2.1.2-2.7 0-3.6 1.7-8.7 5.3-15.4l3.5-6.3c2.9-5.4 5.1-9.4 6.7-13.4 1.7-4 3.5-10 5.5-18 1.6-7 5.4-14 11.4-21l7.5-9c5.2-6 8.6-11 10.5-15s2.9-9 2.9-13c0-2-.5-8-1.6-18-1-10-1.5-20-1.5-29 0-7 .6-12 1.9-17s3.6-10 7-14c3-4 7-8 13-10s13-3 21-3c3 0 6 0 9 1 3 0 7 1 12 3 4 2 8 4 11 7 4 3 7 8 10 13 2 6 4 12 5 20 1 5 1 10 2 17 0 6 1 10 1 13 1 3 1 7 2 12 1 4 2 8 4 11 2 4 4 8 7 12 3 5 7 10 11 16 9 10 16 21 20 32 5 10 8 23 8 36.9 0 6.9-1 13.6-3 20.1 2 0 3 .8 4 2.2s2 4.4 3 9.1l1 7.4c1 2.2 2 4.3 5 6.1 2 1.8 4 3.3 7 4.5 2 1 5 2.4 7 4.2 2 2 3 4.1 3 6.3 0 3.4-1 5.9-3 7.7-2 2-4 3.4-7 4.3-2 1-6 3-12 5.82-5 2.96-10 6.55-15 10.8l-10 8.51c-4 3.9-8 6.7-11 8.4-3 1.8-7 2.7-11 2.7l-7-.8c-8-2.1-13-6.1-16-12.2-16-1.94-29-2.9-37-2.9"
+     id="path2"
+     style="fill:#53586b;fill-opacity:1" />
+</svg>
diff --git a/sources/pyside6/doc/images/macos.svg b/sources/pyside6/doc/images/macos.svg
new file mode 100644
index 000000000..01b8cb002
--- /dev/null
+++ b/sources/pyside6/doc/images/macos.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   viewBox="0 0 4875 4875"
+   version="1.1"
+   id="svg4"
+   sodipodi:docname="macOS.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs8" />
+  <sodipodi:namedview
+     id="namedview6"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="0.17866667"
+     inkscape:cx="2056.9029"
+     inkscape:cy="2443.097"
+     inkscape:window-width="1920"
+     inkscape:window-height="1080"
+     inkscape:window-x="1920"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg4" />
+  <path
+     fill="#666"
+     d="m 4217.2809,3659.1573 c -67.1033,155.0227 -146.5318,297.7206 -238.5597,428.9145 -125.4425,178.8514 -228.1514,302.6507 -307.3064,371.3978 -122.7033,112.843 -254.1713,170.6343 -394.952,173.9209 -101.0661,0 -222.9479,-28.7587 -364.8238,-87.0974 -142.3418,-58.0655 -273.1524,-86.8235 -392.7608,-86.8235 -125.4424,0 -259.9782,28.758 -403.8809,86.8235 -144.1218,58.3387 -260.2248,88.7411 -348.9927,91.7538 -135.0014,5.7518 -269.5646,-53.6831 -403.8809,-178.5773 -85.7283,-74.7731 -192.9569,-202.9541 -321.4121,-384.5447 C 902.88949,3881.0097 789.58031,3656.1447 700.81195,3399.782 605.74429,3122.8775 558.08701,2854.7371 558.08701,2595.1424 c 0,-297.3638 64.25482,-553.8363 192.95678,-768.7591 101.14827,-172.6342 235.71135,-308.8131 404.12711,-408.7836 168.4162,-99.9703 350.3899,-150.914 546.3595,-154.1734 107.2285,0 247.8447,33.1682 422.5877,98.3545 174.25,65.4052 286.1345,98.5736 335.1882,98.5736 36.6747,0 160.9663,-38.7834 371.6716,-116.1026 199.256,-71.705 367.4256,-101.3949 505.1932,-89.7 373.3149,30.1284 653.78,177.2902 840.3002,442.4178 -333.8741,202.2962 -499.0309,485.6375 -495.7444,849.1192 3.0132,283.1218 105.7221,518.7232 307.5803,705.7915 91.4803,86.8235 193.6417,153.9273 307.3064,201.5844 -24.6494,71.4857 -50.6695,139.9584 -78.3327,205.6926 z M 3361.0953,290.01478 c 0,221.90982 -81.0722,429.10615 -242.6678,620.88525 -195.0111,227.98777 -430.8867,359.72937 -686.6746,338.94127 -3.2589,-26.6223 -5.1489,-54.6418 -5.1489,-84.085 0,-213.03328 92.7396,-441.02035 257.431,-627.43123 82.222,-94.38292 186.794,-172.86107 313.606,-235.46509 126.5378,-61.66949 246.2285,-95.77377 358.7983,-101.61416 3.2866,29.66615 4.656,59.3338 4.656,88.76593 z"
+     id="path2"
+     style="fill:#53586b;fill-opacity:1;stroke-width:4.43719" />
+</svg>
diff --git a/sources/pyside6/doc/images/windows.svg b/sources/pyside6/doc/images/windows.svg
new file mode 100644
index 000000000..a40519bb0
--- /dev/null
+++ b/sources/pyside6/doc/images/windows.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   viewBox="0 0 4875 4875"
+   version="1.1"
+   id="svg4"
+   sodipodi:docname="windows.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs8" />
+  <sodipodi:namedview
+     id="namedview6"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="0.17866667"
+     inkscape:cx="2224.8134"
+     inkscape:cy="2437.5"
+     inkscape:window-width="2552"
+     inkscape:window-height="1432"
+     inkscape:window-x="1924"
+     inkscape:window-y="4"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg4" />
+  <path
+     fill="#0078d4"
+     d="M0 0h2311v2310H0zm2564 0h2311v2310H2564zM0 2564h2311v2311H0zm2564 0h2311v2311H2564"
+     id="path2"
+     style="fill:#53586b;fill-opacity:1" />
+</svg>
diff --git a/sources/pyside6/doc/index.rst b/sources/pyside6/doc/index.rst
index ca4f025c0..1bb28f9c1 100644
--- a/sources/pyside6/doc/index.rst
+++ b/sources/pyside6/doc/index.rst
@@ -31,7 +31,7 @@ This project is available under the LGPLv3/GPLv3 and the `Qt commercial license`
 .. _Qt: https://doc.qt.io
 .. _PySide6: quickstart.html
 .. _`Qt commercial license`: https://www.qt.io/licensing/
-.. _`Porting from PySide2 to PySide6`: porting_from2.html
+.. _`Porting from PySide2 to PySide6`: gettingstarted/porting_from2.html
 
 Quick Start
 ===========
@@ -44,142 +44,171 @@ and to learn what is installed with the ``pyside6``, check the
 `package content, structure, and tools`_ page.
 
 
-.. _`getting started guide`: gettingstarted.html
+.. _`getting started guide`: gettingstarted/index.html
 .. _`write your first application`: quickstart.html
-.. _`package content, structure, and tools`: package_details.html
+.. _`package content, structure, and tools`: gettingstarted/package_details.html
 
 Documentation
 =============
 
-.. panels::
-    :body: align-items-center jutify-content-center text-center
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center img-responsive card-img-top-main
-
-    :img-top: images/Desktop.svg
-
-    Write your first Qt application.
-
-    +++
-
-    .. link-button:: quickstart
-        :type: ref
-        :text: Start here!
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/Support.svg
-
-    Modules, docs, and cross compilation.
-
-    +++
-
-    .. link-button:: gettingstarted/index
-        :type: ref
-        :text: Build Instructions
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/Dev.svg
-
-    PySide API reference.
-
-    +++
-
-    .. link-button:: api
-        :type: ref
-        :text: API Docs
-        :classes: btn-qt btn-block stretched-link
-
-    ---
-    :img-top: images/Tutorials.svg
-
-    Learn with step-by-step guides.
-
-    +++
-
-    .. link-button:: tutorials/index
-        :type: ref
-        :text: Tutorials
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/Examples.svg
-
-    Check all the available examples.
-
-    +++
-
-    .. link-button:: examples/index
-        :type: ref
-        :text: Examples
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/Training.svg
-
-    Watch webinars, talks, and more.
-
-    +++
-
-    .. link-button:: videos
-        :type: ref
-        :text: Videos
-        :classes: btn-qt btn-block stretched-link
-
-    ---
-    :img-top: images/Deployment.svg
-
-    Learn to deploy your applications.
-
-    +++
-
-    .. link-button:: deployment-guides
-        :type: ref
-        :text: Deployment
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/stopwatch.svg
-
-    API differences and known issues.
-
-    +++
-
-    .. link-button:: considerations
-        :type: ref
-        :text: Considerations
-        :classes: btn-qt btn-block stretched-link
-    ---
-    :img-top: images/cpp_python.svg
-
-    Generate C++ to Python bindings.
-
-    +++
-
-    .. link-button:: shiboken6/index.html
-        :text: Shiboken
-        :classes: btn-qt btn-block stretched-link
-
-    ---
-    :img-top: images/Development.svg
-
-    Notes for Developers.
-
-    +++
-
-    .. link-button:: developer-notes
-        :type: ref
-        :text: Developers
-        :classes: btn-qt btn-block stretched-link
-
-    ---
-    :img-top: images/Commercial.svg
-
-    Packages, installation, and details.
-
-    +++
-
-    .. link-button:: commercial-page
-        :type: ref
-        :text: Commercial
-        :classes: btn-qt btn-block stretched-link
+.. grid:: 1 3 3 3
+    :gutter: 2
+
+    .. grid-item-card::
+        :img-top: images/Desktop.svg
+        :class-item: text-center
+
+        Write your first Qt application.
+        +++
+        .. button-ref:: quick-start
+            :color: primary
+            :outline:
+            :expand:
+
+            Start here!
+
+    .. grid-item-card::
+        :img-top: images/Support.svg
+        :class-item: text-center
+
+        Modules, docs, and cross compilation.
+        +++
+        .. button-ref:: gettingstarted/index
+            :color: primary
+            :outline:
+            :expand:
+
+            Build Instructions
+
+    .. grid-item-card::
+        :img-top: images/Commercial.svg
+        :class-item: text-center
+
+        Packages, installation, and details.
+        +++
+        .. button-ref:: commercial-page
+            :color: primary
+            :outline:
+            :expand:
+
+            Commercial
+
+    .. grid-item-card::
+        :img-top: images/Dev.svg
+        :class-item: text-center
+
+        PySide API reference.
+        +++
+        .. button-ref:: pyside-api
+            :color: primary
+            :outline:
+            :expand:
+
+            API Docs
+
+    .. grid-item-card::
+        :img-top: images/Tutorials.svg
+        :class-item: text-center
+
+        Learn with step-by-step guides.
+        +++
+        .. button-ref:: tutorials/index
+            :color: primary
+            :outline:
+            :expand:
+
+            Tutorials
+
+    .. grid-item-card::
+        :img-top: images/Examples.svg
+        :class-item: text-center
+
+        Check all the available examples.
+        +++
+        .. button-ref:: examples/index
+            :color: primary
+            :outline:
+            :expand:
+
+            Examples
+
+    .. grid-item-card::
+        :img-top: images/Training.svg
+        :class-item: text-center
+
+        Watch webinars, talks, and more.
+        +++
+        .. button-ref:: videos
+            :color: primary
+            :outline:
+            :expand:
+
+            Videos
+
+    .. grid-item-card::
+        :img-top: images/Tooling.svg
+        :class-item: text-center
+
+        Discover the tools included.
+        +++
+        .. button-ref:: package_tools
+            :color: primary
+            :outline:
+            :expand:
+
+            Tooling
+
+    .. grid-item-card::
+        :img-top: images/Deployment.svg
+        :class-item: text-center
+
+        Learn to deploy your applications.
+        +++
+        .. button-ref:: deployment-guides
+            :color: primary
+            :outline:
+            :expand:
+
+            Deployment
+
+    .. grid-item-card::
+        :img-top: images/cpp_python.svg
+        :class-item: text-center
+
+        Generate C++ to Python bindings.
+        +++
+        .. button-link:: shiboken6/index.html
+            :color: primary
+            :outline:
+            :expand:
+
+            Shiboken
+
+    .. grid-item-card::
+        :img-top: images/stopwatch.svg
+        :class-item: text-center
+
+        API differences and known issues.
+        +++
+        .. button-ref:: considerations
+            :color: primary
+            :outline:
+            :expand:
+
+            Considerations
+
+    .. grid-item-card::
+        :img-top: images/Development.svg
+        :class-item: text-center
+
+        Notes for Developers.
+        +++
+        .. button-ref:: developer-notes
+            :color: primary
+            :outline:
+            :expand:
+
+            Developers
 
 
 We have also a `wiki page`_ where you can find how to report bugs, contribute or contact the community.
diff --git a/sources/pyside6/doc/inheritance_diagram.py b/sources/pyside6/doc/inheritance_diagram.py
index 22d7d87ad..e972fac4c 100644
--- a/sources/pyside6/doc/inheritance_diagram.py
+++ b/sources/pyside6/doc/inheritance_diagram.py
@@ -37,7 +37,6 @@ r"""
     :license: BSD, see LICENSE for details.
 """
 
-import sys
 try:
     from hashlib import md5
 except ImportError:
@@ -48,109 +47,8 @@ from docutils.parsers.rst import directives, Directive
 
 from sphinx.ext.graphviz import render_dot_html, render_dot_latex
 
-from import_inheritance import (get_inheritance_entries_by_import,
-                                InheritanceException)
-from json_inheritance import (is_inheritance_from_json_enabled,
-                              get_inheritance_entries_from_json)
-
-
-class InheritanceGraph(object):
-    """
-    Given a list of classes, determines the set of classes that they inherit
-    from all the way to the root "object", and then is able to generate a
-    graphviz dot graph from them.
-    """
-    def __init__(self, class_names, currmodule, show_builtins=False, parts=0):
-        """
-        *class_names* is a list of child classes to show bases from.
-
-        If *show_builtins* is True, then Python builtins will be shown
-        in the graph.
-        """
-        self.class_names = class_names
-        if is_inheritance_from_json_enabled():
-            self.class_info = get_inheritance_entries_from_json(class_names)
-        else:
-            self.class_info = get_inheritance_entries_by_import(class_names,
-                                                                currmodule,
-                                                                __builtins__,
-                                                                show_builtins,
-                                                                parts)
-
-    def get_all_class_names(self):
-        """
-        Get all of the class names involved in the graph.
-        """
-        return [fullname for (_, fullname, _) in self.class_info]
-
-    # These are the default attrs for graphviz
-    default_graph_attrs = {
-        'rankdir': 'LR',
-        'size': '"8.0, 12.0"',
-    }
-    default_node_attrs = {
-        'shape': 'box',
-        'fontsize': 10,
-        'height': 0.25,
-        'fontname': '"Vera Sans, DejaVu Sans, Liberation Sans, '
-                    'Arial, Helvetica, sans"',
-        'style': '"setlinewidth(0.5)"',
-    }
-    default_edge_attrs = {
-        'arrowsize': 0.5,
-        'style': '"setlinewidth(0.5)"',
-    }
-
-    def _format_node_attrs(self, attrs):
-        return ','.join([f'{x[0]}={x[1]}' for x in attrs.items()])
-
-    def _format_graph_attrs(self, attrs):
-        return ''.join([f"{x[0]}={x[1]};\n" for x in attrs.items()])
-
-    def generate_dot(self, name, urls={}, env=None,
-                     graph_attrs={}, node_attrs={}, edge_attrs={}):
-        """
-        Generate a graphviz dot graph from the classes that
-        were passed in to __init__.
-
-        *name* is the name of the graph.
-
-        *urls* is a dictionary mapping class names to HTTP URLs.
-
-        *graph_attrs*, *node_attrs*, *edge_attrs* are dictionaries containing
-        key/value pairs to pass on as graphviz properties.
-        """
-        g_attrs = self.default_graph_attrs.copy()
-        n_attrs = self.default_node_attrs.copy()
-        e_attrs = self.default_edge_attrs.copy()
-        g_attrs.update(graph_attrs)
-        n_attrs.update(node_attrs)
-        e_attrs.update(edge_attrs)
-        if env:
-            g_attrs.update(env.config.inheritance_graph_attrs)
-            n_attrs.update(env.config.inheritance_node_attrs)
-            e_attrs.update(env.config.inheritance_edge_attrs)
-
-        res = []
-        res.append(f'digraph {name} {{\n')
-        res.append(self._format_graph_attrs(g_attrs))
-
-        for name, fullname, bases in self.class_info:
-            # Write the node
-            this_node_attrs = n_attrs.copy()
-            url = urls.get(fullname)
-            if url is not None:
-                this_node_attrs['URL'] = f'"{url}"'
-                this_node_attrs['target'] = '"_top"'  # Browser target frame attribute (same page)
-            attribute = self._format_node_attrs(this_node_attrs)
-            res.append(f'  "{name}" [{attribute}];\n')
-
-            # Write the edges
-            for base_name in bases:
-                attribute = self._format_node_attrs(e_attrs)
-                res.append(f'  "{base_name}" -> "{name}" [{attribute}];\n')
-        res.append('}\n')
-        return ''.join(res)
+from inheritance_graph import InheritanceGraph
+from import_inheritance import (InheritanceException)
 
 
 class inheritance_diagram(nodes.General, nodes.Element):
@@ -186,7 +84,7 @@ class InheritanceDiagram(Directive):
         try:
             graph = InheritanceGraph(
                 class_names, env.temp_data.get('py:module'),
-                parts=node['parts'])
+                __builtins__, parts=node['parts'])
         except InheritanceException as err:
             return [node.document.reporter.warning(err.args[0],
                                                    line=self.lineno)]
@@ -210,27 +108,6 @@ def get_graph_hash(node):
     return md5(hashString.encode('utf-8')).hexdigest()[-10:]
 
 
-def fix_class_name(name):
-    """Fix duplicated modules 'PySide6.QtCore.PySide6.QtCore.QObject'"""
-    mod_pos = name.rfind('.PySide')
-    return name[mod_pos + 1:] if mod_pos != -1 else name
-
-
-def expand_ref_uri(uri):
-    """Fix a ref URI like 'QObject.html#PySide6.QtCore.PySide6.QtCore.QObject'
-       to point from the image directory back to the HTML directory."""
-    anchor_pos = uri.find('#')
-    if anchor_pos == -1:
-        return uri
-    # Determine the path from the anchor "#PySide6.QtCore.PySide6.QtCore.QObject"
-    class_name = fix_class_name(uri[anchor_pos + 1:])
-    path = '../'
-    modules = class_name.split('.')
-    for m in range(min(2, len(modules))):
-        path += f'{modules[m]}/'
-    return path + uri[:anchor_pos]  # Strip anchor
-
-
 def html_visit_inheritance_diagram(self, node):
     """
     Output the graph for HTML.  This will insert a PNG with clickable
@@ -247,7 +124,7 @@ def html_visit_inheritance_diagram(self, node):
         ref_title = child.get('reftitle')
         uri = child.get('refuri')
         if uri and ref_title:
-            urls[fix_class_name(ref_title)] = expand_ref_uri(uri)
+            urls[ref_title] = uri
 
     dotcode = graph.generate_dot(name, urls, env=self.builder.env)
     render_dot_html(self, node, dotcode, {}, 'inheritance', 'inheritance',
diff --git a/sources/pyside6/doc/inheritance_diagram.pyproject b/sources/pyside6/doc/inheritance_diagram.pyproject
new file mode 100644
index 000000000..a44dc93b8
--- /dev/null
+++ b/sources/pyside6/doc/inheritance_diagram.pyproject
@@ -0,0 +1,6 @@
+{
+    "files": ["inheritance_diagram.py",
+              "import_inheritance.py",
+              "inheritance_graph.py",
+              "json_inheritance.py"]
+}
diff --git a/sources/pyside6/doc/inheritance_graph.py b/sources/pyside6/doc/inheritance_graph.py
new file mode 100644
index 000000000..00e0ac486
--- /dev/null
+++ b/sources/pyside6/doc/inheritance_graph.py
@@ -0,0 +1,145 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+import sys
+
+from import_inheritance import (get_inheritance_entries_by_import)
+from json_inheritance import (is_inheritance_from_json_enabled,
+                              get_inheritance_entries_from_json)
+
+
+TEST_DRIVER_USAGE = """Usage: inheritance_graph.py [module] [class]
+
+Example:
+python inheritance_graph.py  PySide6.QtWidgets PySide6.QtWidgets.QWizard
+"""
+
+
+def format_dict(d):
+    """Format the URL dict for error message."""
+    result = '{'
+    n = 0
+    for k, v in d.items():
+        n += 1
+        if n > 10:
+            result += "..."
+            break
+        if n > 1:
+            result += ", "
+        result += f'"{k}": "{v}"'
+    result += '}'
+    return result
+
+
+class InheritanceGraph(object):
+    """
+    Given a list of classes, determines the set of classes that they inherit
+    from all the way to the root "object", and then is able to generate a
+    graphviz dot graph from them.
+    """
+    def __init__(self, class_names, currmodule, builtins=None, show_builtins=False, parts=0):
+        """
+        *class_names* is a list of child classes to show bases from.
+
+        If *show_builtins* is True, then Python builtins will be shown
+        in the graph.
+        """
+        self.class_names = class_names
+        if is_inheritance_from_json_enabled():
+            self.class_info = get_inheritance_entries_from_json(class_names)
+        else:
+            self.class_info = get_inheritance_entries_by_import(class_names,
+                                                                currmodule,
+                                                                builtins,
+                                                                show_builtins,
+                                                                parts)
+
+    def get_all_class_names(self):
+        """
+        Get all of the class names involved in the graph.
+        """
+        return [fullname for (_, fullname, _) in self.class_info]
+
+    # These are the default attrs for graphviz
+    default_graph_attrs = {
+        'rankdir': 'LR',
+        'size': '"8.0, 12.0"',
+    }
+    default_node_attrs = {
+        'shape': 'box',
+        'fontsize': 10,
+        'height': 0.25,
+        'fontname': '"Vera Sans, DejaVu Sans, Liberation Sans, '
+                    'Arial, Helvetica, sans"',
+        'style': '"setlinewidth(0.5)"',
+    }
+    default_edge_attrs = {
+        'arrowsize': 0.5,
+        'style': '"setlinewidth(0.5)"',
+    }
+
+    def _format_node_attrs(self, attrs):
+        return ','.join([f'{x[0]}={x[1]}' for x in attrs.items()])
+
+    def _format_graph_attrs(self, attrs):
+        return ''.join([f"{x[0]}={x[1]};\n" for x in attrs.items()])
+
+    def generate_dot(self, name, urls={}, env=None,
+                     graph_attrs={}, node_attrs={}, edge_attrs={}):
+        """
+        Generate a graphviz dot graph from the classes that
+        were passed in to __init__.
+
+        *name* is the name of the graph.
+
+        *urls* is a dictionary mapping class names to HTTP URLs.
+
+        *graph_attrs*, *node_attrs*, *edge_attrs* are dictionaries containing
+        key/value pairs to pass on as graphviz properties.
+        """
+        g_attrs = self.default_graph_attrs.copy()
+        n_attrs = self.default_node_attrs.copy()
+        e_attrs = self.default_edge_attrs.copy()
+        g_attrs.update(graph_attrs)
+        n_attrs.update(node_attrs)
+        e_attrs.update(edge_attrs)
+        if env:
+            g_attrs.update(env.config.inheritance_graph_attrs)
+            n_attrs.update(env.config.inheritance_node_attrs)
+            e_attrs.update(env.config.inheritance_edge_attrs)
+
+        res = []
+        res.append(f'digraph {name} {{\n')
+        res.append(self._format_graph_attrs(g_attrs))
+
+        for name, fullname, bases in self.class_info:
+            # Write the node
+            this_node_attrs = n_attrs.copy()
+            url = urls.get(fullname)
+            if url is not None:
+                this_node_attrs['URL'] = f'"{url}"'
+                this_node_attrs['target'] = '"_top"'  # Browser target frame attribute (same page)
+            else:
+                urls_str = format_dict(urls)
+                print(f'inheritance_graph.py: No URL found for {name} ({fullname}) in {urls_str}.',
+                      file=sys.stderr)
+            attribute = self._format_node_attrs(this_node_attrs)
+            res.append(f'  "{name}" [{attribute}];\n')
+
+            # Write the edges
+            for base_name in bases:
+                attribute = self._format_node_attrs(e_attrs)
+                res.append(f'  "{base_name}" -> "{name}" [{attribute}];\n')
+        res.append('}\n')
+        return ''.join(res)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(TEST_DRIVER_USAGE)
+        sys.exit(-1)
+    module = sys.argv[1]
+    class_names = sys.argv[2:]
+    graph = InheritanceGraph(class_names, module)
+    dot = graph.generate_dot("test")
+    print(dot)
diff --git a/sources/pyside6/doc/modules.rst b/sources/pyside6/doc/modules.rst
index c4c8852bf..8e77a4616 100644
--- a/sources/pyside6/doc/modules.rst
+++ b/sources/pyside6/doc/modules.rst
@@ -7,358 +7,228 @@ Qt Modules Supported by Qt for Python
 
    PySide6/Qt*/index
 
-.. panels::
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    :mod:`QtBluetooth <PySide6.QtBluetooth>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtBluetooth <PySide6.QtBluetooth>`
 
-    The Bluetooth API provides connectivity between Bluetooth enabled devices.
+        The Bluetooth API provides connectivity between Bluetooth enabled
+        devices.
 
-    ---
 
-    :mod:`QtCharts <PySide6.QtCharts>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtCharts <PySide6.QtCharts>`
 
-    Provides a set of easy to use chart components.
+        Provides a set of easy to use chart components.
 
-    ---
+    .. grid-item-card:: :mod:`QtConcurrent <PySide6.QtConcurrent>`
 
-    :mod:`QtConcurrent <PySide6.QtConcurrent>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides high-level APIs that make it possible to write multi-threaded
+        programs without using low-level threading primitives such as mutexes,
+        read-write locks, wait conditions, or semaphores.
 
-    Provides high-level APIs that make it possible
-    to write multi-threaded programs without using low-level threading
-    primitives such as mutexes, read-write locks, wait conditions, or semaphores.
 
-    ---
+    .. grid-item-card:: :mod:`QtCore <PySide6.QtCore>`
 
-    :mod:`QtCore <PySide6.QtCore>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides core non-GUI functionality.
 
-    Provides core non-GUI functionality.
+    .. grid-item-card:: :mod:`QtDataVisualization <PySide6.QtDataVisualization>`
 
-    ---
+        Provides a way to visualize data in 3D as bar, scatter, and surface
+        graphs.
 
-    :mod:`QtDataVisualization <PySide6.QtDataVisualization>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtDBus <PySide6.QtDBus>`
 
-    Provides a way to visualize data in 3D as bar, scatter, and surface graphs.
+        D-Bus is an Inter-Process Communication (IPC) and Remote Procedure
+        Calling (RPC) mechanism originally developed for Linux to replace
+        existing and competing IPC solutions with one unified protocol
 
-    ---
+    .. grid-item-card:: :mod:`QtDesigner <PySide6.QtDesigner>`
 
-    :mod:`QtDBus <PySide6.QtDBus>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides classes to extend *Qt Widgets Designer*.
 
-    D-Bus is an Inter-Process Communication (IPC) and Remote Procedure
-    Calling (RPC) mechanism originally developed for Linux to replace
-    existing and competing IPC solutions with one unified protocol
+    .. grid-item-card:: :mod:`QtGui <PySide6.QtGui>`
 
-    ---
+        Extends QtCore with GUI functionality.
 
-    :mod:`QtDesigner <PySide6.QtDesigner>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtHelp <PySide6.QtHelp>`
 
-    Provides classes to extend Qt Designer.
+        Provides classes for integrating online documentation in applications.
 
-    ---
+    .. grid-item-card:: :mod:`Qt Multimedia <PySide6.QtMultimedia>`
 
-    :mod:`QtGui <PySide6.QtGui>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides API for multimedia-specific use cases.
 
-    Extends QtCore with GUI functionality.
+    .. grid-item-card:: :mod:`Qt Multimedia Widgets <PySide6.QtMultimediaWidgets>`
 
-    ---
+        Provides the widget-based multimedia API.
 
-    :mod:`QtHelp <PySide6.QtHelp>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtNetwork <PySide6.QtNetwork>`
 
-    Provides classes for integrating online documentation in applications.
+        Offers classes that let you to write TCP/IP clients and servers.
 
-    ---
+    .. grid-item-card:: :mod:`Qt Network Authorization <PySide6.QtNetworkAuth>`
 
-    :mod:`Qt Multimedia <PySide6.QtMultimedia>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides a set of APIs that enable Qt applications to obtain limited
+        access to online accounts and HTTP services without exposing users'
+        passwords.
 
-    Provides API for multimedia-specific use cases.
+    .. grid-item-card:: :mod:`QtNfc <PySide6.QtNfc>`
 
-    ---
+        The NFC API provides connectivity between NFC enabled devices.
 
-    :mod:`Qt Multimedia Widgets <PySide6.QtMultimediaWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtOpenGL <PySide6.QtOpenGL>`
 
-    Provides the widget-based multimedia API.
+        Offers classes that make it easy to use OpenGL in Qt applications.
 
-    ---
+    .. grid-item-card:: :mod:`QtOpenGL Widgets <PySide6.QtOpenGLWidgets>`
 
-    :mod:`QtNetwork <PySide6.QtNetwork>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides the OpenGLWidget class enabling OpenGL rendering for
+        a certain part of the widget tree.
 
-    Offers classes that let you to write TCP/IP clients and servers.
+    .. grid-item-card:: :mod:`Qt Positioning <PySide6.QtPositioning>`
 
-    ---
+        Provides access to position, satellite info and area monitoring
+        classes.
 
-    :mod:`Qt Network Authorization <PySide6.QtNetworkAuth>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt PDF <PySide6.QtPdf>`
 
-    Provides a set of APIs that enable Qt applications to obtain limited
-    access to online accounts and HTTP services without exposing users'
-    passwords.
+        Classes and functions for rendering PDF documents.
 
-    ---
+    .. grid-item-card:: :mod:`Qt PDF Widgets <PySide6.QtPdfWidgets>`
 
-    :mod:`QtNfc <PySide6.QtNfc>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        A PDF viewer widget.
 
-    The NFC API provides connectivity between NFC enabled devices.
+    .. grid-item-card:: :mod:`QtPrintSupport <PySide6.QtPrintSupport>`
 
-    ---
+        Provides extensive cross-platform support for printing.
 
-    :mod:`QtOpenGL <PySide6.QtOpenGL>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtQml <PySide6.QtQml>`
 
-    Offers classes that make it easy to use OpenGL in Qt applications.
+        Python API for Qt QML.
 
-    ---
+    .. grid-item-card:: :mod:`QtQuick <PySide6.QtQuick>`
 
-    :mod:`QtOpenGL Widgets <PySide6.QtOpenGLWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides classes for embedding Qt Quick in Qt applications.
 
-    Provides the  OpenGLWidget class enabling OpenGL rendering for a certain
-    part of the widget tree.
+    .. grid-item-card:: :mod:`QtQuickControls2 <PySide6.QtQuickControls2>`
 
-    ---
+        Provides classes for setting up the controls from C++.
 
-    :mod:`Qt Positioning <PySide6.QtPositioning>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtQuickTest <PySide6.QtQuickTest>`
 
-    Provides access to position, satellite info and area monitoring classes.
+       A unit test framework for QML applications where test cases are written as JavaScript functions.
 
-    ---
+    .. grid-item-card:: :mod:`QtQuickWidgets <PySide6.QtQuickWidgets>`
 
-    :mod:`Qt PDF <PySide6.QtPdf>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides the QQuickWidget class for embedding Qt Quick in widget-based applications.
 
-    Classes and functions for rendering PDF documents.
+    .. grid-item-card:: :mod:`QtRemoteObjects <PySide6.QtRemoteObjects>`
 
-    ---
+        Inter-Process Communication (IPC) module developed for Qt. This module
+        extends Qt's existing functionalities to enable information exchange
+        between processes or computers, easily.
 
-    :mod:`Qt PDF Widgets <PySide6.QtPdfWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt Scxml <PySide6.QtScxml>`
 
-    A PDF viewer widget.
+        Provides classes to create and use state machines from SCXML files.
 
-    ---
+    .. grid-item-card:: :mod:`Qt Sensors <PySide6.QtSensors>`
 
-    :mod:`QtPrintSupport <PySide6.QtPrintSupport>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides access to sensor hardware.
 
-    Provides extensive cross-platform support for printing.
+    .. grid-item-card:: :mod:`Qt Serial Bus <PySide6.QtSerialBus>`
 
-    ---
+        Provides access to serial industrial bus interfaces. Currently, the
+        module supports the CAN bus and Modbus protocols.
 
-    :mod:`QtQml <PySide6.QtQml>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt Serial Port <PySide6.QtSerialPort>`
 
-    Python API for Qt QML.
+        Provides classes to interact with hardware and virtual serial ports.
 
-    ---
+    .. grid-item-card:: :mod:`Qt Spatial Audio <PySide6.QtSpatialAudio>`
 
-    :mod:`QtQuick <PySide6.QtQuick>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides APIs for modeling sound source and their surrounds in 3D
+        space.
 
-    Provides classes for embedding Qt Quick in Qt applications.
+    .. grid-item-card:: :mod:`QtSql <PySide6.QtSql>`
 
-    ---
+        Helps you provide seamless database integration to your Qt
+        applications.
 
-    :mod:`QtQuickControls2 <PySide6.QtQuickControls2>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtStateMachine <PySide6.QtStateMachine>`
 
-    Provides classes for setting up the controls from C++.
+        Provides classes for creating and executing state graphs.
 
-    ---
+    .. grid-item-card:: :mod:`QtSvg <PySide6.QtSvg>`
 
-    :mod:`QtQuickWidgets <PySide6.QtQuickWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides classes for displaying the contents of SVG files.
 
-    Provides the QQuickWidget class for embedding Qt Quick in widget-based applications.
+    .. grid-item-card:: :mod:`QtSvgWidgets <PySide6.QtSvgWidgets>`
 
-    ---
+        Provides a widget that is used to display the contents of SVG files.
 
-    :mod:`QtRemoteObjects <PySide6.QtRemoteObjects>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtTest <PySide6.QtTest>`
 
-    Inter-Process Communication (IPC) module developed for Qt. This module
-    extends Qt's existing functionalities to enable information exchange
-    between processes or computers, easily.
+        Provides classes for unit testing Qt applications and libraries.
 
-    ---
+    .. grid-item-card:: :mod:`QtUiTools <PySide6.QtUiTools>`
 
-    :mod:`Qt Scxml <PySide6.QtScxml>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides classes to handle forms created with *Qt Widgets Designer*.
 
-    Provides classes to create and use state machines from SCXML files.
+    .. grid-item-card:: :mod:`Qt WebChannel <PySide6.QtWebChannel>`
 
-    ---
+        Provides access to QObject or QML objects from HTML clients for
+        seamless integration of Qt applications with HTML/JavaScript clients.
 
-    :mod:`Qt Sensors <PySide6.QtSensors>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtWebEngine Core C++ Classes <PySide6.QtWebEngineCore>`
 
-    Provides access to sensor hardware.
+        Provides public API shared by both QtWebEngine and QtWebEngineWidgets.
 
-    ---
+    .. grid-item-card:: :mod:`QtWebEngine Widgets C++ Classes <PySide6.QtWebEngineWidgets>`
 
-    :mod:`Qt Serial Bus <PySide6.QtSerialBus>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Provides C++ classes for rendering web content in a QWidget based
+        application.
 
-    Provides access to serial industrial bus interfaces. Currently, the module
-    supports the CAN bus and Modbus protocols.
+    .. grid-item-card:: :mod:`QtWebEngine QML Types <PySide6.QtWebEngineQuick>`
 
-    ---
+        Provides QML types for rendering web content within a QML application.
 
-    :mod:`Qt Serial Port <PySide6.QtSerialPort>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt WebSockets <PySide6.QtWebSockets>`
 
-    Provides classes to interact with hardware and virtual serial ports.
+        Provides WebSocket communication compliant with RFC 6455.
 
-    ---
+    .. grid-item-card:: :mod:`QtWidgets <PySide6.QtWidgets>`
 
-    :mod:`Qt Spatial Audio <PySide6.QtSpatialAudio>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Extends Qt GUI with C++ widget functionality.
 
-    Provides APIs for modeling sound source and their surrounds in 3D space.
+    .. grid-item-card:: :mod:`QtXml <PySide6.QtXml>`
 
-    ---
+        Provides a C++ implementation of DOM.
 
-    :mod:`QtSql <PySide6.QtSql>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt3DAnimation <PySide6.Qt3DAnimation>`
 
-    Helps you provide seamless database integration to your Qt applications.
+        Provides basic elements required to animate 3D objects.
 
-    ---
+    .. grid-item-card:: :mod:`Qt3D Core <PySide6.Qt3DCore>`
 
-    :mod:`QtStateMachine <PySide6.QtStateMachine>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Contains functionality to support near-realtime simulation systems.
 
-    Provides classes for creating and executing state graphs.
+    .. grid-item-card:: :mod:`Qt3D Extras <PySide6.Qt3DExtras>`
 
-    ---
+        Provides a set of prebuilt elements to help you get started with Qt 3D.
 
-    :mod:`QtSvg <PySide6.QtSvg>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`Qt3D Input <PySide6.Qt3DInput>`
 
-    Provides classes for displaying the contents of SVG files.
+        Provides classes for handling user input in applications using Qt 3D.
 
-    ---
+    .. grid-item-card:: :mod:`Qt3D Logic <PySide6.Qt3DLogic>`
 
-    :mod:`QtSvgWidgets <PySide6.QtSvgWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Enables synchronizing frames with the Qt 3D backend.
 
-    Provides a widget that is used to display the contents of SVG files.
+    .. grid-item-card:: :mod:`Qt3D Render <PySide6.Qt3DRender>`
 
-    ---
+        Contains functionality to support 2D and 3D rendering using Qt 3D.
 
-    :mod:`QtTest <PySide6.QtTest>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: :mod:`QtAsyncio <PySide6.QtAsyncio>`
 
-    Provides classes for unit testing Qt applications and libraries.
-
-    ---
-
-    :mod:`QtUiTools <PySide6.QtUiTools>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides classes to handle forms created with Qt Designer.
-
-    ---
-
-    :mod:`Qt WebChannel <PySide6.QtWebChannel>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides access to QObject or QML objects from HTML clients for seamless
-    integration of Qt applications with HTML/JavaScript clients.
-
-    ---
-
-    :mod:`QtWebEngine Core C++ Classes <PySide6.QtWebEngineCore>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides public API shared by both QtWebEngine and QtWebEngineWidgets.
-
-    ---
-
-    :mod:`QtWebEngine Widgets C++ Classes <PySide6.QtWebEngineWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides C++ classes for rendering web content in a QWidget based application.
-
-    ---
-
-    :mod:`QtWebEngine QML Types <PySide6.QtWebEngineQuick>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides QML types for rendering web content within a QML application.
-
-    ---
-
-    :mod:`Qt WebSockets <PySide6.QtWebSockets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides WebSocket communication compliant with RFC 6455.
-
-    ---
-
-    :mod:`QtWidgets <PySide6.QtWidgets>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Extends Qt GUI with C++ widget functionality.
-
-    ---
-
-    :mod:`QtXml <PySide6.QtXml>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides a C++ implementation of DOM.
-
-    ---
-
-    :mod:`Qt3DAnimation <PySide6.Qt3DAnimation>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides basic elements required to animate 3D objects.
-
-    ---
-
-    :mod:`Qt3D Core <PySide6.Qt3DCore>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Contains functionality to support near-realtime simulation systems.
-
-    ---
-
-    :mod:`Qt3D Extras <PySide6.Qt3DExtras>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides a set of prebuilt elements to help you get started with Qt 3D.
-
-    ---
-
-    :mod:`Qt3D Input <PySide6.Qt3DInput>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Provides classes for handling user input in applications using Qt 3D.
-
-    ---
-
-    :mod:`Qt3D Logic <PySide6.Qt3DLogic>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Enables synchronizing frames with the Qt 3D backend.
-
-    ---
-
-    :mod:`Qt3D Render <PySide6.Qt3DRender>`
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    Contains functionality to support 2D and 3D rendering using Qt 3D.
+        Provides integration between asyncio and Qt's event loop.
diff --git a/sources/pyside6/doc/pysideinclude.py b/sources/pyside6/doc/pysideinclude.py
index 91fffe115..8e2834cce 100644
--- a/sources/pyside6/doc/pysideinclude.py
+++ b/sources/pyside6/doc/pysideinclude.py
@@ -11,9 +11,9 @@ from os import path
 from docutils import nodes
 from docutils.parsers.rst import Directive, directives
 
-from sphinx import addnodes
 from sphinx.util import parselinenos
 
+
 class PySideInclude(Directive):
     """
     Like ``.. include:: :literal:``, but only warns if the include file is
@@ -68,7 +68,7 @@ class PySideInclude(Directive):
         codec_info = codecs.lookup(encoding)
         try:
             f = codecs.StreamReaderWriter(open(fn, 'Ub'),
-                    codec_info[2], codec_info[3], 'strict')
+                                          codec_info[2], codec_info[3], 'strict')
             lines = f.readlines()
             f.close()
         except (IOError, OSError):
@@ -91,7 +91,7 @@ class PySideInclude(Directive):
                     'Object named %r not found in include file %r' %
                     (objectname, filename), line=self.lineno)]
             else:
-                lines = lines[tags[objectname][1]-1 : tags[objectname][2]-1]
+                lines = lines[tags[objectname][1] - 1: tags[objectname][2] - 1]
 
         linespec = self.options.get('lines')
         if linespec is not None:
@@ -102,10 +102,10 @@ class PySideInclude(Directive):
             lines = [lines[i] for i in linelist]
 
         startafter = self.options.get('start-after')
-        endbefore  = self.options.get('end-before')
-        prepend    = self.options.get('prepend')
-        append     = self.options.get('append')
-        snippet    = self.options.get('snippet')
+        endbefore = self.options.get('end-before')
+        prepend = self.options.get('prepend')
+        append = self.options.get('append')
+        snippet = self.options.get('snippet')
 
         if snippet:
             startafter = "//![%s]" % snippet
@@ -126,9 +126,9 @@ class PySideInclude(Directive):
             lines = res
 
         if prepend:
-           lines.insert(0, prepend + '\n')
+            lines.insert(0, prepend + '\n')
         if append:
-           lines.append(append + '\n')
+            lines.append(append + '\n')
 
         text = ''.join(lines)
         if self.options.get('tab-width'):
@@ -143,5 +143,6 @@ class PySideInclude(Directive):
         document.settings.env.note_dependency(rel_fn)
         return [retnode]
 
+
 def setup(app):
     app.add_directive('pysideinclude', PySideInclude)
diff --git a/sources/pyside6/doc/qdoc_spawner.py.in b/sources/pyside6/doc/qdoc_spawner.py.in
new file mode 100644
index 000000000..d9d434366
--- /dev/null
+++ b/sources/pyside6/doc/qdoc_spawner.py.in
@@ -0,0 +1,105 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+import argparse
+import subprocess
+import os
+import sys
+import time
+from multiprocessing import Pool, cpu_count
+from pathlib import Path
+
+
+def run_qdoc(file, qdoc_args, args):
+    env = os.environ
+    env["BUILDDIR"] = args.build_dir
+    env["QT_INSTALL_DOCS"] = args.qt_install_docs
+    env["QT_VERSION"] = args.qt_version
+    env["QT_VER"] = ".".join(args.qt_version.split(".")[:2])
+    env["QT_VERSION_TAG"] = args.qt_version
+
+    command = [
+        args.qdoc_bin,
+        file,
+        *qdoc_args,
+        "-installdir",
+        args.doc_data_dir,
+        "-outputdir",
+        args.doc_data_dir,
+    ]
+
+    start_time = time.time()
+    _ = subprocess.Popen(command, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = _.communicate()
+    returncode = _.wait()
+    duration = round(time.time() - start_time)
+
+    if args.verbose or returncode != 0 or err:
+       cmd_str = " ".join(command)
+       print(f"> Output of: {cmd_str}")
+       if out:
+           print(out.decode("utf-8"), file=sys.stdout)
+       if err:
+            print(err.decode("utf-8"), file=sys.stderr)
+       print(f"> Finished: {file} {duration}s (exit code {returncode})")
+
+    if returncode != 0:
+       raise Exception(f"Failing executing the command {command} ({returncode})")
+
+
+def get_qdocconf_files():
+    if not Path("pyside.qdocconf").exists():
+        print("ERROR: the working dir doesn't include a 'pyside.qdocconf' file")
+        sys.exit(-1)
+
+    # Generate the temporary qdocconf files
+    # This is necessary because using a file like 'pyside-qtcore.qtdocconf'
+    # will generate an error, because inside we call functions like 'include()'
+    files_single_exec = []
+    files_prepare = []
+    with open("pyside.qdocconf") as f:
+        for i in f.read().splitlines():
+            _p = Path(i)
+            _name = f"_{_p.stem}.qdocconf"
+            with open(_name, "w", encoding="utf-8") as f:
+                f.write(i)
+            files_single_exec.append(_name)
+            files_prepare.append(i.strip())
+
+    return files_prepare, files_single_exec
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(prog="qdoc spawner")
+    parser.add_argument("--qt", dest="qt_version", action="store", required=True)
+    parser.add_argument("--doc-data-dir", dest="doc_data_dir", action="store", required=True)
+    parser.add_argument("--qdoc-binary", dest="qdoc_bin", action="store", required=True)
+    parser.add_argument("--build-dir", dest="build_dir", action="store", required=True)
+    parser.add_argument("--qt-install-docs", dest="qt_install_docs", action="store", required=True)
+    parser.add_argument("--parallel", dest="parallel", action="store", default="4")
+    parser.add_argument("--verbose", dest="verbose", action="store_true", default=False)
+
+    args = parser.parse_args()
+
+    core_index = Path(args.doc_data_dir) / "webxml" / "qtcore-index.webxml"
+    if core_index.is_file():
+        print(f"qdoc_spawner: {core_index} already exists, bailing out")
+        sys.exit(0)
+
+    files_prepare, files_single_exec = get_qdocconf_files()
+
+    parallel = args.parallel
+    if parallel == "auto":
+        parallel = cpu_count()
+
+    try:
+        # mode: -prepare -no-link-errors
+        with Pool(int(parallel)) as p:
+            p.starmap(run_qdoc, [(str(f), ["-prepare", "-no-link-errors"], args) for f in files_prepare])
+
+        # mode: -single-exec
+        with Pool(int(parallel)) as p:
+            p.starmap(run_qdoc, [(str(f), ["-single-exec"], args) for f in files_single_exec])
+    except Exception as e:
+        print(f"qdoc_spawner: error: {e}", file=sys.stderr)
+        sys.exit(-1)
diff --git a/sources/pyside6/doc/qtattributionsscannertorst.py b/sources/pyside6/doc/qtattributionsscannertorst.py
index 216c1439b..677371c45 100644
--- a/sources/pyside6/doc/qtattributionsscannertorst.py
+++ b/sources/pyside6/doc/qtattributionsscannertorst.py
@@ -8,7 +8,6 @@ Tool to run qtattributionsscanner and convert its output to rst
 import os
 import json
 import subprocess
-import sys
 import warnings
 from argparse import ArgumentParser, RawTextHelpFormatter
 from pathlib import Path
@@ -22,11 +21,12 @@ libexec_dir = None
 
 def indent(lines, indent):
     result = ''
-    for l in lines:
-        result = f"{result}{indent}{l}\n"
+    for line in lines:
+        result = f"{result}{indent}{line}\n"
     return result
 
-rstHeader="""Licenses Used in Qt for Python
+
+rstHeader = """Licenses Used in Qt for Python
 ******************************
 
 Qt for Python contains some code that is not provided under the
@@ -52,18 +52,23 @@ code licensed under third-party opensource licenses:
 
 """
 
+
 def rstHeadline(title):
     return f"{title}\n{'-' * len(title)}\n"
 
+
 def rstUrl(title, url):
     return f"`{title} <{url}>`_"
 
+
 def rstLiteralBlock(lines):
     return f"::\n\n{indent(lines, '    ')}\n\n"
 
+
 def rstLiteralBlockFromText(text):
     return rstLiteralBlock(text.strip().split('\n'))
 
+
 def readFile(fileName):
     with open(fileName, 'r') as file:
         return file.readlines()
@@ -90,7 +95,7 @@ def runScanner(directory, targetFileName, libexec_dir):
             url = entry['Homepage']
             version = entry['Version']
             if url and version:
-                content = f"{content}{rstUrl('Project Homepage', url)}, upstream version: {version}\n\n"
+                content = f"{content}{rstUrl('Project Homepage', url)}, upstream version: {version}\n\n"  # noqa E:501
             copyright = entry['Copyright']
             if copyright:
                 content += rstLiteralBlockFromText(copyright)
diff --git a/sources/pyside6/doc/qtmodules/pyside-qtdoc.qdocconf.in b/sources/pyside6/doc/qtmodules/pyside-qtdoc.qdocconf.in
new file mode 100644
index 000000000..88cc3eac4
--- /dev/null
+++ b/sources/pyside6/doc/qtmodules/pyside-qtdoc.qdocconf.in
@@ -0,0 +1,2 @@
+include(@QT_SRC_DIR@/../qtdoc/doc/config/qtdoc.qdocconf)
+include(../pyside-config.qdocconf)
diff --git a/sources/pyside6/doc/qtmodules/pyside-qtquickcontrols2.qdocconf.in b/sources/pyside6/doc/qtmodules/pyside-qtquickcontrols2.qdocconf.in
index bfd339ba6..4d0a55946 100644
--- a/sources/pyside6/doc/qtmodules/pyside-qtquickcontrols2.qdocconf.in
+++ b/sources/pyside6/doc/qtmodules/pyside-qtquickcontrols2.qdocconf.in
@@ -1,3 +1,3 @@
-include(@QT_SRC_DIR@/../qtdeclarative/src/quickcontrols2/doc/qtquickcontrols.qdocconf)
-includepaths += -I @QT_SRC_DIR@/../qtquickcontrols2/src/quickcontrols2
+include(@QT_SRC_DIR@/../qtdeclarative/src/quickcontrols/doc/qtquickcontrols.qdocconf)
+includepaths += -I @QT_SRC_DIR@/../qtdeclarative/src/quickcontrols
 include(../pyside-config.qdocconf)
diff --git a/sources/pyside6/doc/qtmodules/pyside-qtquicktest.qdocconf.in b/sources/pyside6/doc/qtmodules/pyside-qtquicktest.qdocconf.in
new file mode 100644
index 000000000..1d8397537
--- /dev/null
+++ b/sources/pyside6/doc/qtmodules/pyside-qtquicktest.qdocconf.in
@@ -0,0 +1,3 @@
+include(@QT_SRC_DIR@/../qtdeclarative/src/qmltest/doc/qtqmltest.qdocconf)
+includepaths += -I @QT_SRC_DIR@/../qtdeclarative/src/qmltest
+include(../pyside-config.qdocconf)
diff --git a/sources/pyside6/doc/quickstart.rst b/sources/pyside6/doc/quickstart.rst
index 141edf94c..7e1a210f2 100644
--- a/sources/pyside6/doc/quickstart.rst
+++ b/sources/pyside6/doc/quickstart.rst
@@ -4,20 +4,32 @@ Quick start
 ===========
 
 New to Qt? Check also the :ref:`faq-section` section at the end of this page.
+In case you own a Qt License, please refer to :ref:`commercial-page`.
+
+.. note:: Having Qt installed in your system will not interfere with your
+   PySide6 installation if you do it via ``pip install``, because the Python
+   packages (wheels) include already Qt binaries. Most notably, style plugins
+   from the system won't have any effect on PySide applications.
 
 Requirements
 ------------
 
 Before you can install |project|, first you must install the following software:
 
- * Python 3.7+,
- * We recommend using a virtual environment, such as
-   `venv <https://docs.python.org/3/library/venv.html>`_ or
-   `virtualenv <https://virtualenv.pypa.io/en/latest>`_
+* Python 3.7+,
+* We **highly** recommend using a virtual environment, such as
+  `venv <https://docs.python.org/3/library/venv.html>`_ or
+  `virtualenv <https://virtualenv.pypa.io/en/latest>`_
+  and avoid installing PySide6 via ``pip`` in your system.
+
+.. note:: For Windows users, please use the interpreter from https://python.org/download
+    rather than the one installed from the Microsoft Store.
 
 Installation
 ------------
 
+.. note:: For a commercial installation, refer to :ref:`commercial-page`.
+
 * **Creating and activating an environment**
   You can do this by running the following on a terminal:
 
@@ -36,7 +48,7 @@ Installation
   Check this animation on how to do it:
 
   .. image:: https://qt-wiki-uploads.s3.amazonaws.com/images/8/8a/Pyside6_install.gif
-     :alt: Installation gif
+     :alt: Installation GIF
 
 * **Installing PySide6**
 
@@ -54,7 +66,15 @@ Installation
   * It is also possible to install a specific snapshot from our servers.
     To do so, you can use the following command::
 
-      pip install --index-url=https://download.qt.io/snapshots/ci/pyside/6.0.0/latest pyside6 --trusted-host download.qt.io
+      pip install --index-url=https://download.qt.io/snapshots/ci/pyside/6.4/latest pyside6 --trusted-host download.qt.io
+
+  .. note:: Starting with 6.4.3, PySide6 can be used from inside a
+    `conda <https://conda.io>`_ environment, but any manual changes you make to
+    the ``qt.conf`` file will be ignored. If you want to set custom values to
+    the Qt configuration, set them in a ``qt6.conf`` file instead.
+    Read more about `qt.conf`_.
+
+.. _`qt.conf`: https://doc.qt.io/qt-6/qt-conf.html
 
 * **Test your installation**
 
@@ -72,8 +92,8 @@ Installation
 .. note:: For more information about what's included in the ``pyside6``
    package, check :ref:`package_details`.
 
-Create a Simple Application
----------------------------
+Create a Simple Qt Widgets Application
+--------------------------------------
 
 Your |project| setup is ready. You can explore it further by developing a simple application
 that prints "Hello World" in several languages. The following instructions will
@@ -88,12 +108,12 @@ guide you through the development process:
     from PySide6 import QtCore, QtWidgets, QtGui
 
   The |pymodname| Python module provides access to the Qt APIs as its submodule.
-  In this case, you are importing the :code:`QtCore`, :code:`QtWidgets`, and :code:`QtGui` submodules.
+  In this case, you are importing the :ref:`QtCore`, :ref:`QtWidgets`, and :ref:`QtGui` submodules.
 
 * **Main Class**
 
-  Define a class named :code:`MyWidget`, which extends QWidget and includes a QPushButton and
-  QLabel.::
+  Define a class named :code:`MyWidget`, which extends :ref:`QWidget` and
+  includes a :ref:`QPushButton` and :ref:`QLabel`.::
 
     class MyWidget(QtWidgets.QWidget):
         def __init__(self):
@@ -115,8 +135,9 @@ guide you through the development process:
         def magic(self):
             self.text.setText(random.choice(self.hello))
 
-  The MyWidget class has the :code:`magic` member function that randomly chooses an item from the
-  :code:`hello` list. When you click the button, the :code:`magic` function is called.
+  The ``MyWidget`` class has the :code:`magic` member function that randomly
+  chooses an item from the :code:`hello` list. When you click the button, the
+  :code:`magic` function is called.
 
 * **Application execution**
 
@@ -138,6 +159,81 @@ guide you through the development process:
   .. image:: images/screenshot_hello.png
      :alt: Hello World application
 
+Create a Simple Quick Application
+---------------------------------
+
+To do the same using Qt Quick:
+
+* **Imports**
+
+  Create a new file named :code:`hello_world_quick.py`, and add the following imports to it.::
+
+    import sys
+    from PySide6.QtGui import QGuiApplication
+    from PySide6.QtQml import QQmlApplicationEngine
+
+* **Declarative UI**
+
+  The UI can be described in the QML language (assigned to a Python variable)::
+
+    QML = """
+    import QtQuick
+    import QtQuick.Controls
+    import QtQuick.Layouts
+
+    Window {
+        width: 300
+        height: 200
+        visible: true
+        title: "Hello World"
+
+        readonly property list<string> texts: ["Hallo Welt", "Hei maailma",
+                                               "Hola Mundo", "Привет мир"]
+
+        function setText() {
+            var i = Math.round(Math.random() * 3)
+            text.text = texts[i]
+        }
+
+        ColumnLayout {
+            anchors.fill:  parent
+
+            Text {
+                id: text
+                text: "Hello World"
+                Layout.alignment: Qt.AlignHCenter
+            }
+            Button {
+                text: "Click me"
+                Layout.alignment: Qt.AlignHCenter
+                onClicked:  setText()
+            }
+        }
+    }
+    """
+
+  .. note:: Keep in mind ideally this content should go into
+    a ``qml`` file, but for simplicity, we are using a string variable.
+
+* **Application execution**
+
+  Now, add a main function where you instantiate a :ref:`QQmlApplicationEngine` and
+  load the QML::
+
+    if __name__ == "__main__":
+        app = QGuiApplication(sys.argv)
+        engine = QQmlApplicationEngine()
+        engine.loadData(QML.encode('utf-8'))
+        if not engine.rootObjects():
+            sys.exit(-1)
+        exit_code = app.exec()
+        del engine
+        sys.exit(exit_code)
+
+
+  .. note:: This is a simplified example. Normally, the QML code should be in a separate
+     :code:`.qml` file, which can be edited by design tools.
+
 .. _faq-section:
 
 Frequently Asked Questions
@@ -146,45 +242,38 @@ Frequently Asked Questions
 Here you can find a couple of common questions and situations that will
 clarify questions before you start programming.
 
-.. panels::
-    :container: container-lg pb-1
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-
-    .. link-button:: faq/whatisqt
-        :type: ref
-        :text: Qt, QML, Widgets... What is the difference?
-        :classes: btn-link btn-block stretched-link
-    ---
-
-    .. link-button:: faq/whichide
-        :type: ref
-        :text: Which IDEs are compatible with PySide?
-        :classes: btn-link btn-block stretched-link
-    ---
-
-    .. link-button:: faq/whatisshiboken
-        :type: ref
-        :text: Binding Generation: What is Shiboken?
-        :classes: btn-link btn-block stretched-link
-    ---
-
-    .. link-button:: faq/typesoffiles
-        :type: ref
-        :text: File Types in PySide
-        :classes: btn-link btn-block stretched-link
-    ---
-
-    .. link-button:: faq/distribution
-        :type: ref
-        :text: Distributing your application to other systems and platforms
-        :classes: btn-link btn-block stretched-link
-
-    ---
-
-    .. link-button:: faq/whyqtforpython
-        :type: ref
-        :text: As a Qt/C++ developer, why should I consider Qt for Python?
-        :classes: btn-link btn-block stretched-link
+.. grid:: 1 3 3 3
+    :gutter: 2
+
+    .. grid-item-card:: What is Qt
+        :link: faq/whatisqt.html
+
+        Qt, QML, Widgets... What is the difference?
+
+    .. grid-item-card:: Compatible IDEs
+        :link: faq/whichide.html
+
+        Which IDEs are compatible with PySide?
+
+    .. grid-item-card:: Binding Generation
+        :link: faq/whatisshiboken.html
+
+        What is Shiboken?
+
+    .. grid-item-card:: File types
+        :link: faq/typesoffiles.html
+
+        File Types in PySide
+
+    .. grid-item-card:: App distribution
+        :link: faq/distribution.html
+
+        Distributing your application to other systems and platforms
+
+    .. grid-item-card:: Why Qt for Python?
+        :link: faq/whyqtforpython.html
+
+        As a Qt/C++ developer, why should I consider Qt for Python?
 
 .. toctree::
     :hidden:
@@ -196,4 +285,3 @@ clarify questions before you start programming.
     faq/distribution.rst
     faq/whyqtforpython.rst
 
-
diff --git a/sources/pyside6/doc/snippets/qtbase/src/gui/doc/snippets/code/src_gui_painting_qpainter_drawText.cpp.py b/sources/pyside6/doc/snippets/qtbase/src/gui/doc/snippets/code/src_gui_painting_qpainter_drawText.cpp.py
new file mode 100644
index 000000000..cad2c5395
--- /dev/null
+++ b/sources/pyside6/doc/snippets/qtbase/src/gui/doc/snippets/code/src_gui_painting_qpainter_drawText.cpp.py
@@ -0,0 +1,13 @@
+painter = QPainter(self)
+font = painter.font()
+font.setPixelSize(48)
+painter.setFont(font)
+rectangle = QRect(0, 0, 100, 50)
+boundingRect = painter.drawText(rectangle, 0, "Hello")
+pen = painter.pen()
+pen.setStyle(Qt.DotLine)
+painter.setPen(pen)
+painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width()))
+pen.setStyle(Qt.DashLine)
+painter.setPen(pen)
+painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()))
diff --git a/sources/pyside6/doc/tools/index.rst b/sources/pyside6/doc/tools/index.rst
new file mode 100644
index 000000000..b421a428f
--- /dev/null
+++ b/sources/pyside6/doc/tools/index.rst
@@ -0,0 +1,211 @@
+.. _package_tools:
+
+Tools
+=====
+
+Following the same idea from the modules, we also include in the packages
+(wheels) Qt tools that are important for any Qt application development
+workflow, like ``uic``, ``rcc``, etc.
+
+All the tools **must** be used from the PySide wrappers, and not directly.
+For example, if exploring the ``site-packages/`` directory on your installation
+you find ``uic.exe`` (on Windows), you should not click on that, and use
+``pyside6-uic.exe`` instead.
+The reason for this is the proper setup of PATHs, plugins, and more,
+to properly work with the installed Python package.
+
+Here you can find all the tools we include in |project| starting
+from 6.3.0, grouped by different topics:
+
+Project development
+~~~~~~~~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-project``
+        :link: pyside6-project
+        :link-type: ref
+
+        to build *Qt Widgets Designer* forms (``.ui`` files),
+        resource files (``.qrc``) and QML type files (``.qmltype``)
+        from a ``.pyproject`` file.
+
+Widget Development
+~~~~~~~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-designer``
+        :link: pyside6-designer
+        :link-type: ref
+
+        drag-and-drop tool for designing Widget UIs (generates ``.ui`` files,
+        see :ref:`using_ui_files`).
+
+    .. grid-item-card:: ``pyside6-uic``
+        :link: pyside6-uic
+        :link-type: ref
+
+        to generate Python code from ``.ui`` form files.
+
+    .. grid-item-card:: ``pyside6-rcc``
+        :link: pyside6-rcc
+        :link-type: ref
+
+        to generate serialized data from ``.qrc`` resources files.
+        Keep in mind these files can be used in other non-widget projects.
+
+
+QML Development
+~~~~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-qmllint``
+        :link: pyside6-qmllint
+        :link-type: ref
+
+        that verifies the syntactic validity of QML files.
+
+    .. grid-item-card:: ``pyside6-qmltyperegistrar``
+        :link: pyside6-qmltyperegistrar
+        :link-type: ref
+
+        to read metatypes files and generate files that contain the necessary
+        code to register all the types marked with relevant macros.
+
+    .. grid-item-card:: ``pyside6-qmlimportscanner``
+        :link: pyside6-qmlimportscanner
+        :link-type: ref
+
+        to identify the QML modules imported from a
+        project/QML files and dump the result as a JSON array.
+
+    .. grid-item-card:: ``pyside6-qmlcachegen``
+        :link: pyside6-qmlcachegen
+        :link-type: ref
+
+        to compile QML to bytecode at compile time for bundling inside the
+        binary.
+
+    .. grid-item-card:: ``pyside6-qml``
+        :link: pyside6-qml
+        :link-type: ref
+
+        to enable quick prototyping with QML files. This tool mimics some of
+        the capabilities of Qt's ``QML`` runtime utility by
+        directly invoking QQmlEngine/QQuickView.
+
+Translations
+~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-linguist``
+        :link: pyside6-linguist
+        :link-type: ref
+
+        for translating text in applications.
+
+    .. grid-item-card:: ``pyside6-lrelease``
+        :link: pyside6-lrelease
+        :link-type: ref
+
+        to create run-time translation files for the application.
+
+    .. grid-item-card:: ``pyside6-lupdate``
+        :link: pyside6-lupdate
+        :link-type: ref
+
+        to synchronize source code and translations.
+
+Qt Help
+~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-assistant``
+        :link: pyside6-assistant
+        :link-type: ref
+
+        for viewing online documentation in Qt Help file format.
+        Read more about the formats on the `QtHelp Framework`_ page.
+
+.. _`QtHelp Framework`: https://doc.qt.io/qt-6/qthelp-framework.html
+
+PySide Utilities
+~~~~~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-genpyi``
+        :link: pyside6-genpyi
+        :link-type: ref
+
+        to generate Python stubs (``.pyi`` files) for Qt modules.
+
+    .. grid-item-card:: ``pyside6-metaobjectdump``
+        :link: pyside6-metaobjectdump
+        :link-type: ref
+
+        a tool to print out the metatype information in JSON to be used as
+        input for ``qmltyperegistrar``.
+
+Deployment
+~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-deploy``
+        :link: pyside6-deploy
+        :link-type: ref
+
+        to deploy PySide6 applications to desktop platforms - Linux, Windows
+        and macOS.
+
+    .. grid-item-card:: ``pyside6-android-deploy``
+        :link: pyside6-android-deploy
+        :link-type: ref
+
+        to deploy PySide6 application as an Android app targeting different
+        Android platforms - aarch64, armv7a, i686, x86_64.
+
+Shader Tools
+~~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-qsb``
+        :link: pyside6-qsb
+        :link-type: ref
+
+        a command-line tool provided by the Qt Shader Tools modules to
+        generate and inspect .qsb files.
+
+Qt Quick 3D
+~~~~~~~~~~~
+
+.. grid:: 2
+    :gutter: 3 3 4 5
+
+    .. grid-item-card:: ``pyside6-balsam``
+        :link: pyside6-balsam
+        :link-type: ref
+
+        a command line tool that takes assets created in digital content
+        creation tools like Maya, 3ds Max or Blender and converts them into an
+        efficient runtime format for use with Qt Quick 3D.
+
+    .. grid-item-card:: ``pyside6-balsamui``
+        :link: pyside6-balsamui
+        :link-type: ref
+
+        a graphical user interface for the ``pyside6-balsam`` tool.
diff --git a/sources/pyside6/doc/tools/pyside-assistant.rst b/sources/pyside6/doc/tools/pyside-assistant.rst
new file mode 100644
index 000000000..c9b3470c3
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-assistant.rst
@@ -0,0 +1,21 @@
+.. _pyside6-assistant:
+
+pyside6-assistant
+=================
+
+``pyside6-assistant`` is a tool that wraps `Qt Assistant`_, the help
+viewer of Qt for use with the Qt help file format (see `The Qt Help Framework`_).
+
+The version of assistant shipped with Qt for Python does not contain
+any documentation.
+
+You can build the Qt for Python documentation in the Qt help file format
+(see :ref:`building_documentation`) and register it for use in `Preferences`
+dialog of ``pyside6-assistant`` (`Edit/Preferences`).
+
+.. image:: pyside6-assistant_screenshot.webp
+    :width: 381
+    :alt: PySide6 Assistant Screenshot
+
+.. _`Qt Assistant`: https://doc.qt.io/qt-6/qtassistant-index.html
+.. _`The Qt Help Framework`: https://doc.qt.io/qt-6/qthelp-framework.html
diff --git a/sources/pyside6/doc/tools/pyside-designer.rst b/sources/pyside6/doc/tools/pyside-designer.rst
new file mode 100644
index 000000000..4cde6b2bf
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-designer.rst
@@ -0,0 +1,91 @@
+.. _pyside6-designer:
+
+pyside6-designer
+================
+
+``pyside6-designer`` is a tool that wraps the `Qt Widgets Designer`_,
+to enable you to design Qt Widgets applications with a *drag-and-drop*
+approach.
+
+.. image:: pyside6-designer_screenshot.webp
+    :width: 100%
+    :alt: PySide6 Designer Screenshot
+
+Usage
+-----
+
+With ``pyside6-designer`` you can design your application in a simple way,
+to later save the end result in a ``.ui`` file. When you start the tool, you
+will see a dialog to select the base window: a QWidget, a QMainWindow, etc.
+
+.. image:: pyside6-designer_base_screenshot.webp
+    :width: 50%
+    :alt: PySide6 Designer Initial Screenshot
+
+Once you select one of those options, you can start placing widgets
+into the interface, and have access to the whole structure, properties,
+and more.
+
+.. image:: pyside6-designer_sections_screenshot.webp
+    :width: 100%
+    :alt: PySide6 Designer Initial Screenshot
+
+A simple distinction of the areas you might use is described in the
+previous screenshot. In the section **1** you will find all the elements
+you can use in your application, which is the area **2**.
+The application designs follows a hierarchical configuration,
+in **3** you can see the structure of the example which contains
+only a ``QMainWindow`` and a ``QPushButton``. Lastly
+you can access and modify the properties of the item in **4**,
+where you could adjust dimensions, names, etc.
+
+
+When your application is finished, you will save your design in a ``.ui``
+file. This ``.ui`` file can later be converted into a Python file,
+with the help of the :ref:`pyside6-uic` tool. You can find
+more details of this process in: :ref:`using_ui_files`.
+
+If you are interested in more functionality of the tool, you can check
+the official `Qt Widgets Designer Manual`_.
+
+
+Custom Widgets
+--------------
+
+One of the features that the `Qt Widgets Designer`_ provides is the possibility
+of loading custom widgets, in order to facilitate the development with ad-hoc
+widgets.
+
+On the following screenshot, you can see a new component on the left column
+that is already added on the main widget, a tic-tac-toe custom widget.
+
+.. image:: pyside6-designer_customwidgets_screenshot.webp
+    :width: 100%
+    :alt: PySide6 Designer Custom Widgets Screenshot
+
+To achieve this, you need to register a custom widget by setting the environment
+variable ``PYSIDE_DESIGNER_PLUGINS`` to the directory where your register file
+is located. The registration file for the tic-tac-toe widget looks like this:
+
+.. code-block:: Python
+
+    from tictactoe import TicTacToe
+    from tictactoeplugin import TicTacToePlugin
+
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+
+    if __name__ == '__main__':
+        QPyDesignerCustomWidgetCollection.addCustomWidget(TicTacToePlugin())
+
+As you can see in the previous code, ``TicTacToe`` is the custom widget,
+imported from a different file, and the ``TicTacToePlugin`` is the interface
+layer for `Qt Widgets Designer`_ to recognize it.
+We provide a helper class, ``QPyDesignerCustomWidgetCollection``, to
+simplify the registration process.
+
+If you are interested in all the details of this specific case, you can
+check the :ref:`task-menu-extension-example`.
+
+.. _`Qt Widgets Designer`: https://doc.qt.io/qt-6/qtdesigner-manual.html
+.. _`Qt Widgets Designer Manual`: https://doc.qt.io/qt-6/qtdesigner-manual.html
diff --git a/sources/pyside6/doc/tools/pyside-genpyi.rst b/sources/pyside6/doc/tools/pyside-genpyi.rst
new file mode 100644
index 000000000..0240c5005
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-genpyi.rst
@@ -0,0 +1,52 @@
+.. _pyside6-genpyi:
+
+pyside6-genpyi
+==============
+
+`pyside6-genpyi` is a command line tool to generate Python stub files
+(.pyi) for PySide modules. Stub files define signatures of all classes,
+methods (including overloads), constants and enums of the PySide
+modules. Signatures also contain type hints. This helps PySide integrate
+with Python type checkers and IDEs. For example, if you use any function
+from the Qt API with PySide, your IDE's function lookup feature will
+show you the function signature and its parameters and return value
+including types.
+
+PySide6 already ships with stub files that were generated with
+`pyside6-genpyi`. However, if you want to generate new stub files for
+several (or all) modules, for example to toggle a few features, you can
+run `pyside6-genpyi` manually. If you want to generate stub files for
+your own custom module, refer to :ref:`shiboken6-genpyi`.
+
+
+Usage
+-----
+
+To generate stub files for a PySide module, run the following command:
+
+.. code-block:: bash
+
+    pyside6-genpyi <module_names> [OPTIONS]
+
+where `<module_names>` is a space-separated list of module names (the
+modules must be importable from the working directory) and where
+`[OPTIONS]` can be one of the following:
+
+* **--quiet**: Run the tool quietly without output to stdout.
+* **--outpath <output_dir>**: Specify the output directory for the
+  generated stub files. If not specified, the stub files are generated
+  in the location of the module binary.
+* **--sys-path <paths>**: Prepend the system path (`sys.path`) with a
+  space-separated list of strings `<paths>`. This is useful if the
+  module is not installed in a default lookup location.
+* **--feature <features>**: A space-separate list of optional PySide
+  features to enable (see :ref:`pysideapi2`). This option has no effect
+  when using PyPy. Currently, the following features are available:
+
+  * **snake_case**: All methods in the module are switched from
+    ``camelCase`` to ``snake_case``. A single upper case letter is
+    replaced by an underscore and the lower case letter.
+  * **true_property**: All getter and setter functions in the module
+    which are marked as a property in the Qt6 docs are replaced by Python
+    property objects. Properties are also listed as such in the according
+    QMetaObject of a class.
diff --git a/sources/pyside6/doc/tools/pyside-linguist.rst b/sources/pyside6/doc/tools/pyside-linguist.rst
new file mode 100644
index 000000000..e13124a8e
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-linguist.rst
@@ -0,0 +1,20 @@
+.. _pyside6-linguist:
+
+pyside6-linguist
+=================
+
+``pyside6-linguist`` is a tool that wraps `Qt Linguist`_, Qt's tool to
+translate user interfaces and manage application localizations. It
+supports Qt's own TS file format as well as the XML Localization
+Interchange File Format (XLIFF). There are no differences between the
+version bundled with PySide and the one from Qt.
+
+For more information on how to use this tool, read Qt's documentation
+here: `Qt Linguist`_. Read more about how to translate PySide
+applications here: :ref:`translations`.
+
+.. image:: pyside6-linguist_screenshot.webp
+    :width: 500
+    :alt: PySide6 Linguist Screenshot
+
+.. _`Qt Linguist`: https://doc.qt.io/qt-6/qtlinguist-index.html
diff --git a/sources/pyside6/doc/tools/pyside-lrelease.rst b/sources/pyside6/doc/tools/pyside-lrelease.rst
new file mode 100644
index 000000000..7c628f2aa
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-lrelease.rst
@@ -0,0 +1,25 @@
+.. _pyside6-lrelease:
+
+pyside6-lrelease
+================
+
+.. note:: This tool is automatically called by :ref:`pyside6-project`
+   so you don't need to call it manually. *Qt Creator* will take care
+   of this step as well while executing a project.
+
+``pyside6-lrelease`` is a command line tool wrapping `lrelease`_. It produces
+``.qm`` files out of ``.ts`` files. The ``.qm`` file format is a compact binary
+format that the localized application uses. It provides extremely fast lookup
+for translations (see :ref:`translations`).
+
+Usage
+-----
+
+To convert a ``.ts`` file of the :ref:`qt-linguist-example`
+into its binary representation, run:
+
+.. code-block:: bash
+
+    pyside6-lrelease example_de.ts -qm example_de.qm
+
+.. _`lrelease`: https://doc.qt.io/qt-6/linguist-lrelease.html
diff --git a/sources/pyside6/doc/tools/pyside-lupdate.rst b/sources/pyside6/doc/tools/pyside-lupdate.rst
new file mode 100644
index 000000000..1c0d73c15
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-lupdate.rst
@@ -0,0 +1,23 @@
+.. _pyside6-lupdate:
+
+pyside6-lupdate
+===============
+
+.. note:: This tool is automatically called by :ref:`pyside6-project`
+   so you don't need to call it manually.
+
+``pyside6-lupdate`` is a command line tool wrapping `lupdate`_. It finds
+translatable strings in Python, ``.ui``, and ``.qml`` files and generates or
+updates ``.ts`` files (see :ref:`translations`).
+
+Usage
+-----
+
+To create or update the ``.ts`` file of the :ref:`qt-linguist-example`,
+run:
+
+.. code-block:: bash
+
+    pyside6-lupdate main.py main.qml form.ui -ts example_de.ts
+
+.. _`lupdate`: https://doc.qt.io/qt-6/linguist-lupdate.html
diff --git a/sources/pyside6/doc/tools/pyside-metaobjectdump.rst b/sources/pyside6/doc/tools/pyside-metaobjectdump.rst
new file mode 100644
index 000000000..1522b7ad5
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-metaobjectdump.rst
@@ -0,0 +1,92 @@
+.. _pyside6-metaobjectdump:
+
+pyside6-metaobjectdump
+======================
+
+``pyside6-metaobjectdump`` is a command line tool. It scans Python source
+files and dumps out information on classes to be registered with QML in
+JSON-format. This serves as input for the :ref:`pyside6-qmltyperegistrar` tool.
+
+The tool is the equivalent of the `moc`_ tool in Qt / C++.
+
+It is automatically run by the :ref:`pyside6-project` tool
+when passing the ``qmllint`` argument instructing it to check
+the QML source files.
+
+Usage
+-----
+
+Classes to be registered with QML are indicated by QML decorators
+like :deco:`QmlElement`. Invoking:
+
+.. code-block:: bash
+
+    pyside6-metaobjectdump birthdayparty.py
+
+produces the JSON data on stdout:
+
+.. code-block:: json
+
+    [
+        {
+            "classes": [
+                {
+                    "className": "BirthdayParty",
+                    "qualifiedClassName": "BirthdayParty",
+                    "object": true,
+                    "superClasses": [
+                        {
+                            "access": "public",
+                            "name": "QObject"
+                        }
+                    ],
+                    "classInfos": [
+                        {
+                            "name": "QML.Element",
+                            "value": "auto"
+                        }
+                    ],
+                    "properties": [
+                        {
+                            "name": "host",
+                            "type": "Person",
+                            "index": 0,
+                            "read": "host",
+                            "notify": "host_changed",
+                            "write": "host"
+                        },
+                        {
+                            "name": "guests",
+                            "type": "QQmlListProperty<Person>",
+                            "index": 1
+                        }
+                    ],
+                    "signals": [
+                        {
+                            "access": "public",
+                            "name": "host_changed",
+                            "arguments": [],
+                            "returnType": "void"
+                        },
+                        {
+                            "access": "public",
+                            "name": "guests_changed",
+                            "arguments": [],
+                            "returnType": "void"
+                        }
+                    ]
+                }
+            ],
+            "outputRevision": 68,
+            "QML_IMPORT_NAME": "People",
+            "QML_IMPORT_MAJOR_VERSION": 1,
+            "QML_IMPORT_MINOR_VERSION": 0,
+            "QT_MODULES": [
+                "QtCore",
+                "QtQml"
+            ],
+            "inputFile": ".../examples/qml/tutorials/extending-qml-advanced/advanced1-Base-project/birthdayparty.py"
+        }
+    ]
+
+.. _`moc`: https://doc.qt.io/qt-6/moc.html
diff --git a/sources/pyside6/doc/tools/pyside-project.rst b/sources/pyside6/doc/tools/pyside-project.rst
new file mode 100644
index 000000000..0359e1b7d
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-project.rst
@@ -0,0 +1,64 @@
+.. _pyside6-project:
+
+pyside6-project
+===============
+
+`pyside6-project` is a command line tool for creating, building and deploying
+|project| applications. It operates on a project file which is also used by
+`Qt Creator`_.
+
+Project file format
+-------------------
+
+The project file format is a simple `JSON`_-based format with the suffix
+``.pyproject`` listing all files of the project excluding generated files
+(typically ``.py``, ``.qml``, ``.qrc``, ``.ts``, or ``.ui`` files):
+
+.. code-block:: json
+
+    {
+        "files": ["main.py"]
+    }
+
+
+Usage
+-----
+
+The tool has several subcommands. New projects can be created using
+the below commands, passing the project name (directory):
+
+*new-ui*
+    Creates a new QtWidgets project with a *Qt Widgets Designer*-based main
+    window.
+
+*new-widget*
+    Creates a new QtWidgets project with a main window.
+
+*new-quick*
+    Creates a new QtQuick project.
+
+The other commands take the project file as an argument.
+It is also possible to specify a directory containing the project file.
+
+*build*
+    Builds the project, generating the required build artifacts
+    (see :ref:`using_ui_files`, :ref:`using_qrc_files`).
+
+*run*
+    Builds the project and runs the main.
+
+*deploy*
+    Deploys the application (see see :ref:`pyside6-deploy`).
+
+*lupdate*
+    Updates translation (.ts) files (see :ref:`translations`).
+
+*clean*
+    Cleans the build artifacts.
+
+*qmllint*
+    Runs the ``qmllint`` tool, checking the QML files.
+
+
+.. _`Qt Creator`: https://www.qt.io/product/development-tools
+.. _`JSON`: https://www.json.org/
diff --git a/sources/pyside6/doc/tools/pyside-qml.rst b/sources/pyside6/doc/tools/pyside-qml.rst
new file mode 100644
index 000000000..0502dd94a
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-qml.rst
@@ -0,0 +1,84 @@
+.. _pyside6-qml:
+
+pyside6-qml
+===========
+
+``pyside6-qml``  mimics some capabilities of Qt's `qml <qml_runtime>`_ runtime utility by directly
+invoking QQmlEngine/QQuickView. It enables prototyping with QML/QtQuick without the need to write
+any Python code that loads the QML files either through `QQmlApplicationEngine <qqmlappengine>`_ or
+the `QQuickView <qquickview>`_ class. The tool also detects the QML classes implemented in Python
+and registers them with the QML type system.
+
+Usage
+-----
+
+Consider the example `Extending QML - Plugins Example <extending_qml_example>`_. This example does
+not have a Python file with a ``main`` function that initializes a QmlEngine to load the QML file
+``app.qml``. You can run the example by running
+
+.. code-block:: bash
+
+    pyside6-qml examples/qml/tutorials/extending-qml/chapter6-plugins/app.qml -I examples/qml/tutorials/extending-qml/chapter6-plugins/Charts
+
+The ``-I`` flag is used to point ``pyside6-qml`` to the folder containing Python files that
+implement QML classes.
+
+Command Line Options
+--------------------
+
+Here are all the command line options of ``pyside6-qml``:
+
+Arguments
+^^^^^^^^^
+
+* **file**: This option refers to the QML file to be loaded by ``pyside6-qml``. This option does not
+  have a name or a flag. Therefore, this option should be the first option supplied to
+  ``pyside6-qml``. For example,
+
+.. code-block:: bash
+
+    pyside6-qml /path/to/test.qml
+
+Options
+^^^^^^^
+
+* **--module-paths/-I**: Specify space-separated folder/file paths which point to the Python files
+  that implement QML classes. By default, the parent directory of the QML file supplied to
+  ``pyside6-qml`` is searched recursively for all Python files and they are imported. Otherwise,
+  only the paths given in module paths are searched.
+
+* **--verbose/-v**: Run ``pyside6-qml`` in verbose mode. When run in this mode, pyside6-qml prints
+  log messages during various stages of processing.
+
+Options that align with `QML <qml_runtime>`_ runtime utility
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+* **--app-typ/-a**: Specifies which application class to use. It takes one of the three values -
+  ``core, gui, widget``. The default value is *gui*.
+
+* **--config/-c**: Load the given built-in configuration. It takes one of two values - ``default,
+  resizeToItem``. This option is only relevant for a QtQuick application. If ``default`` is used,
+  the view resizes to the size of the root item in the QML. If ``resizeToItem`` is used, the view
+  automatically resizes the root item to the size of the view.
+
+* **--list-conf**: List the built-in configurations. ``pyside6-qml`` has two built-in configurations
+  - ``default`` and ``resizeToItem``. See the option ``--config`` for more information.
+
+* **--rhi/-r**: Specifies the backend for the Qt graphics abstraction (RHI). It takes one of the
+  four values - ``vulkan, metal, d3dll, gl``.
+
+* **--verbose/-v**: List the built-in configurations. ``pyside6-qml`` has two built-in
+  configurations - *default* and *resizeToItem*. See the option ``--config`` for more information.
+
+* **--gles**: Force use of GLES (AA_UseOpenGLES).
+
+* **--desktop**: Force use of desktop OpenGL (AA_UseDesktopOpenGL).
+
+* **--software**: Force use of software rendering(AA_UseSoftwareOpenGL).
+
+* **--disable-context-sharing**: Disable the use of a shared GL context for QtQuick Windows".
+
+.. _`qml_runtime`: https://doc.qt.io/qt-6/qtquick-qml-runtime.html
+.. _`qqmlappengine`: https://doc.qt.io/qt-6/qqmlapplicationengine.html
+.. _`qquickview`: https://doc.qt.io/qt-6/qquickview.html
+.. _`extending_qml_example`: https://doc.qt.io/qtforpython-6/examples/example_qml_tutorials_extending-qml_chapter6-plugins.html
diff --git a/sources/pyside6/doc/tools/pyside-qmlcachegen.rst b/sources/pyside6/doc/tools/pyside-qmlcachegen.rst
new file mode 100644
index 000000000..ecd8e6afd
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-qmlcachegen.rst
@@ -0,0 +1,25 @@
+.. _pyside6-qmlcachegen:
+
+pyside6-qmlcachegen
+===================
+
+``pyside6-qmlcachegen`` is a command line tool that wraps `qmlcachegen`_.
+This tool creates C++ code or `QML byte code` for ``.qml`` files. For
+Qt for Python, only `QML byte code` is relevant. The file suffix is
+``.qmlc`` and it works similar to compiled Python bytecode
+(``.pyc`` files).
+
+Usage
+-----
+
+The command line option ``--only-bytecode`` should be used to
+create `QML byte code`. For example:
+
+.. code-block:: bash
+
+    qmlcachegen --only-bytecode gallery.qml
+
+produces a file ``gallery.qmlc`` containing `QML byte code` which is
+automatically loaded by the QML engine.
+
+.. _`qmlcachegen`: https://doc.qt.io/qt-6/qtqml-tool-qmlcachegen.html
diff --git a/sources/pyside6/doc/tools/pyside-qmllint.rst b/sources/pyside6/doc/tools/pyside-qmllint.rst
new file mode 100644
index 000000000..54a72470e
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-qmllint.rst
@@ -0,0 +1,49 @@
+.. _pyside6-qmllint:
+
+pyside6-qmllint
+===============
+
+``pyside6-qmllint`` is a command line tool that wraps `qmllint`_. This tool
+verifies the syntatic validity of QML files and warns about some QML
+anti-patterns.
+
+It is automatically run by the :ref:`pyside6-project` tool
+when passing the ``qmllint`` argument instructing it to check
+the QML source files.
+
+Usage
+-----
+
+The tool should normally not be invoked manually since it requires
+a number of import paths and additional type information
+generated by :ref:`pyside6-qmltyperegistrar` to function.
+
+For example, for a ``.qml`` file like:
+
+.. code-block:: javascript
+
+    import QtQuick
+    import QtQuick.Controls
+
+    Item {
+        Text {
+            id: name
+            text: qsTr("Hello World")
+        }
+    }
+
+when running:
+
+.. code-block:: bash
+
+    pyside6-qmllint Main.qml
+
+it would warn about unused imports:
+
+.. code-block::
+
+    Info: Main.qml:2:1: Unused import [unused-imports]
+    import QtQuick.Controls
+    ^^^^^^
+
+.. _`qmllint`: https://doc.qt.io/qt-6/qtquick-tool-qmllint.html
diff --git a/sources/pyside6/doc/tools/pyside-qmltyperegistrar.rst b/sources/pyside6/doc/tools/pyside-qmltyperegistrar.rst
new file mode 100644
index 000000000..0e8d66bd5
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-qmltyperegistrar.rst
@@ -0,0 +1,17 @@
+.. _pyside6-qmltyperegistrar:
+
+pyside6-qmltyperegistrar
+========================
+
+``pyside6-qmltyperegistrar`` is a command line tool that wraps the
+``qmltyperegistrar`` tool of Qt.
+
+It takes the file produced by :ref:`pyside6-metaobjectdump`
+as input and generates C++ code to register C++ classes to QML
+and a ``.qmltypes`` file containing a JSON description of the
+classes. For Qt for Python, only the ``.qmltypes`` file
+is of interest as input for :ref:`pyside6-qmllint`.
+
+The tool is automatically run by the :ref:`pyside6-project` tool
+when passing the ``qmllint`` argument instructing it to check
+the QML source files.
diff --git a/sources/pyside6/doc/tools/pyside-rcc.rst b/sources/pyside6/doc/tools/pyside-rcc.rst
new file mode 100644
index 000000000..e5688485e
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-rcc.rst
@@ -0,0 +1,55 @@
+.. _pyside6-rcc:
+
+pyside6-rcc
+===========
+
+.. note:: This tool is automatically called by :ref:`pyside6-project`
+   so you don't need to call it manually. *Qt Creator* will take care
+   of this step as well while executing a project.
+
+
+``pyside6-rcc`` is a command line tool for converting ``.qrc`` files into ``.py``
+files, so they can be used within your Python code.
+
+The tool is a wrapper around the `rcc`_ tool, which was originally
+designed to generate C++ code, but it also has Python support.
+
+Even though the equivalent of ``pyside6-rcc`` is running ``rcc -g python``
+we strongly recommend you to rely on ``pyside6-rcc`` in order to avoid
+mismatches between versions for the generated code.
+
+Usage
+-----
+
+Once you have gathered your resources on a qrc file,
+you can transform your ``.qrc`` file with the following command:
+
+.. code-block:: bash
+
+    pyside6-rcc your_file.qrc -o rc_your_file.py
+
+It is important to use the ``-o`` option to generate the Python file with the
+conversion, otherwise you will receive all the output as stdout in your terminal.
+
+To enable the usage of those resources in your program, you need to import
+the file:
+
+.. code-block:: Python
+
+    import rc_your_file
+
+then you can use a specific resource, for example an image, with the prefix ``:/``,
+for example:
+
+.. code-block:: Python
+
+    pixmap = QPixmap(":/icons/image.png")
+
+
+For additional options, you can use ``pyside6-rcc -h`` in order to get
+more information about additional options.
+
+Visit the tutorial :ref:`using_qrc_files` for a hands-on example.
+
+.. _`rcc`: https://doc.qt.io/qt-6/rcc.html
+
diff --git a/sources/pyside6/doc/tools/pyside-uic.rst b/sources/pyside6/doc/tools/pyside-uic.rst
new file mode 100644
index 000000000..ba4e36b4e
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside-uic.rst
@@ -0,0 +1,59 @@
+.. _pyside6-uic:
+
+pyside6-uic
+===========
+
+.. note:: This tool is automatically called by :ref:`pyside6-project`
+   so you don't need to call it manually. *Qt Creator* will take care
+   of this step as well while executing a project.
+
+``pyside6-uic`` is a command line tool for converting ``.ui`` files into ``.py``
+files, with the objective of using application designs as Python classes.
+
+The tool is a wrapper around the `uic`_ tool, which was originally
+designed to generate C++ code, but it also has Python support.
+
+Even though the equivalent of ``pyside6-uic`` is running ``uic -g python``
+we strongly recommend you to rely on ``pyside6-uic`` in order to avoid
+mismatches between versions for the generated code.
+
+Usage
+-----
+
+Once you have designed your application with :ref:`pyside6-designer`,
+you can transform your ``.ui`` file with the following command:
+
+.. code-block:: bash
+
+    pyside6-uic your_file.ui -o ui_your_file.py
+
+It is important to use the ``-o`` option to generate the Python file with the
+conversion, otherwise you will receive all the output as stdout in your terminal.
+
+The structure of the generated Python file will be similar in all cases,
+and you will get one class called ``Ui_TheNameOfYourDesign(object)`` that
+is in charge of positioning all the elements like your design.
+
+To use this Python file, you should follow our tutorial in
+:ref:`using_ui_files`, but in summary, it is mainly importing the class
+from the generated file and setting it up in your code:
+
+.. code-block:: Python
+
+    self.ui = Ui_TheNameOfYourDesign()
+    self.ui.setupUi(self)
+
+For additional options, you can use ``pyside-uic -h`` in order to get
+more information related to relative imports, absolute imports, using resources,
+translations, etc.
+
+.. note:: Remember that you need to have a class corresponding to the base
+    form you selected in :ref:`pyside6-designer`, a ``QWidget``, or ``QDialog``,
+    or ``QMainWindow``, etc, in order for ``setupUi`` to work. Check
+    :ref:`using_ui_files` for more information.
+
+.. warning:: Do not modify the content of the generated Python file from your
+    ``.ui`` file, otherwise everything will be lost when you re-generate it.
+
+.. _`uic`: https://doc.qt.io/qt-6/uic.html
+
diff --git a/sources/pyside6/doc/tools/pyside6-assistant_screenshot.webp b/sources/pyside6/doc/tools/pyside6-assistant_screenshot.webp
new file mode 100644
index 000000000..7d898d8e6
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-assistant_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-balsam.rst b/sources/pyside6/doc/tools/pyside6-balsam.rst
new file mode 100644
index 000000000..c6677f6a3
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-balsam.rst
@@ -0,0 +1,59 @@
+.. _pyside6-balsam:
+
+pyside6-balsam
+==============
+
+``pyside6-qsb`` is a tool that wraps the `balsam <Balsam Asset Import Tool>`_
+tool provided with Qt Quick 3D. The Balsam tool is a command line application
+that is part of Qt Quick 3D's asset conditioning pipeline. The purpose is to
+take assets created in digital content creation tools like `Maya`_, `3ds Max`_
+or `Blender`_ and converts them into an efficient runtime format for use with Qt
+Quick 3D. It is not possible, nor does it make sense to reference the
+interchange formats directly in applications because a large amount of
+resources are needed to parse and condition the content of the asset before it
+is usable for real-time rendering. Instead, the interchange formats can be
+converted via the Balsam tool into QML Components and resources like geometry
+and textures.
+
+
+For more information on how to use this tool, read Qt's documentation
+here: `Balsam Asset Import Tool`_.
+
+Usage
+-----
+
+.. code-block:: bash
+
+    pyside6-balsam [options] sourceFileName
+
+To convert a 3D asset contained in the file ``testModel.fbx`` with
+``pyside6-balsam`` the following command would be used:
+
+.. code-block:: bash
+
+    pyside6-balsam testModel.fbx
+
+This would generate the following files:
+
+* meshes/testModel.mesh
+* TestModel.qml
+
+Which can then be used in a Qt Quick 3D project by using that QML Component:
+
+.. code-block:: xml
+
+    import QtQuick3D 1.0
+
+    Scene {
+        Model {
+            source: "TestModel.qml"
+        }
+    }
+
+For other modes of operation, refer to the `Balsam Asset Import Tool`_.
+
+.. _`Balsam Asset Import Tool`: https://doc.qt.io/qt-6/qtquick3d-tool-balsam.html
+.. _Maya: https://www.autodesk.com/products/maya/overview
+.. _3ds Max: https://www.autodesk.com/products/3ds-max/overview
+.. _Blender: https://www.blender.org/
+
diff --git a/sources/pyside6/doc/tools/pyside6-balsamui.rst b/sources/pyside6/doc/tools/pyside6-balsamui.rst
new file mode 100644
index 000000000..f34cb6045
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-balsamui.rst
@@ -0,0 +1,22 @@
+.. _pyside6-balsamui:
+
+pyside6-balsamui
+================
+
+``pyside6-balsamui`` is graphical user interface frontend to the command line
+tool :ref:`pyside6-balsam`. The purpose of the tool is to take assets created
+in digital content creation tools like `Maya`_, `3ds Max`_ or `Blender`_ and
+converts them into an efficient runtime format for use with Qt Quick 3D.
+
+For more information on the further capabilities of the tool, read Qt's
+documentation here: `Balsam Asset Import Tool`_.
+
+.. image:: pyside6-balsamui_screenshot.webp
+    :width: 500
+    :alt: pyside6-balsamui screenshot
+
+.. _`Balsam Asset Import Tool`: https://doc.qt.io/qt-6/qtquick3d-tool-balsam.html
+.. _Maya: https://www.autodesk.com/products/maya/overview
+.. _3ds Max: https://www.autodesk.com/products/3ds-max/overview
+.. _Blender: https://www.blender.org/
+
diff --git a/sources/pyside6/doc/tools/pyside6-balsamui_screenshot.webp b/sources/pyside6/doc/tools/pyside6-balsamui_screenshot.webp
new file mode 100644
index 000000000..5c194fdb6
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-balsamui_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-designer_base_screenshot.webp b/sources/pyside6/doc/tools/pyside6-designer_base_screenshot.webp
new file mode 100644
index 000000000..88ff77786
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-designer_base_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-designer_customwidgets_screenshot.webp b/sources/pyside6/doc/tools/pyside6-designer_customwidgets_screenshot.webp
new file mode 100644
index 000000000..c84436c1d
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-designer_customwidgets_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-designer_screenshot.webp b/sources/pyside6/doc/tools/pyside6-designer_screenshot.webp
new file mode 100644
index 000000000..27f03652b
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-designer_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-designer_sections_screenshot.webp b/sources/pyside6/doc/tools/pyside6-designer_sections_screenshot.webp
new file mode 100644
index 000000000..6ff025503
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-designer_sections_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-linguist_screenshot.webp b/sources/pyside6/doc/tools/pyside6-linguist_screenshot.webp
new file mode 100644
index 000000000..cd91007ba
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-linguist_screenshot.webp
diff --git a/sources/pyside6/doc/tools/pyside6-qmlimportscanner.rst b/sources/pyside6/doc/tools/pyside6-qmlimportscanner.rst
new file mode 100644
index 000000000..ba27414d7
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-qmlimportscanner.rst
@@ -0,0 +1,53 @@
+.. _pyside6-qmlimportscanner:
+
+pyside6-qmlimportscanner
+========================
+
+``pyside6-qmlimportscanner`` is a command line tool that wraps the
+``qmlimportscanner`` tool of Qt.
+
+
+The tool is automatically run by the :ref:`pyside6-project` tool
+when passing the ``qmllint`` argument instructing it to check
+the QML source files.
+
+Usage
+-----
+
+Invoking the tool in the directory of the :ref:`filesystemexplorer_example`
+example using:
+
+.. code-block:: bash
+
+    pyside6-qmlimportscanner -rootPath .
+
+produces:
+
+.. code-block:: json
+
+    [
+        {
+            "name": "QtQuick",
+            "type": "module"
+        },
+        {
+            "name": "QtQuick.Controls.Basic",
+            "type": "module"
+        },
+        {
+            "name": "QtQuick.Layouts",
+            "type": "module"
+        },
+        {
+            "name": "FileSystemModule",
+            "type": "module"
+        },
+        {
+            "name": "QtQuick.Controls",
+            "type": "module"
+        },
+        {
+            "name": "QtQuick.Effects",
+            "type": "module"
+        }
+    ]
diff --git a/sources/pyside6/doc/tools/pyside6-qsb.rst b/sources/pyside6/doc/tools/pyside6-qsb.rst
new file mode 100644
index 000000000..f6f1847d4
--- /dev/null
+++ b/sources/pyside6/doc/tools/pyside6-qsb.rst
@@ -0,0 +1,39 @@
+.. _pyside6-qsb:
+
+pyside6-qsb
+===========
+
+``pyside6-qsb`` is a tool that wraps the `qsb <QSB Manual>`_ tool. qsb is a
+command line tool provided by the `Qt Shader Tools`_ module. It integrates
+third-party libraries such as `glslang`_ and `SPIRV-Cross`_, optionally invokes
+external tools, such as ``fxc`` or ``spirv-opt``, and generates .qsb files.
+Additionally, it can be used to inspect the contents of a .qsb package.
+
+For more information on how to use this tool, read Qt's documentation
+here: `QSB Manual`_.
+
+Usage
+-----
+
+To create a qsb file from a shader file, e.g., ``shader.frag``, use the
+following command:
+
+.. code-block:: bash
+
+    pyside6-qsb -o shader.frag.qsb shader.frag
+
+To inspect the file produced, i.e., ``shader.frag.qsb``, use the following
+command:
+
+.. code-block:: bash
+
+    pyside6-qsb -d shader.frag.qsb
+
+This will print the reflection metadata (in JSON form) and the included shaders.
+
+For other modes of operation, refer to the `QSB Manual`_.
+
+.. _`glslang`: https://github.com/KhronosGroup/glslang
+.. _`spirv-cross`: https://github.com/KhronosGroup/SPIRV-Cross
+.. _`QSB Manual`: https://doc.qt.io/qt-6/qtshadertools-qsb.html
+.. _`Qt Shader Tools`: https://doc.qt.io/qt-6/qtshadertools-index.html
diff --git a/sources/pyside6/doc/tutorials/basictutorial/clickablebutton.rst b/sources/pyside6/doc/tutorials/basictutorial/clickablebutton.rst
index 2221858bc..c5464640b 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/clickablebutton.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/clickablebutton.rst
@@ -60,7 +60,8 @@ signal to the `say_hello()` function:
     button.clicked.connect(say_hello)
 
 Finally, we show the button and start the Qt main loop:
-::
+
+.. code-block:: python
 
     # Show the button
     button.show()
@@ -68,9 +69,8 @@ Finally, we show the button and start the Qt main loop:
     app.exec()
 
 Here is the complete code for this example:
-::
 
-    #!/usr/bin/python
+.. code-block:: python
 
     import sys
     from PySide6.QtWidgets import QApplication, QPushButton
diff --git a/sources/pyside6/doc/tutorials/basictutorial/dialog.rst b/sources/pyside6/doc/tutorials/basictutorial/dialog.rst
index bc06d6d9b..b7712672b 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/dialog.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/dialog.rst
@@ -3,8 +3,8 @@ Creating a Dialog Application
 
 This tutorial shows how to build a simple dialog with some
 basic widgets. The idea is to let users provide their name
-in a `QLineEdit`, and the dialog greets them on click of a
-`QPushButton`.
+in a ``QLineEdit``, and the dialog greets them on click of a
+``QPushButton``.
 
 Let us just start with a simple stub that creates and shows
 a dialog. This stub is updated during the course of this
@@ -31,24 +31,24 @@ tutorial, but you can use this stub as is if you need to:
         sys.exit(app.exec())
 
 The imports aren't new to you, the same for the creation of the
-`QApplication` and the execution of the Qt main loop.
+``QApplication`` and the execution of the Qt main loop.
 The only novelty here is the **class definition**.
 
 You can create any class that subclasses PySide6 widgets.
-In this case, we are subclassing `QDialog` to define a custom
+In this case, we are subclassing ``QDialog`` to define a custom
 dialog, which we name as **Form**. We have also implemented the
-`init()` method that calls the `QDialog`'s init method with the
-parent widget, if any. Also, the new `setWindowTitle()` method
-just sets the title of the dialog window. In `main()`, you can see
+``init()`` method that calls the ``QDialog``'s init method with the
+parent widget, if any. Also, the new ``setWindowTitle()`` method
+just sets the title of the dialog window. In ``main()``, you can see
 that we are creating a *Form object* and showing it to the world.
 
 Create the Widgets
 ------------------
 
-We are going to create two widgets: a `QLineEdit` where users can
-enter their name, and a `QPushButton` that prints the contents of
-the `QLineEdit`.
-So, let's add the following code to the `init()` method of our Form:
+We are going to create two widgets: a ``QLineEdit`` where users can
+enter their name, and a ``QPushButton`` that prints the contents of
+the ``QLineEdit``.
+So, let's add the following code to the ``init()`` method of our Form:
 ::
 
     # Create widgets
@@ -62,8 +62,8 @@ Create a layout to organize the Widgets
 ---------------------------------------
 
 Qt comes with layout-support that helps you organize the widgets
-in your application. In this case, let's use `QVBoxLayout` to lay out
-the widgets vertically. Add the following code to the `init()` method,
+in your application. In this case, let's use ``QVBoxLayout`` to lay out
+the widgets vertically. Add the following code to the ``init()`` method,
 after creating the widgets:
 ::
 
@@ -72,40 +72,41 @@ after creating the widgets:
     layout.addWidget(self.edit)
     layout.addWidget(self.button)
 
-So, we create the layout, add the widgets with `addWidget()`.
+So, we create the layout, add the widgets with ``addWidget()``.
 
 Create the function to greet and connect the Button
 ---------------------------------------------------
 
 Finally, we just have to add a function to our custom **Form**
 and *connect* our button to it. Our function will be a part of
-the Form, so you have to add it after the `init()` function:
+the Form, so you have to add it after the ``init()`` function:
 ::
 
     # Greets the user
     def greetings(self):
         print(f"Hello {self.edit.text()}")
 
-Our function just prints the contents of the `QLineEdit` to the
+Our function just prints the contents of the ``QLineEdit`` to the
 python console. We have access to the text by means of the
-`QLineEdit.text()` method.
+``QLineEdit.text()`` method.
 
 Now that we have everything, we just need to *connect* the
-`QPushButton` to the `Form.greetings()` method. To do so, add the
-following line to the `init()` method:
+``QPushButton`` to the ``Form.greetings()`` method. To do so, add the
+following line to the ``init()`` method:
 ::
 
     # Add button signal to greetings slot
     self.button.clicked.connect(self.greetings)
 
-Once executed, you can enter your name in the `QLineEdit` and watch
+Once executed, you can enter your name in the ``QLineEdit`` and watch
 the console for greetings.
 
 Complete code
 -------------
 
 Here is the complete code for this tutorial:
-::
+
+.. code-block:: python
 
     import sys
     from PySide6.QtWidgets import (QLineEdit, QPushButton, QApplication,
diff --git a/sources/pyside6/doc/tutorials/basictutorial/icons.zip b/sources/pyside6/doc/tutorials/basictutorial/icons.zip
new file mode 100644
index 000000000..e279e37b8
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/basictutorial/icons.zip
diff --git a/sources/pyside6/doc/tutorials/basictutorial/qrcfiles.rst b/sources/pyside6/doc/tutorials/basictutorial/qrcfiles.rst
index 477c5b738..858293beb 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/qrcfiles.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/qrcfiles.rst
@@ -1,7 +1,7 @@
 .. _using_qrc_files:
 
-Using `.qrc` Files (`pyside6-rcc`)
-**********************************
+Using ``.qrc`` Files (``pyside6-rcc``)
+**************************************
 
 The `Qt Resource System`_ is a mechanism for storing binary files
 in an application.
@@ -17,7 +17,7 @@ In this tutorial you will learn how to load custom images as button icons.
 For inspiration, we will try to adapt the multimedia player example
 from Qt.
 
-As you can see on the following image, the `QPushButton` that are used
+As you can see on the following image, the ``QPushButton`` that are used
 for the media actions (play, pause, stop, and so on) are using the
 default icons meant for such actions.
 
@@ -25,29 +25,27 @@ default icons meant for such actions.
    :alt: Multimedia Player Qt Example
 
 You could make the application more attractive by designing the icons,
-but in case you don't want to design them, `download the following set`_
-and use them.
+but in case you don't want to design them, you can download and use them.
+
+:download:`Download icons <icons.zip>`
 
 .. image:: icons.png
    :alt: New Multimedia icons
 
-You can find more information about the `rcc` command, and `.qrc` file
+You can find more information about the ``rcc`` command, and ``.qrc`` file
 format, and the resource system in general in the `Qt Resource System`_
 site.
 
-.. _`download the following set`: icons/
-
 
-The `.qrc` file
-================
+The ``.qrc`` file
+=================
 
-Before running any command, add information about the resources to a `.qrc`
+Before running any command, add information about the resources to a ``.qrc``
 file.
-In the following example, notice how the resources are listed in `icons.qrc`
+In the following example, notice how the resources are listed in ``icons.qrc``
 
 ::
 
-    </ui>
     <!DOCTYPE RCC><RCC version="1.0">
     <qresource>
         <file>icons/play.png</file>
@@ -62,15 +60,15 @@ In the following example, notice how the resources are listed in `icons.qrc`
 Generating a Python file
 =========================
 
-Now that the `icons.qrc` file is ready, use the `pyside6-rcc` tool to generate
+Now that the ``icons.qrc`` file is ready, use the ``pyside6-rcc`` tool to generate
 a Python class containing the binary information about the resources
 
 To do this, we need to run::
 
-    pyside6-rcc icons.rc -o rc_icons.py
+    pyside6-rcc icons.qrc -o rc_icons.py
 
-The `-o` option lets you specify the output filename,
-which is `rc_icons.py` in this case.
+The ``-o`` option lets you specify the output filename,
+which is ``rc_icons.py`` in this case.
 
 To use the generated file, add the following import at the top of your main Python file::
 
@@ -167,7 +165,7 @@ Now, the constructor of your class should look like this:
 Executing the example
 =====================
 
-Run the application by calling `python main.py` to checkout the new icon-set:
+Run the application by calling ``python main.py`` to checkout the new icon-set:
 
 .. image:: player-new.png
    :alt: New Multimedia Player Qt Example
diff --git a/sources/pyside6/doc/tutorials/basictutorial/signals_and_slots.rst b/sources/pyside6/doc/tutorials/basictutorial/signals_and_slots.rst
index d22075812..0bfd9e276 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/signals_and_slots.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/signals_and_slots.rst
@@ -43,101 +43,104 @@ a signal directly to another signal. (This will emit the second signal
 immediately whenever the first is emitted.)
 
 Qt's widgets have many predefined signals and slots. For example,
-`QAbstractButton` (base class of buttons in Qt) has a `clicked()`
-signal and `QLineEdit` (single line input field) has a slot named
-'clear()`. So, a text input field with a button to clear the text
-could be implemented by placing a `QToolButton` to the right of the
-`QLineEdit` and connecting its `clicked()` signal to the slot
-'clear()`. This is done using the `connect()` method of the signal:
+``QAbstractButton`` (base class of buttons in Qt) has a ``clicked()``
+signal and ``QLineEdit`` (single line input field) has a slot named
+``clear()``. So, a text input field with a button to clear the text
+could be implemented by placing a ``QToolButton`` to the right of the
+``QLineEdit`` and connecting its ``clicked()`` signal to the slot
+``clear()``. This is done using the ``connect()`` method of the signal:
 
-    .. code-block:: python
+.. code-block:: python
 
-        button = QToolButton()
-        line_edit = QLineEdit()
-        button.clicked.connect(line_edit.clear)
+    button = QToolButton()
+    line_edit = QLineEdit()
+    button.clicked.connect(line_edit.clear)
 
-`connect()` returns a `QMetaObject.Connection` object, which can be
-used  with the `disconnect()` method to sever the connection.
+``connect()`` returns a ``QMetaObject.Connection`` object, which can be
+used with the ``disconnect()`` method to sever the connection.
 
 Signals can also be connected to free functions:
 
-    .. code-block:: python
+.. code-block:: python
 
-        import sys
-        from PySide6.QtWidgets import QApplication, QPushButton
+    import sys
+    from PySide6.QtWidgets import QApplication, QPushButton
 
 
-        def function():
-            print("The 'function' has been called!")
+    def function():
+        print("The 'function' has been called!")
 
-        app = QApplication()
-        button = QPushButton("Call function")
-        button.clicked.connect(func)
-        button.show()
-        sys.exit(app.exec())
+    app = QApplication()
+    button = QPushButton("Call function")
+    button.clicked.connect(function)
+    button.show()
+    sys.exit(app.exec())
 
 Connections can be spelled out in code or, for widget forms,
 designed in the
 `Signal-Slot Editor <https://doc.qt.io/qt-6/designer-connection-mode.html>`_
-of Qt Designer.
+of *Qt Widgets Designer*.
 
 The Signal Class
 ----------------
 
 When writing classes in Python, signals are declared as class level
 variables of the class ``QtCore.Signal()``. A QWidget-based button
-that emits a `clicked()` signal could look as
+that emits a ``clicked()`` signal could look as
 follows:
 
-   .. code-block:: python
+.. code-block:: python
 
-       from PySide6.QtCore import Qt, Signal
-       from PySide6.QtWidgets import QWidget
+    from PySide6.QtCore import Qt, Signal
+    from PySide6.QtWidgets import QWidget
 
-       class Button(QWidget):
+    class Button(QWidget):
 
-           clicked = Signal(Qt.MouseButton)
+        clicked = Signal(Qt.MouseButton)
 
-           ...
+        ...
 
-           def mousePressEvent(self, event):
-               self.clicked.emit(event.button())
+        def mousePressEvent(self, event):
+            self.clicked.emit(event.button())
 
 The constructor of ``Signal`` takes a tuple or a list of Python types
 and C types:
 
-    .. code-block:: python
+.. code-block:: python
 
-        signal1 = Signal(int)  # Python types
-        signal2 = Signal(QUrl)  # Qt Types
-        signal3 = Signal(int, str, int)  # more than one type
-        signal4 = Signal((float,), (QDate,))  # optional types
+    signal1 = Signal(int)  # Python types
+    signal2 = Signal(QUrl)  # Qt Types
+    signal3 = Signal(int, str, int)  # more than one type
+    signal4 = Signal((float,), (QDate,))  # optional types
 
 In addition to that, it can receive also a named argument ``name`` that defines
 the signal name. If nothing is passed, the new signal will have the same name
 as the variable that it is being assigned to.
 
-    .. code-block:: python
+.. code-block:: python
 
-        # TODO
-        signal5 = Signal(int, name='rangeChanged')
-        # ...
-        rangeChanged.emit(...)
+    # TODO
+    signal5 = Signal(int, name='rangeChanged')
+    # ...
+    rangeChanged.emit(...)
 
 Another useful option of ``Signal`` is the arguments name,
 useful for QML applications to refer to the emitted values by name:
 
-    .. code-block:: python
+.. code-block:: python
 
-        sumResult = Signal(int, arguments=['sum'])
+    sumResult = Signal(int, arguments=['sum'])
 
-    .. code-block:: javascript
+.. code-block:: javascript
 
-        Connections {
-            target: ...
-            function onSumResult(sum) {
-                // do something with 'sum'
-            }
+    Connections {
+        target: ...
+        function onSumResult(sum) {
+            // do something with 'sum'
+        }
+
+
+.. _slot-decorator:
 
 The Slot Class
 --------------
@@ -146,11 +149,11 @@ Slots in QObject-derived classes should be indicated by the decorator
 ``@QtCore.Slot()``. Again, to define a signature just pass the types
 similar to the ``QtCore.Signal()`` class.
 
-    .. code-block:: python
+.. code-block:: python
 
-        @Slot(str)
-        def slot_function(self, s):
-            ...
+    @Slot(str)
+    def slot_function(self, s):
+        ...
 
 
 ``Slot()`` also accepts a ``name`` and a ``result`` keyword.
@@ -159,6 +162,19 @@ Python type. The ``name`` keyword behaves the same way as in ``Signal()``. If
 nothing is passed as name then the new slot will have the same name as the
 function that is being decorated.
 
+We recommend marking all methods used by signal connections with a
+``@QtCore.Slot()`` decorator. Not doing causes run-time overhead due to the
+method being added to the ``QMetaObject`` when creating the connection. This is
+particularly important for ``QObject`` classes registered with QML, where
+missing decorators can introduce bugs.
+
+Missing decorators can be diagnosed by setting activating warnings of the
+logging category ``qt.pyside.libpyside``; for example by setting the
+environment variable:
+
+.. code-block:: bash
+
+    export QT_LOGGING_RULES="qt.pyside.libpyside.warning=true"
 
 .. _overloading-signals-and-slots:
 
@@ -172,62 +188,76 @@ In Qt 6, signals have distinct names for different types.
 The following example uses two handlers for a Signal and a Slot to showcase
 the different functionality.
 
-    .. code-block:: python
+.. code-block:: python
 
-        import sys
-        from PySide6.QtWidgets import QApplication, QPushButton
-        from PySide6.QtCore import QObject, Signal, Slot
+    import sys
+    from PySide6.QtWidgets import QApplication, QPushButton
+    from PySide6.QtCore import QObject, Signal, Slot
 
 
-        class Communicate(QObject):
-            # create two new signals on the fly: one will handle
-            # int type, the other will handle strings
-            speak = Signal((int,), (str,))
+    class Communicate(QObject):
+        # create two new signals on the fly: one will handle
+        # int type, the other will handle strings
+        speak = Signal((int,), (str,))
 
-            def __init__(self, parent=None):
-                super().__init__(parent)
+        def __init__(self, parent=None):
+            super().__init__(parent)
 
-                self.speak[int].connect(self.say_something)
-                self.speak[str].connect(self.say_something)
+            self.speak[int].connect(self.say_something)
+            self.speak[str].connect(self.say_something)
 
-            # define a new slot that receives a C 'int' or a 'str'
-            # and has 'say_something' as its name
-            @Slot(int)
-            @Slot(str)
-            def say_something(self, arg):
-                if isinstance(arg, int):
-                    print("This is a number:", arg)
-                elif isinstance(arg, str):
-                    print("This is a string:", arg)
+        # define a new slot that receives a C 'int' or a 'str'
+        # and has 'say_something' as its name
+        @Slot(int)
+        @Slot(str)
+        def say_something(self, arg):
+            if isinstance(arg, int):
+                print("This is a number:", arg)
+            elif isinstance(arg, str):
+                print("This is a string:", arg)
+
+    if __name__ == "__main__":
+        app = QApplication(sys.argv)
+        someone = Communicate()
 
-        if __name__ == "__main__":
-            app = QApplication(sys.argv)
-            someone = Communicate()
+        # emit 'speak' signal with different arguments.
+        # we have to specify the str as int is the default
+        someone.speak.emit(10)
+        someone.speak[str].emit("Hello everybody!")
 
-            # emit 'speak' signal with different arguments.
-            # we have to specify the str as int is the default
-            someone.speak.emit(10)
-            someone.speak[str].emit("Hello everybody!")
 
+.. _signals-and-slots-strings:
 
 Specifying Signals and Slots by Method Signature Strings
 --------------------------------------------------------
 
 
 Signals and slots can also be specified as C++ method signature
-strings passed through the `SIGNAL()` and/or `SLOT()` functions:
+strings passed through the ``SIGNAL()`` and/or ``SLOT()`` functions:
+
+.. code-block:: python
+
+    from PySide6.QtCore import SIGNAL, SLOT
+
+    button.connect(SIGNAL("clicked(Qt::MouseButton)"),
+                   action_handler, SLOT("action1(Qt::MouseButton)"))
+
+This is not normally recommended; it is only needed
+for a few cases where signals are only accessible via ``QMetaObject``
+(``QAxObject``, ``QAxWidget``, ``QDBusInterface`` or ``QWizardPage::registerField()``):
 
-    .. code-block:: python
+.. code-block:: python
 
-        from PySide6.QtCore import SIGNAL, SLOT
+    wizard.registerField("text", line_edit, "text",
+                         SIGNAL("textChanged(QString)"))
 
-        button.connect(SIGNAL("clicked(Qt::MouseButton)"),
-                      action_handler, SLOT("action1(Qt::MouseButton)"))
+The signature strings can be found by querying ``QMetaMethod.methodSignature()``
+when introspecting ``QMetaObject``:
 
-This is not recommended for connecting signals, it is mostly
-used to specify signals for methods like `QWizardPage::registerField()`:
+.. code-block:: python
 
-    .. code-block:: python
+    mo = widget.metaObject()
+    for m in range(mo.methodOffset(), mo.methodCount()):
+        print(mo.method(m).methodSignature())
 
-        wizard.registerField("text", line_edit, "text",
-                             SIGNAL("textChanged(QString)"))
+Slots should be decorated using :ref:`@Slot <slot-decorator>`.
diff --git a/sources/pyside6/doc/tutorials/basictutorial/translations.rst b/sources/pyside6/doc/tutorials/basictutorial/translations.rst
index 31cd004a3..21c16cdcd 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/translations.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/translations.rst
@@ -9,10 +9,10 @@ Translating Applications
 Qt Linguist
 -----------
 
-`Qt Linguist <https://doc.qt.io/qt-6/qtlinguist-index.html>`_ and
+`Qt Linguist`_ and
 its related tools can be used to provide translations for applications.
 
-The ``examples/widgets/linguist`` example illustrates this. The example is
+The :ref:`qt-linguist-example` example illustrates this. The example is
 very simple, it has a menu and shows a list of programming languages with
 multiselection.
 
@@ -28,18 +28,18 @@ The linguist example has a number of messages enclosed in ``self.tr()``.
 The status bar message shown in response to a selection change uses
 a plural form depending on a count:
 
-    .. code-block:: python
+.. code-block:: python
 
-        count = len(self._list_widget.selectionModel().selectedRows())
-        message = self.tr("%n language(s) selected", "", count)
+    count = len(self._list_widget.selectionModel().selectedRows())
+    message = self.tr("%n language(s) selected", "", count)
 
 The translation workflow for the example is as follows:
 The translated messages are extracted using the ``lupdate`` tool,
 producing XML-based ``.ts`` files:
 
-    .. code-block:: bash
+.. code-block:: bash
 
-        pyside6-lupdate main.py -ts example_de.ts
+    pyside6-lupdate main.py -ts example_de.ts
 
 If ``example_de.ts`` already exists, it will be updated with the new
 messages added to the code in-between.
@@ -52,15 +52,29 @@ they should be passed to the ``pyside6-lupdate`` tool as well:
     pyside6-lupdate main.py main.qml form.ui -ts example_de.ts
 
 The source files generated by ``pyside6-uic`` from the form files
-should `not` be passed.
+should **not** be passed.
+
+The ``lupdate`` mode of ``pyside6-project`` can also be used for this. It
+collects all source files and runs ``pyside6-lupdate`` when ``.ts`` file(s)
+are given in the ``.pyproject`` file:
+
+.. code-block:: bash
+
+    pyside6-project lupdate .
 
 ``.ts`` files are translated using *Qt Linguist*. Once this is complete,
 the files are converted to a binary form (``.qm`` files):
 
-    .. code-block:: bash
+.. code-block:: bash
+
+    pyside6-lrelease example_de.ts -qm example_de.qm
+
+``pyside6-project`` will build the ``.qm`` file automatically when
+``.ts`` file(s) are given in the ``.pyproject`` file:
 
-        mkdir translations
-        pyside6-lrelease example_de.ts -qm translations/example_de.qm
+.. code-block:: bash
+
+    pyside6-project build .
 
 To avoid having to ship the ``.qm`` files, it is recommend
 to put them into a Qt resource file along with icons and other
@@ -68,43 +82,45 @@ applications resources (see :ref:`using_qrc_files`).
 The resource file ``linguist.qrc`` provides the ``example_de.qm``
 under ``:/translations``:
 
-    .. code-block:: xml
+.. code-block:: xml
 
-        <!DOCTYPE RCC><RCC version="1.0">
-        <qresource>
-            <file>translations/example_de.qm</file>
-        </qresource>
-        </RCC>
+    <!DOCTYPE RCC><RCC version="1.0">
+    <qresource prefix="translations">
+        <file>example_de.qm</file>
+    </qresource>
+    </RCC>
 
 At runtime, the translations need to be loaded using the ``QTranslator`` class:
 
-    .. code-block:: python
+.. code-block:: python
 
-        path = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
-        translator = QTranslator(app)
-        if translator.load(QLocale.system(), 'qtbase', '_', path):
-            app.installTranslator(translator)
-        translator = QTranslator(app)
-        path = ':/translations'
-        if translator.load(QLocale.system(), 'example', '_', path):
-            app.installTranslator(translator)
+    path = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
+    translator = QTranslator(app)
+    if translator.load(QLocale.system(), 'qtbase', '_', path):
+        app.installTranslator(translator)
+    translator = QTranslator(app)
+    path = ':/translations'
+    if translator.load(QLocale.system(), 'example', '_', path):
+        app.installTranslator(translator)
 
 The code first loads the translations shipped for Qt and then
 the translations of the applications loaded from resources.
 
 The example can then be run in German:
 
-    .. code-block:: bash
+.. code-block:: bash
+
+    LANG=de python main.py
 
-        LANG=de python main.py
+.. _Qt Linguist: https://doc.qt.io/qt-6/qtlinguist-index.html
 
 GNU gettext
 -----------
 
-The `GNU gettext <https://docs.python.org/3/library/gettext.html>`_ module
+The `GNU gettext`_ module
 can be used to provide translations for applications.
 
-The ``examples/widgets/gettext`` example illustrates this. The example is
+The :ref:`gettext-example` example illustrates this. The example is
 very simple, it has a menu and shows a list of programming languages with
 multiselection.
 
@@ -116,29 +132,29 @@ aliased to ``ngettext``.
 
 Those functions are defined at the top:
 
-    .. code-block:: python
+.. code-block:: python
 
-        import gettext
-        ...
-        _ = None
-        ngettext = None
+    import gettext
+    # ...
+    _ = None
+    ngettext = None
 
 and later assigned as follows:
 
-    .. code-block:: python
-
-        src_dir = Path(__file__).resolve().parent
-        try:
-            translation = gettext.translation('example', localedir=src_dir / 'locales')
-            if translation:
-                translation.install()
-                _ = translation.gettext
-                ngettext = translation.ngettext
-        except FileNotFoundError:
-            pass
-        if not _:
-            _ = gettext.gettext
-            ngettext = gettext.ngettext
+.. code-block:: python
+
+    src_dir = Path(__file__).resolve().parent
+    try:
+        translation = gettext.translation('example', localedir=src_dir / 'locales')
+        if translation:
+            translation.install()
+            _ = translation.gettext
+            ngettext = translation.ngettext
+    except FileNotFoundError:
+        pass
+    if not _:
+        _ = gettext.gettext
+        ngettext = gettext.ngettext
 
 This specifies that our translation file has the base name ``example`` and
 will be found in the source tree under ``locales``. The code will try
@@ -146,18 +162,18 @@ to load a translation matching the current language.
 
 Messages to be translated look like:
 
-    .. code-block:: python
+.. code-block:: python
 
-        file_menu = self.menuBar().addMenu(_("&File"))
+    file_menu = self.menuBar().addMenu(_("&File"))
 
 The status bar message shown in response to a selection change uses
 a plural form depending on a count:
 
-    .. code-block:: python
+.. code-block:: python
 
-        count = len(self._list_widget.selectionModel().selectedRows())
-        message = ngettext("{0} language selected",
-                           "{0} languages selected", count).format(count)
+    count = len(self._list_widget.selectionModel().selectedRows())
+    message = ngettext("{0} language selected",
+                       "{0} languages selected", count).format(count)
 
 The ``ngettext()`` function takes the singular form, plural form and the count.
 The returned string still contains the formatting placeholder, so it needs
@@ -172,43 +188,45 @@ is first created:
     xgettext -L Python -o locales/example.pot main.py
 
 This file has a few generic placeholders which can be replaced by the
-appropriate values.  It is then copied to the ``de_DE/LC_MESSAGES`` directory.
+appropriate values. It is then copied to the ``de_DE/LC_MESSAGES`` directory.
 
-    .. code-block:: bash
+.. code-block:: bash
 
-        cd locales/de_DE/LC_MESSAGES/
-        cp ../../example.pot .
+    cd locales/de_DE/LC_MESSAGES/
+    cp ../../example.pot .
 
 Further adaptions need to be made to account for the German plural
 form and encoding:
 
-    .. code-block::
+.. code-block::
 
-        "Project-Id-Version: PySide6 gettext example\n"
-        "POT-Creation-Date: 2021-07-05 14:16+0200\n"
-        "Language: de_DE\n"
-        "MIME-Version: 1.0\n"
-        "Content-Type: text/plain; charset=UTF-8\n"
-        "Content-Transfer-Encoding: 8bit\n"
-        "Plural-Forms: nplurals=2; plural=n != 1;\n"
+    "Project-Id-Version: PySide6 gettext example\n"
+    "POT-Creation-Date: 2021-07-05 14:16+0200\n"
+    "Language: de_DE\n"
+    "MIME-Version: 1.0\n"
+    "Content-Type: text/plain; charset=UTF-8\n"
+    "Content-Transfer-Encoding: 8bit\n"
+    "Plural-Forms: nplurals=2; plural=n != 1;\n"
 
 Below, the translated messages can be given:
 
-    .. code-block::
+.. code-block::
 
-        #: main.py:57
-        msgid "&File"
-        msgstr "&Datei"
+    #: main.py:57
+    msgid "&File"
+    msgstr "&Datei"
 
 Finally, the ``.pot`` is converted to its binary form (machine object file,
 ``.mo``), which needs to be deployed:
 
-    .. code-block:: bash
+.. code-block:: bash
 
-        msgfmt -o example.mo example.pot
+    msgfmt -o example.mo example.pot
 
 The example can then be run in German:
 
-    .. code-block:: bash
+.. code-block:: bash
+
+    LANG=de python main.py
 
-        LANG=de python main.py
+.. _GNU gettext: https://docs.python.org/3/library/gettext.html
diff --git a/sources/pyside6/doc/tutorials/basictutorial/treewidget.rst b/sources/pyside6/doc/tutorials/basictutorial/treewidget.rst
index b286de507..f431cb5c4 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/treewidget.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/treewidget.rst
@@ -11,14 +11,14 @@ information in trees. You can also create a data model and display it using a
    further on. To know more about the Model/View architecture in Qt, refer to
    its `official documentation <https://doc.qt.io/qt-6/model-view-programming.html>`_.
 
-1. Import ``QTreeWidget`` and ``QTreeWidgetItem`` for this application:
+#. Import ``QTreeWidget`` and ``QTreeWidgetItem`` for this application:
 
    .. code-block:: python
 
        import sys
        from PySide6.QtWidgets import QApplication, QTreeWidget, QTreeWidgetItem
 
-2. Define a dictionary with project structures to display the information as a
+#. Define a dictionary with project structures to display the information as a
    tree, with files belonging to each project:
 
    .. code-block:: python
@@ -27,13 +27,13 @@ information in trees. You can also create a data model and display it using a
                "Project B": ["file_b.csv", "photo.jpg"],
                "Project C": []}
 
-3. Initialize the ``QApplication`` singleton:
+#. Initialize the ``QApplication`` singleton:
 
    .. code-block:: python
 
        app = QApplication()
 
-4. Configure the ``QTreeWidget`` to have two columns, one for the item name,
+#. Configure the ``QTreeWidget`` to have two columns, one for the item name,
    and the other for item type information of the files in the project
    directories.
    You can set the column name with the ``setHeaderLabels`` as described below:
@@ -44,7 +44,7 @@ information in trees. You can also create a data model and display it using a
        tree.setColumnCount(2)
        tree.setHeaderLabels(["Name", "Type"])
 
-5. Iterate the data structure, create the ``QTreeWidgetItem`` elements, and add
+#. Iterate the data structure, create the ``QTreeWidgetItem`` elements, and add
    the corresponding children to each parent.
    We also extract the extension name for only the files and add them
    into the second column.
@@ -64,7 +64,7 @@ information in trees. You can also create a data model and display it using a
 
        tree.insertTopLevelItems(0, items)
 
-7. Show the tree and execute the ``QApplication``.
+#. Show the tree and execute the ``QApplication``.
 
    .. code-block:: python
 
diff --git a/sources/pyside6/doc/tutorials/basictutorial/uifiles.rst b/sources/pyside6/doc/tutorials/basictutorial/uifiles.rst
index cd1057c97..cb945908d 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/uifiles.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/uifiles.rst
@@ -1,27 +1,27 @@
 .. _using_ui_files:
 
-Using `.ui` files from Designer or QtCreator with `QUiLoader` and `pyside6-uic`
-*******************************************************************************
+Using ``.ui`` files from Designer or QtCreator with ``QUiLoader`` and ``pyside6-uic``
+*************************************************************************************
 
 This page describes the use of
-`Qt Designer <https://doc.qt.io/qt-6/qtdesigner-manual.html>`_ to create
+`Qt Widgets Designer <https://doc.qt.io/qt-6/qtdesigner-manual.html>`_ to create
 graphical interfaces based on Qt Widgets for your Qt for Python project.
-**Qt Designer** is a graphical UI design tool which is available as a
+*Qt Widgets Designer* is a graphical UI design tool which is available as a
 standalone binary (``pyside6-designer``) or embedded into the
-`Qt Creator IDE <https://doc.qt.io/qtcreator>`_. Its use within **Qt Creator**
+`Qt Creator IDE <https://doc.qt.io/qtcreator>`_. Its use within *Qt Creator*
 is described at
-`Using Qt Designer <https://doc.qt.io/qtcreator/creator-using-qt-designer.html>`_.
+`Using Qt Widgets Designer <https://doc.qt.io/qtcreator/creator-using-qt-designer.html>`_.
 
 .. image:: uifiles.png
    :alt: Designer and the equivalent code
 
-The designs are stored in `.ui` files, which is an XML-based format. It will
+The designs are stored in ``.ui`` files, which is an XML-based format. It will
 be converted to Python or C++ code populating a widget instance at project build
 time by the `pyside6-uic <https://doc.qt.io/qt-6/uic.html>`_ tool.
 
-To create a new Qt Design Form in **Qt Creator**, choose
-`File/New File Or Project` and "Main Window" for template. Save it as
-`mainwindow.ui`. Add a `QPushButton` to the center of the centralwidget.
+To create a new Qt Design Form in *Qt Creator*, choose
+``File/New File Or Project`` and "Main Window" for template. Save it as
+``mainwindow.ui``. Add a ``QPushButton`` to the center of the centralwidget.
 
 Your file ``mainwindow.ui`` should look something like this:
 
@@ -88,12 +88,12 @@ Option A: Generating a Python class
 ===================================
 
 The standard way to interact with a **UI file** is to generate a Python
-class from it. This is possible thanks to the `pyside6-uic` tool.
+class from it. This is possible thanks to the ``pyside6-uic`` tool.
 To use this tool, you need to run the following command on a console::
 
-    pyside6-uic mainwindow.ui > ui_mainwindow.py
+    pyside6-uic mainwindow.ui -o ui_mainwindow.py
 
-We redirect all the output of the command to a file called `ui_mainwindow.py`,
+We redirect all the output of the command to a file called ``ui_mainwindow.py``,
 which will be imported directly::
 
     from ui_mainwindow import Ui_MainWindow
@@ -136,7 +136,7 @@ file:
 
 .. note::
 
-  You must run `pyside6-uic` again every time you make changes
+  You must run ``pyside6-uic`` again every time you make changes
   to the **UI file**.
 
 Option B: Loading it directly
@@ -149,7 +149,7 @@ module:
 
     from PySide6.QtUiTools import QUiLoader
 
-The `QUiLoader` lets us load the **ui file** dynamically
+The ``QUiLoader`` lets us load the **ui file** dynamically
 and use it right away:
 
 .. code-block:: python
@@ -192,40 +192,41 @@ The complete code of this example looks like this:
 Then to execute it we just need to run the following on a
 command prompt:
 
-.. code-block:: python
+.. code-block:: bash
 
     python main.py
 
 .. note::
 
-    `QUiLoader` uses connect() calls taking the function signatures as string
+    ``QUiLoader`` uses ``connect()`` calls taking the function signatures as string
     arguments for signal/slot connections.
-    It is thus unable to handle Python types like `str` or `list` from
+    It is thus unable to handle Python types like ``str`` or ``list`` from
     custom widgets written in Python since these types are internally mapped
     to different C++ types.
 
 .. _designer_custom_widgets:
 
-Custom Widgets in Qt Designer
-=============================
+Custom Widgets in Qt Widgets Designer
+=====================================
 
-**Qt Designer** is able to use user-provided (custom) widgets. They are shown
-in the widget box and can be dragged onto the form just like Qt's widgets (see
-`Using Custom Widgets with Qt Designer <https://doc.qt.io/qt-6/designer-using-custom-widgets.html>`_
-). Normally, this requires implementing the widget as a plugin to Qt Designer
-written in  C++ implementing its
-`QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_ .
+*Qt Widgets Designer* is able to use user-provided (custom) widgets.
+They are shown in the widget box and can be dragged onto the form just like
+Qt's widgets (see
+`Using Custom Widgets with Qt Widgets Designer <https://doc.qt.io/qt-6/designer-using-custom-widgets.html>`_
+). Normally, this requires implementing the widget as a plugin to
+*Qt Widgets Designer* written in C++ implementing its
+`QDesignerCustomWidgetInterface`_ .
 
 Qt for Python provides a simple interface for this which is similar to
 :meth:`registerCustomWidget()<PySide6.QtUiTools.QUiLoader.registerCustomWidget>`.
 
 The widget needs to be provided as a Python module, as shown by
-the widgetbinding example (file ``wigglywidget.py``) or
-the taskmenuextension example (file ``tictactoe.py``).
+the :ref:`widgetbinding-example` (file ``wigglywidget.py``) or
+the :ref:`task-menu-extension-example` (file ``tictactoe.py``).
 
-Registering this with Qt Designer is done by providing
+Registering this with *Qt Widgets Designer* is done by providing
 a registration script named ``register*.py`` and pointing
-the  path-type environment variable ``PYSIDE_DESIGNER_PLUGINS``
+the path-type environment variable ``PYSIDE_DESIGNER_PLUGINS``
 to the directory.
 
 The code of the registration script looks as follows:
@@ -262,20 +263,20 @@ The code of the registration script looks as follows:
 
 
 QPyDesignerCustomWidgetCollection provides an implementation of
-`QDesignerCustomWidgetCollectionInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetcollectioninterface.html>`_
-exposing custom widgets to **Qt Designer** with static convenience functions
-for registering types or adding instances of
-`QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_ .
+`QDesignerCustomWidgetCollectionInterface`_
+exposing custom widgets to *Qt Widgets Designer* with static convenience
+functions for registering types or adding instances of
+`QDesignerCustomWidgetInterface`_ .
 
 The function
 :meth:`registerCustomWidget()<PySide6.QtDesigner.QPyDesignerCustomWidgetCollection.registerCustomWidget>`
-is used to register a widget type with **Qt Designer**. In the simple case, it
-can be used like `QUiLoader.registerCustomWidget()`. It takes the custom widget
+is used to register a widget type with *Qt Widgets Designer*. In the simple case, it
+can be used like ``QUiLoader.registerCustomWidget()``. It takes the custom widget
 type and some optional keyword arguments passing values that correspond to the
 getters of
-`QDesignerCustomWidgetInterface <https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html>`_ :
+`QDesignerCustomWidgetInterface`_ :
 
-When launching **Qt Designer** via its launcher ``pyside6-designer``,
+When launching *Qt Widgets Designer* via its launcher ``pyside6-designer``,
 the custom widget should be visible in the widget box.
 
 For advanced usage, it is also possible to pass the function an implementation
@@ -286,15 +287,18 @@ is registered for the custom widget. The example is a port of the
 corresponding C++
 `Task Menu Extension Example <https://doc.qt.io/qt-6/qtdesigner-taskmenuextension-example.html>`_ .
 
-Troubleshooting the Qt Designer Plugin
-++++++++++++++++++++++++++++++++++++++
+.. _QDesignerCustomWidgetCollectionInterface: https://doc.qt.io/qt-6/qdesignercustomwidgetcollectioninterface.html
+.. _QDesignerCustomWidgetInterface: https://doc.qt.io/qt-6/qdesignercustomwidgetinterface.html
+
+Troubleshooting the Qt Widgets Designer Plugin
+++++++++++++++++++++++++++++++++++++++++++++++
 
 - The launcher ``pyside6-designer`` must be used. The standalone
-  **Qt Designer** will not load the plugin.
+  *Qt Widgets Designer* will not load the plugin.
 - The menu item **Help/About Plugin** brings up a dialog showing the plugins
   found and potential load error messages.
 - Check the console or Windows Debug view for further error messages.
 - Due to the buffering of output by Python, error messages may appear
-  only after **Qt Designer** has terminated.
+  only after *Qt Widgets Designer* has terminated.
 - When building Qt for Python, be sure to set the ``--standalone`` option
   for the plugin to be properly installed.
diff --git a/sources/pyside6/doc/tutorials/basictutorial/widgetstyling.rst b/sources/pyside6/doc/tutorials/basictutorial/widgetstyling.rst
index e1af8b8a9..2fa51c0a8 100644
--- a/sources/pyside6/doc/tutorials/basictutorial/widgetstyling.rst
+++ b/sources/pyside6/doc/tutorials/basictutorial/widgetstyling.rst
@@ -23,7 +23,7 @@ to each component. As an example, look at the following simple snippet:
         w.show()
         sys.exit(app.exec())
 
-When you execute this code, you will see a simple `QLabel` aligned at the
+When you execute this code, you will see a simple ``QLabel`` aligned at the
 center, and with a placeholder text.
 
 .. image:: widgetstyling-simple-no.png
@@ -32,8 +32,8 @@ center, and with a placeholder text.
 You can style your application using the CSS-like syntax.
 For more information, see `Qt Style Sheets Reference`_.
 
-A `QLabel` can be styled differently by setting some of its CSS
-properties, such as `background-color` and `font-family`,
+A ``QLabel`` can be styled differently by setting some of its CSS
+properties, such as ``background-color`` and ``font-family``,
 so let's see how does the code look like with these changes:
 
 .. code-block:: python
@@ -55,7 +55,7 @@ so let's see how does the code look like with these changes:
         w.show()
         sys.exit(app.exec())
 
-Now when you run the code, notice that the `QLabel` looks different with your
+Now when you run the code, notice that the ``QLabel`` looks different with your
 custom style:
 
 .. image:: widgetstyling-simple-yes.png
@@ -64,15 +64,15 @@ custom style:
 
 .. note::
 
-  If you don't have the font `Titillium` installed, you can try with any
+  If you don't have the font ``Titillium`` installed, you can try with any
   other you prefer.
-  Remember you can list your installed fonts using `QFontDatabase`,
-  specifically the `families()` method.
+  Remember you can list your installed fonts using ``QFontDatabase``,
+  specifically the ``families()`` method.
 
 
 Styling each UI element separately like you did in the previous snippet is a
 lot of work. The easier alternative for this is to use Qt Style Sheets,
-which is one or more `.qss` files defining the style for the UI elements in
+which is one or more ``.qss`` files defining the style for the UI elements in
 your application.
 
 More examples can be found in the `Qt Style Sheet Examples`_ documentation
@@ -94,7 +94,7 @@ Qt Style Sheets
   It's recommended to create a full new Qt style to cover all the possible
   corner cases.
 
-A `qss` file is quite similar to a CSS file, but you need to specify the Widget
+A ``qss`` file is quite similar to a CSS file, but you need to specify the Widget
 component and optionally the name of the object::
 
     QLabel {
@@ -105,8 +105,8 @@ component and optionally the name of the object::
         font-size: 20px;
     }
 
-The first style defines a `background-color` for all `QLabel` objects in your
-application, whereas the later one styles the `title` object only.
+The first style defines a ``background-color`` for all ``QLabel`` objects in your
+application, whereas the later one styles the ``title`` object only.
 
 .. note::
 
@@ -115,8 +115,8 @@ application, whereas the later one styles the `title` object only.
   `label.setObjectName("title")`
 
 
-Once you have a `qss` file for your application, you can apply it by reading
-the file and using the `QApplication.setStyleSheet(str)` function:
+Once you have a ``qss`` file for your application, you can apply it by reading
+the file and using the ``QApplication.setStyleSheet(str)`` function:
 
 .. code-block:: python
 
@@ -132,7 +132,7 @@ the file and using the `QApplication.setStyleSheet(str)` function:
 
         sys.exit(app.exec())
 
-Having a general `qss` file allows you to decouple the styling aspects of
+Having a general ``qss`` file allows you to decouple the styling aspects of
 the code, without mixing it in the middle of the general functionality, and you
 can simply enable it or disable it.
 
@@ -142,14 +142,14 @@ Look at this new example, with more widgets components:
    :linenos:
    :lines: 22-44
 
-This displays a two column widget, with a `QListWidget` on the left and a
-`QLabel` and a `QPushButton` on the right. It looks like this when you run the
+This displays a two column widget, with a ``QListWidget`` on the left and a
+``QLabel`` and a ``QPushButton`` on the right. It looks like this when you run the
 code:
 
 .. image:: widgetstyling-no.png
    :alt: Widget with no style
 
-If you add content to the previously described `style.qss` file, you can modify
+If you add content to the previously described ``style.qss`` file, you can modify
 the look-n-feel of the previous example:
 
 .. literalinclude:: style.qss
@@ -161,7 +161,7 @@ You can also use state-based styling on the QListWidget *items* for example, to
 style them differently depending on whether they are *selected* or not.
 
 After applying all the styling alternatives you explored in this topic, notice
-that the `QLabel` example looks a lot different now.
+that the ``QLabel`` example looks a lot different now.
 Try running the code to check its new look:
 
 .. image:: widgetstyling-yes.png
diff --git a/sources/pyside6/doc/tutorials/debugging/mixed_debugging.rst b/sources/pyside6/doc/tutorials/debugging/mixed_debugging.rst
index 1dff84ac4..85c326347 100644
--- a/sources/pyside6/doc/tutorials/debugging/mixed_debugging.rst
+++ b/sources/pyside6/doc/tutorials/debugging/mixed_debugging.rst
@@ -5,10 +5,10 @@ When debugging PySide code, very often you would also like to debug the
 corresponding C++ extension of the PySide module. This is done by attaching your
 debugger to the Python interpreter. In this tutorial, we are going to take you
 through a comprehensive guide in building Qt 6, using the built Qt 6 to build
-PySide6, and then starting a debugging process in either Qt Creator or VSCode.
+PySide6, and then starting a debugging process in either *Qt Creator* or VSCode.
 
 With VSCode, you should be able to see the combined call stacks for both C++ and
-Python together. With Qt Creator, unfortunately you would only be able to
+Python together. With *Qt Creator*, unfortunately you would only be able to
 debug the native C++ code of the PySide module; that is you won't be able to set
 breakpoints inside the Python code.
 
@@ -101,7 +101,7 @@ Build PySide6 using the Qt 6 that you built earlier
 ----------------------------------------------------
 
 Follow the steps mentioned `Getting Started - Qt for Python
-<https://doc.qt.io/qtforpython/gettingstarted.html>`_
+<https://doc.qt.io/qtforpython/gettingstarted/index.html>`_
 
 You may manually select the modules to install using the ``--module-subset`` cli
 argument for `setup.py`. This was my installation script
@@ -116,7 +116,7 @@ It is recommended to use a Python virtual environment rather than installing in
 Debugging the process using your preferred IDE
 ----------------------------------------------
 
-The following sections guide you through the setup for Qt Creator or VSCode.
+The following sections guide you through the setup for *Qt Creator* or VSCode.
 
 .. toctree::
    :glob:
diff --git a/sources/pyside6/doc/tutorials/debugging/qml_debugging.rst b/sources/pyside6/doc/tutorials/debugging/qml_debugging.rst
new file mode 100644
index 000000000..223e608fc
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/debugging/qml_debugging.rst
@@ -0,0 +1,32 @@
+Using Qt Creator's QML Debugger for a PySide6 QML Application
+*************************************************************
+
+Besides the C++ debugger, *Qt Creator* provides a `QML debugger`_ which lets you
+inspect JavaScript code. It works by connecting to a socket server run by the
+``QmlEngine`` instance. The port is passed on the command line. To enable it,
+add the below code to your QML application:
+
+.. code-block:: python
+
+        from argparse import ArgumentParser, RawTextHelpFormatter
+
+        ...
+
+        if __name__ == "__main__":
+            argument_parser = ArgumentParser(...)
+            argument_parser.add_argument("-qmljsdebugger", action="store",
+                                         help="Enable QML debugging")
+            options = argument_parser.parse_args()
+            if options.qmljsdebugger:
+                QQmlDebuggingEnabler.enableDebugging(True)
+            app = QApplication(sys.argv)
+
+
+For instructions on how to use the QML debugger, see
+`Debugging a Qt Quick Example Application`_.
+
+.. note:: The code should be removed or disabled when shipping the application
+          as it poses a security risk.
+
+.. _`QML debugger`: https://doc.qt.io/qtcreator/creator-debugging-qml.html
+.. _`Debugging a Qt Quick Example Application`: https://doc.qt.io/qtcreator/creator-qml-debugging-example.html
diff --git a/sources/pyside6/doc/tutorials/debugging/qtcreator/qtcreator.rst b/sources/pyside6/doc/tutorials/debugging/qtcreator/qtcreator.rst
index c8c9fb8ae..a78a67fad 100644
--- a/sources/pyside6/doc/tutorials/debugging/qtcreator/qtcreator.rst
+++ b/sources/pyside6/doc/tutorials/debugging/qtcreator/qtcreator.rst
@@ -1,9 +1,9 @@
 Debugging PySide with Qt Creator (Linux)
 ****************************************
 
-As opposed to VSCode, presently Qt Creator does not support mixed mode debugging.
+As opposed to VSCode, presently *Qt Creator* does not support mixed mode debugging.
 However, we can debug the C++ implementation of the corresponding Python PySide
-code. Unlike VSCode, Qt Creator provides a very easy interface to attach GDB to
+code. Unlike VSCode, *Qt Creator* provides a very easy interface to attach GDB to
 the Python interpreter. It saves you from doing all the extra configuration
 steps, that have to be done with VSCode.
 
@@ -14,26 +14,26 @@ Here are the steps:
 2. Go to Projects -> Run -> Run Configuration -> Add. This is going to open a
    new window shown below.
 
-    .. image:: custom_executable_create.png
-        :alt: creation of custom executable
-        :align: center
+   .. image:: custom_executable_create.png
+       :alt: creation of custom executable
+       :align: center
 
 3. Click on Custom Executable and `Create` a new configuration. Feed in the
-details like shown below.
+   details like shown below.
 
-    .. image:: custom_executable_run_config.png
-        :alt: run configuration of custom executable
-        :align: center
+   .. image:: custom_executable_run_config.png
+       :alt: run configuration of custom executable
+       :align: center
 
 4. Debug -> Start Debugging -> Start Debugging Without Deployment.
 
-    .. image:: start_debugging_without_deployment.png
-        :alt: start debugging without deployment
-        :align: center
+   .. image:: start_debugging_without_deployment.png
+       :alt: start debugging without deployment
+       :align: center
 
 You will now hit you breakpoint and can start debugging your code.
 
-    .. image:: breakpoint_cpp.png
-        :alt: breakpoint cpp
-        :align: center
+.. image:: breakpoint_cpp.png
+    :alt: breakpoint cpp
+    :align: center
 
diff --git a/sources/pyside6/doc/tutorials/debugging/vscode/vscode.rst b/sources/pyside6/doc/tutorials/debugging/vscode/vscode.rst
index bb91b5b99..b2a527b0e 100644
--- a/sources/pyside6/doc/tutorials/debugging/vscode/vscode.rst
+++ b/sources/pyside6/doc/tutorials/debugging/vscode/vscode.rst
@@ -9,6 +9,8 @@ in a single session. With VSCode you would be able to do the following:
 * Put breakpoints in both the Python and the C++ code.
 * Step from Python to C++ code and vice versa.
 
+For Windows, see :ref:`creating_windows_debug_builds`.
+
 Let's get started with setting up everything and debugging a Python process.
 
 Setting the Python interpreter
@@ -34,7 +36,7 @@ search for "Python: Select Interpreter".
 Creating Configurations in launch.json
 --------------------------------------
 
-Run -> Add Configuration -> Python -> Python File
+``Run -> Add Configuration -> Python -> Python File``
 
 This should create a launch.json file which looks like this:
 
@@ -143,7 +145,7 @@ Debug The Process
 
 1. Set a breakpoint in the Python code.
 
-2. Go to `Run And Debug` (Ctrl + Shift + D) and run the "Python: Current File"
+2. Go to ``Run And Debug`` (Ctrl + Shift + D) and run the "Python: Current File"
    by clicking the run symbol (green right-arrow). This will hit the breakpoint
    and will halt the Python debugger.
 
@@ -151,40 +153,40 @@ Debug The Process
    Current File" to "(gdb) Attach" or "(Windows) Attach". Your setup should now
    look like this.
 
-    .. image:: breakpoint_gdb.png
-        :alt: breakpoint before attach gdb
-        :align: center
+   .. image:: breakpoint_gdb.png
+       :alt: breakpoint before attach gdb
+       :align: center
 
 4. Run "(gdb) Attach" or "(Windows) Attach" and this should ask you for the
    processId of the Python process to which you want to attach the C++ debugger.
    VSCode also lets you search for the process by its name.
 
-    .. tip:: You can find the processId by running `ps aux | grep python`
+   .. tip:: You can find the processId by running ``ps aux | grep python``
 
-    .. image:: find_process_gdb.png
-        :alt: find process vscode
-        :align: center
+   .. image:: find_process_gdb.png
+       :alt: find process vscode
+       :align: center
 
 5. VSCode might now ask you for superuser permissions. In that case, type 'y'
    and enter your password.
 
-    .. code-block:: bash
+   .. code-block:: bash
 
-        Superuser access is required to attach to a process. Attaching as
-        superuser can potentially harm your computer. Do you want to continue?
-        [y/N]_
+       Superuser access is required to attach to a process. Attaching as
+       superuser can potentially harm your computer. Do you want to continue?
+       [y/N]_
 
 6. That is it. You should now be able to hit the breakpoints that you have set
    on the C++ counterparts.
 
-    .. figure:: audioformat_wrapper.png
-        :alt: Breakpoint set on the shiboken wrapper class
-        :align: left
+   .. figure:: audioformat_wrapper.png
+       :alt: Breakpoint set on the shiboken wrapper class
+       :align: left
 
-    Breakpoint set on the shiboken wrapper class
+   Breakpoint set on the shiboken wrapper class
 
-    .. figure:: audioformat_cpp.png
-        :alt: Breakpoint set on C++ implementation
-        :align: left
+   .. figure:: audioformat_cpp.png
+       :alt: Breakpoint set on C++ implementation
+       :align: left
 
-    Breakpoint set on C++ implementation
+   Breakpoint set on C++ implementation
diff --git a/sources/pyside6/doc/tutorials/expenses/expenses.rst b/sources/pyside6/doc/tutorials/expenses/expenses.rst
index c8ae5c034..2064488ae 100644
--- a/sources/pyside6/doc/tutorials/expenses/expenses.rst
+++ b/sources/pyside6/doc/tutorials/expenses/expenses.rst
@@ -20,9 +20,9 @@ The requirements:
    (`QPushButton <https://doc.qt.io/qtforpython/PySide6/QtWidgets/QPushButton.html>`_).
  * A verification step to avoid invalid data entry.
  * A chart to visualize the expense data
-   (`QChart <https://doc.qt.io/qtforpython/PySide6/QtCharts/QtCharts.QChart.html>`_) that will
+   (`QChart <https://doc.qt.io/qtforpython/PySide6/QtCharts/QChart.html>`_) that will
    be embedded in a chart view
-   (`QChartView <https://doc.qt.io/qtforpython/PySide6/QtCharts/QtCharts.QChartView.html>`_).
+   (`QChartView <https://doc.qt.io/qtforpython/PySide6/QtCharts/QChartView.html>`_).
 
 Empty window
 ------------
@@ -33,10 +33,10 @@ code block.
 .. code-block:: python
    :linenos:
 
-     if __name__ == "__main__":
-         app = QApplication([])
-         # ...
-         sys.exit(app.exec())
+    if __name__ == "__main__":
+        app = QApplication([])
+        # ...
+        sys.exit(app.exec())
 
 Now, to start the development, create an empty window called `MainWindow`.
 You could do that by defining a class that inherits from `QMainWindow`.
@@ -56,45 +56,18 @@ Now that our class is defined, create an instance of it and call `show()`.
 Menu bar
 --------
 
-Using a `QMainWindow` gives some features for free, among them a *menu bar*.  To use it, you need
+Using a `QMainWindow` gives some features for free, among them a *menu bar*. To use it, you need
 to call the method `menuBar()` and populate it inside the `MainWindow` class.
 
 .. literalinclude:: steps/02-expenses.py
    :linenos:
-   :lines: 9-21
-   :emphasize-lines: 6
+   :lines: 9-19
+   :emphasize-lines: 10
 
 Notice that the code snippet adds a *File* menu with the *Exit* option only.
 
-First signal/slot connection
-----------------------------
-
-The *Exit* option must be connected to a slot that triggers the application to exit. The main
-idea to achieve this, is the following:
-
-.. code-block:: python
-
-     element.signal_name.connect(slot_name)
-
-All the interface's elements could be connected through signals to certain slots,
-in the case of a `QAction`, the signal `triggered` can be used:
-
-.. code-block:: python
-
-     exit_action.triggered.connect(slot_name)
-
-.. note:: Now a *slot* needs to be defined to exit the application, which can be done using
-          `QApplication.quit()`.  If we put all these concepts together you will end up with the
-          following code:
-
-.. literalinclude:: steps/03-expenses.py
-   :linenos:
-   :lines: 19-28
-   :emphasize-lines: 4, 8-10
-
-Notice that the decorator `@Slot()` is required for each slot you declare to properly
-register them. Slots are normal functions, but the main difference is that they
-will be invokable from `Signals` of QObjects when connected.
+The *Exit* option must be connected to a slot that triggers the application to exit. We pass
+``QWidget.close()`` here. After the last window has been closed, the application exits.
 
 Empty widget and data
 ---------------------
@@ -107,13 +80,13 @@ Additionally, you will define example data to visualize later.
 
 .. literalinclude:: steps/04-expenses.py
    :linenos:
-   :lines: 9-16
+   :lines: 8-15
 
 With the `Widget` class in place, modify `MainWindow`'s initialization code
 
 .. literalinclude:: steps/04-expenses.py
    :linenos:
-   :lines: 43-47
+   :lines: 37-40
 
 Window layout
 -------------
@@ -121,7 +94,7 @@ Window layout
 Now that the main empty window is in place, you need to start adding widgets to achieve the main
 goal of creating an expenses application.
 
-After declaring the example data, you can visualize it on a simple `QTableWidget`.  To do so, you
+After declaring the example data, you can visualize it on a simple `QTableWidget`. To do so, you
 will add this procedure to the `Widget` constructor.
 
 .. warning:: Only for the example purpose a QTableWidget will be used,
@@ -130,7 +103,7 @@ will add this procedure to the `Widget` constructor.
 
 .. literalinclude:: steps/05-expenses.py
    :linenos:
-   :lines: 11-36
+   :lines: 11-31
 
 As you can see, the code also includes a `QHBoxLayout` that provides the container to place widgets
 horizontally.
@@ -143,7 +116,7 @@ displayed below.
 
 .. literalinclude:: steps/05-expenses.py
    :linenos:
-   :lines: 38-44
+   :lines: 33-39
 
 Having this process on a separate method is a good practice to leave the constructor more readable,
 and to split the main functions of the class in independent processes.
@@ -156,8 +129,8 @@ Because the data that is being used is just an example, you are required to incl
 input items to the table, and extra buttons to clear the table's content, and also quit the
 application.
 
-To distribute these input lines and buttons, you will use a `QVBoxLayout` that allows you to place
-elements vertically inside a layout.
+For input lines along with descriptive labels, you will use a `QFormLayout`. Then,
+you will nest the form layout into a `QVBoxLayout` along with the buttons.
 
 .. literalinclude:: steps/06-expenses.py
    :linenos:
@@ -169,7 +142,7 @@ example:
 
 .. literalinclude:: steps/06-expenses.py
    :linenos:
-   :lines: 5-10
+   :lines: 45-48
 
 The next step will be connecting those new buttons to slots.
 
@@ -183,17 +156,19 @@ documentation <https://doc.qt.io/qtforpython/PySide6/QtWidgets/QAbstractButton.h
 
 .. literalinclude:: steps/07-expenses.py
    :linenos:
-   :lines: 55-58
+   :lines: 50-52
 
 As you can see on the previous lines, we are connecting each *clicked* signal to different slots.
 In this example slots are normal class methods in charge of perform a determined task associated
-with our buttons. It is really important to decorate each method declaration with a `@Slot()`, in
-that way PySide6 knows internally how to register them into Qt.
+with our buttons. It is really important to decorate each method declaration with a `@Slot()`,
+that way, PySide6 knows internally how to register them into Qt and they
+will be invokable from `Signals` of QObjects when connected.
+
 
 .. literalinclude:: steps/07-expenses.py
    :linenos:
-   :lines: 63-92
-   :emphasize-lines: 2,16,28
+   :lines: 57-82
+   :emphasize-lines: 1, 23
 
 Since these slots are methods, we can access the class variables, like our `QTableWidget` to
 interact with it.
@@ -216,24 +191,21 @@ Verification step
 Adding information to the table needs to be a critical action that require a verification step
 to avoid adding invalid information, for example, empty information.
 
-You can use a signal from `QLineEdit` called *textChanged[str]* which will be emitted every
+You can use a signal from `QLineEdit` called *textChanged* which will be emitted every
 time something inside changes, i.e.: each key stroke.
-Notice that this time, there is a *[str]* section on the signal, this means that the signal
-will also emit the value of the text that was changed, which will be really useful to verify
-the current content of the `QLineEdit`.
 
 You can connect two different object's signal to the same slot, and this will be the case
 for your current application:
 
 .. literalinclude:: steps/08-expenses.py
    :linenos:
-   :lines: 62-63
+   :lines: 57-58
 
 The content of the *check_disable* slot will be really simple:
 
 .. literalinclude:: steps/08-expenses.py
    :linenos:
-   :lines: 82-87
+   :lines: 77-80
 
 You have two options, write a verification based on the current value
 of the string you retrieve, or manually get the whole content of both
@@ -255,15 +227,15 @@ side of your application.
 
 .. literalinclude:: steps/09-expenses.py
    :linenos:
-   :lines: 29-31
+   :lines: 30-32
 
 Additionally the order of how you include widgets to the right
 `QVBoxLayout` will also change.
 
 .. literalinclude:: steps/09-expenses.py
    :linenos:
-   :lines: 44-54
-   :emphasize-lines: 9
+   :lines: 46-54
+   :emphasize-lines: 8
 
 Notice that before we had a line with `self.right.addStretch()`
 to fill up the vertical space between the *Add* and the *Clear* buttons,
@@ -279,8 +251,8 @@ to a slot that creates a chart and includes it into your `QChartView`.
 
 .. literalinclude:: steps/10-expenses.py
    :linenos:
-   :lines: 66-72
-   :emphasize-lines: 6
+   :lines: 62-67
+   :emphasize-lines: 3
 
 That is nothing new, since you already did it for the other buttons,
 but now take a look at how to create a chart and include it into
@@ -288,7 +260,7 @@ your `QChartView`.
 
 .. literalinclude:: steps/10-expenses.py
    :linenos:
-   :lines: 102-114
+   :lines: 95-107
 
 The following steps show how to fill a `QPieSeries`:
 
diff --git a/sources/pyside6/doc/tutorials/expenses/main.py b/sources/pyside6/doc/tutorials/expenses/main.py
index 3c22eff34..a3a998470 100644
--- a/sources/pyside6/doc/tutorials/expenses/main.py
+++ b/sources/pyside6/doc/tutorials/expenses/main.py
@@ -3,16 +3,17 @@
 
 import sys
 from PySide6.QtCore import Qt, Slot
-from PySide6.QtGui import QAction, QPainter
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
+from PySide6.QtGui import QPainter
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow,
+                               QPushButton, QTableWidget, QTableWidgetItem,
                                QVBoxLayout, QWidget)
 from PySide6.QtCharts import QChartView, QPieSeries, QChart
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -32,43 +33,38 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
+
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
         self.plot = QPushButton("Plot")
 
         # Disabling 'Add' button
         self.add.setEnabled(False)
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addWidget(self.plot)
         self.right.addWidget(self.chart_view)
         self.right.addWidget(self.clear)
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Signals and Slots
         self.add.clicked.connect(self.add_element)
-        self.quit.clicked.connect(self.quit_application)
         self.plot.clicked.connect(self.plot_data)
         self.clear.clicked.connect(self.clear_table)
-        self.description.textChanged[str].connect(self.check_disable)
-        self.price.textChanged[str].connect(self.check_disable)
+        self.description.textChanged.connect(self.check_disable)
+        self.price.textChanged.connect(self.check_disable)
 
         # Fill example data
         self.fill_table()
@@ -76,32 +72,25 @@ class Widget(QWidget):
     @Slot()
     def add_element(self):
         des = self.description.text()
-        price = self.price.text()
-
-        try:
-            price_item = QTableWidgetItem(f"{float(price):.2f}")
-            price_item.setTextAlignment(Qt.AlignRight)
-
-            self.table.insertRow(self.items)
-            description_item = QTableWidgetItem(des)
+        price = float(self.price.text())
 
-            self.table.setItem(self.items, 0, description_item)
-            self.table.setItem(self.items, 1, price_item)
+        self.table.insertRow(self.items)
+        description_item = QTableWidgetItem(des)
+        price_item = QTableWidgetItem(f"{price:.2f}")
+        price_item.setTextAlignment(Qt.AlignRight)
 
-            self.description.setText("")
-            self.price.setText("")
+        self.table.setItem(self.items, 0, description_item)
+        self.table.setItem(self.items, 1, price_item)
 
-            self.items += 1
-        except ValueError:
-            print("Wrong price", price)
+        self.description.clear()
+        self.price.clear()
 
+        self.items += 1
 
     @Slot()
     def check_disable(self, s):
-        if not self.description.text() or not self.price.text():
-            self.add.setEnabled(False)
-        else:
-            self.add.setEnabled(True)
+        enabled = bool(self.description.text() and self.price.text())
+        self.add.setEnabled(enabled)
 
     @Slot()
     def plot_data(self):
@@ -117,10 +106,6 @@ class Widget(QWidget):
         chart.legend().setAlignment(Qt.AlignLeft)
         self.chart_view.setChart(chart)
 
-    @Slot()
-    def quit_application(self):
-        QApplication.quit()
-
     def fill_table(self, data=None):
         data = self._data if not data else data
         for desc, price in data.items():
@@ -140,7 +125,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -148,17 +133,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/main_snake_prop.py b/sources/pyside6/doc/tutorials/expenses/main_snake_prop.py
index 3f8f6f061..055544409 100644
--- a/sources/pyside6/doc/tutorials/expenses/main_snake_prop.py
+++ b/sources/pyside6/doc/tutorials/expenses/main_snake_prop.py
@@ -61,7 +61,7 @@ class Widget(QWidget):
 
         #self.table_view.setSizePolicy(size)
         self.layout.add_widget(self.table)
-        self.layout.add_layout(self.right)
+        self.layout.form_layout(self.right)
 
         # Set the layout to the QWidget
         self.set_layout(self.layout)
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/01-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/01-expenses.py
index 0db8c60e7..27f2aef65 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/01-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/01-expenses.py
@@ -7,7 +7,7 @@ from PySide6.QtWidgets import QApplication, QMainWindow
 
 class MainWindow(QMainWindow):
     def __init__(self):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
 if __name__ == "__main__":
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/02-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/02-expenses.py
index 142aff4c8..039b818df 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/02-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/02-expenses.py
@@ -2,13 +2,12 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 import sys
-from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QApplication, QMainWindow
 
 
 class MainWindow(QMainWindow):
     def __init__(self):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -16,11 +15,9 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
 
-        self.file_menu.addAction(exit_action)
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/03-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/03-expenses.py
index 7fd6f5014..039b818df 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/03-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/03-expenses.py
@@ -2,14 +2,12 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 import sys
-from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QApplication, QMainWindow
 
 
 class MainWindow(QMainWindow):
     def __init__(self):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -17,15 +15,8 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
-
-        self.file_menu.addAction(exit_action)
-
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
 
 
 if __name__ == "__main__":
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/04-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/04-expenses.py
index f907d31cf..6723690a8 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/04-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/04-expenses.py
@@ -2,14 +2,12 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 import sys
-from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QApplication, QMainWindow, QWidget
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
 
         # Example data
         self._data = {"Water": 24.5, "Electricity": 55.1, "Rent": 850.0,
@@ -19,7 +17,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -27,17 +25,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/05-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/05-expenses.py
index 753bc89d5..df0362fde 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/05-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/05-expenses.py
@@ -2,15 +2,14 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 import sys
-from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QMainWindow,
-                               QTableWidget, QTableWidgetItem, QWidget)
+from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout,
+                               QMainWindow, QTableWidget, QTableWidgetItem,
+                               QWidget)
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -25,14 +24,9 @@ class Widget(QWidget):
         self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Fill example data
         self.fill_table()
 
@@ -47,7 +41,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -55,17 +49,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/06-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/06-expenses.py
index e9abf6a28..d19a6220f 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/06-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/06-expenses.py
@@ -2,16 +2,15 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 import sys
-from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
-                               QVBoxLayout, QWidget)
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow, QPushButton,
+                               QTableWidget, QTableWidgetItem, QVBoxLayout,
+                               QWidget)
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -27,31 +26,27 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
+
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addStretch()
         self.right.addWidget(self.clear)
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Fill example data
         self.fill_table()
 
@@ -66,7 +61,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -74,17 +69,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/07-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/07-expenses.py
index 10b83f2f6..b1ed3fecc 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/07-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/07-expenses.py
@@ -3,15 +3,15 @@
 
 import sys
 from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
-                               QVBoxLayout, QWidget)
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow, QPushButton,
+                               QTableWidget, QTableWidgetItem, QVBoxLayout,
+                               QWidget)
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -27,33 +27,28 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
+
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addStretch()
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Signals and Slots
         self.add.clicked.connect(self.add_element)
-        self.quit.clicked.connect(self.quit_application)
         self.clear.clicked.connect(self.clear_table)
 
         # Fill example data
@@ -68,15 +63,11 @@ class Widget(QWidget):
         self.table.setItem(self.items, 0, QTableWidgetItem(des))
         self.table.setItem(self.items, 1, QTableWidgetItem(price))
 
-        self.description.setText("")
-        self.price.setText("")
+        self.description.clear()
+        self.price.clear()
 
         self.items += 1
 
-    @Slot()
-    def quit_application(self):
-        QApplication.quit()
-
     def fill_table(self, data=None):
         data = self._data if not data else data
         for desc, price in data.items():
@@ -93,7 +84,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -101,17 +92,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/08-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/08-expenses.py
index 1979bd6b8..0e7e21a32 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/08-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/08-expenses.py
@@ -3,15 +3,15 @@
 
 import sys
 from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
-                               QVBoxLayout, QWidget)
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow, QPushButton,
+                               QTableWidget, QTableWidgetItem, QVBoxLayout,
+                               QWidget)
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -27,40 +27,35 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
+
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
 
         # Disabling 'Add' button
         self.add.setEnabled(False)
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addStretch()
         self.right.addWidget(self.clear)
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Signals and Slots
         self.add.clicked.connect(self.add_element)
-        self.quit.clicked.connect(self.quit_application)
         self.clear.clicked.connect(self.clear_table)
-        self.description.textChanged[str].connect(self.check_disable)
-        self.price.textChanged[str].connect(self.check_disable)
+        self.description.textChanged.connect(self.check_disable)
+        self.price.textChanged.connect(self.check_disable)
 
         # Fill example data
         self.fill_table()
@@ -74,21 +69,15 @@ class Widget(QWidget):
         self.table.setItem(self.items, 0, QTableWidgetItem(des))
         self.table.setItem(self.items, 1, QTableWidgetItem(price))
 
-        self.description.setText("")
-        self.price.setText("")
+        self.description.clear()
+        self.price.clear()
 
         self.items += 1
 
     @Slot()
     def check_disable(self, s):
-        if not self.description.text() or not self.price.text():
-            self.add.setEnabled(False)
-        else:
-            self.add.setEnabled(True)
-
-    @Slot()
-    def quit_application(self):
-        QApplication.quit()
+        enabled = bool(self.description.text() and self.price.text())
+        self.add.setEnabled(enabled)
 
     def fill_table(self, data=None):
         data = self._data if not data else data
@@ -106,7 +95,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -114,17 +103,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/09-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/09-expenses.py
index d06f96135..279a46512 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/09-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/09-expenses.py
@@ -3,16 +3,17 @@
 
 import sys
 from PySide6.QtCore import Slot
-from PySide6.QtGui import QAction, QPainter
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
+from PySide6.QtGui import QPainter
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow,
+                               QPushButton, QTableWidget, QTableWidgetItem,
                                QVBoxLayout, QWidget)
 from PySide6.QtCharts import QChartView
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -32,42 +33,37 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
         self.plot = QPushButton("Plot")
 
         # Disabling 'Add' button
         self.add.setEnabled(False)
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addWidget(self.plot)
         self.right.addWidget(self.chart_view)
         self.right.addWidget(self.clear)
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
+        self.layout = QHBoxLayout(self)
 
-        #self.table_view.setSizePolicy(size)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Signals and Slots
         self.add.clicked.connect(self.add_element)
-        self.quit.clicked.connect(self.quit_application)
         self.clear.clicked.connect(self.clear_table)
-        self.description.textChanged[str].connect(self.check_disable)
-        self.price.textChanged[str].connect(self.check_disable)
+        self.description.textChanged.connect(self.check_disable)
+        self.price.textChanged.connect(self.check_disable)
 
         # Fill example data
         self.fill_table()
@@ -81,21 +77,15 @@ class Widget(QWidget):
         self.table.setItem(self.items, 0, QTableWidgetItem(des))
         self.table.setItem(self.items, 1, QTableWidgetItem(price))
 
-        self.description.setText("")
-        self.price.setText("")
+        self.description.clear()
+        self.price.clear()
 
         self.items += 1
 
     @Slot()
     def check_disable(self, s):
-        if not self.description.text() or not self.price.text():
-            self.add.setEnabled(False)
-        else:
-            self.add.setEnabled(True)
-
-    @Slot()
-    def quit_application(self):
-        QApplication.quit()
+        enabled = bool(self.description.text() and self.price.text())
+        self.add.setEnabled(enabled)
 
     def fill_table(self, data=None):
         data = self._data if not data else data
@@ -113,7 +103,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -121,17 +111,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/expenses/steps/10-expenses.py b/sources/pyside6/doc/tutorials/expenses/steps/10-expenses.py
index bbed5c389..a3a998470 100644
--- a/sources/pyside6/doc/tutorials/expenses/steps/10-expenses.py
+++ b/sources/pyside6/doc/tutorials/expenses/steps/10-expenses.py
@@ -3,16 +3,17 @@
 
 import sys
 from PySide6.QtCore import Qt, Slot
-from PySide6.QtGui import QAction, QPainter
-from PySide6.QtWidgets import (QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
-                               QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
+from PySide6.QtGui import QPainter
+from PySide6.QtWidgets import (QApplication, QFormLayout, QHeaderView,
+                               QHBoxLayout, QLineEdit, QMainWindow,
+                               QPushButton, QTableWidget, QTableWidgetItem,
                                QVBoxLayout, QWidget)
 from PySide6.QtCharts import QChartView, QPieSeries, QChart
 
 
 class Widget(QWidget):
     def __init__(self):
-        QWidget.__init__(self)
+        super().__init__()
         self.items = 0
 
         # Example data
@@ -32,43 +33,38 @@ class Widget(QWidget):
 
         # Right
         self.description = QLineEdit()
+        self.description.setClearButtonEnabled(True)
         self.price = QLineEdit()
+        self.price.setClearButtonEnabled(True)
+
         self.add = QPushButton("Add")
         self.clear = QPushButton("Clear")
-        self.quit = QPushButton("Quit")
         self.plot = QPushButton("Plot")
 
         # Disabling 'Add' button
         self.add.setEnabled(False)
 
+        form_layout = QFormLayout()
+        form_layout.addRow("Description", self.description)
+        form_layout.addRow("Price", self.price)
         self.right = QVBoxLayout()
-        self.right.addWidget(QLabel("Description"))
-        self.right.addWidget(self.description)
-        self.right.addWidget(QLabel("Price"))
-        self.right.addWidget(self.price)
+        self.right.addLayout(form_layout)
         self.right.addWidget(self.add)
         self.right.addWidget(self.plot)
         self.right.addWidget(self.chart_view)
         self.right.addWidget(self.clear)
-        self.right.addWidget(self.quit)
 
         # QWidget Layout
-        self.layout = QHBoxLayout()
-
-        #self.table_view.setSizePolicy(size)
+        self.layout = QHBoxLayout(self)
         self.layout.addWidget(self.table)
         self.layout.addLayout(self.right)
 
-        # Set the layout to the QWidget
-        self.setLayout(self.layout)
-
         # Signals and Slots
         self.add.clicked.connect(self.add_element)
-        self.quit.clicked.connect(self.quit_application)
         self.plot.clicked.connect(self.plot_data)
         self.clear.clicked.connect(self.clear_table)
-        self.description.textChanged[str].connect(self.check_disable)
-        self.price.textChanged[str].connect(self.check_disable)
+        self.description.textChanged.connect(self.check_disable)
+        self.price.textChanged.connect(self.check_disable)
 
         # Fill example data
         self.fill_table()
@@ -76,27 +72,25 @@ class Widget(QWidget):
     @Slot()
     def add_element(self):
         des = self.description.text()
-        price = self.price.text()
+        price = float(self.price.text())
 
         self.table.insertRow(self.items)
         description_item = QTableWidgetItem(des)
-        price_item = QTableWidgetItem(f"{float(price):.2f}")
+        price_item = QTableWidgetItem(f"{price:.2f}")
         price_item.setTextAlignment(Qt.AlignRight)
 
         self.table.setItem(self.items, 0, description_item)
         self.table.setItem(self.items, 1, price_item)
 
-        self.description.setText("")
-        self.price.setText("")
+        self.description.clear()
+        self.price.clear()
 
         self.items += 1
 
     @Slot()
     def check_disable(self, s):
-        if not self.description.text() or not self.price.text():
-            self.add.setEnabled(False)
-        else:
-            self.add.setEnabled(True)
+        enabled = bool(self.description.text() and self.price.text())
+        self.add.setEnabled(enabled)
 
     @Slot()
     def plot_data(self):
@@ -112,10 +106,6 @@ class Widget(QWidget):
         chart.legend().setAlignment(Qt.AlignLeft)
         self.chart_view.setChart(chart)
 
-    @Slot()
-    def quit_application(self):
-        QApplication.quit()
-
     def fill_table(self, data=None):
         data = self._data if not data else data
         for desc, price in data.items():
@@ -135,7 +125,7 @@ class Widget(QWidget):
 
 class MainWindow(QMainWindow):
     def __init__(self, widget):
-        QMainWindow.__init__(self)
+        super().__init__()
         self.setWindowTitle("Tutorial")
 
         # Menu
@@ -143,17 +133,11 @@ class MainWindow(QMainWindow):
         self.file_menu = self.menu.addMenu("File")
 
         # Exit QAction
-        exit_action = QAction("Exit", self)
+        exit_action = self.file_menu.addAction("Exit", self.close)
         exit_action.setShortcut("Ctrl+Q")
-        exit_action.triggered.connect(self.exit_app)
 
-        self.file_menu.addAction(exit_action)
         self.setCentralWidget(widget)
 
-    @Slot()
-    def exit_app(self, checked):
-        QApplication.quit()
-
 
 if __name__ == "__main__":
     # Qt Application
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/Main.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/Main.qml
new file mode 100644
index 000000000..faa9175d6
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/Main.qml
@@ -0,0 +1,196 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import FileSystemModule
+
+pragma ComponentBehavior: Bound
+
+ApplicationWindow {
+    id: root
+
+    property bool expandPath: false
+    property bool showLineNumbers: true
+    property string currentFilePath: ""
+
+    width: 1100
+    height: 600
+    minimumWidth: 200
+    minimumHeight: 100
+    visible: true
+    color: Colors.background
+    flags: Qt.Window | Qt.FramelessWindowHint
+    title: qsTr("File System Explorer Example")
+
+    function getInfoText() : string {
+        let out = root.currentFilePath
+        if (!out)
+            return qsTr("File System Explorer")
+        return root.expandPath ? out : out.substring(out.lastIndexOf("/") + 1, out.length)
+    }
+
+    menuBar: MyMenuBar {
+        dragWindow: root
+        infoText: root.getInfoText()
+        MyMenu {
+            title: qsTr("File")
+
+            Action {
+                text: qsTr("Increase Font")
+                shortcut: StandardKey.ZoomIn
+                onTriggered: editor.text.font.pixelSize += 1
+            }
+            Action {
+                text: qsTr("Decrease Font")
+                shortcut: StandardKey.ZoomOut
+                onTriggered: editor.text.font.pixelSize -= 1
+            }
+            Action {
+                text: root.showLineNumbers ? qsTr("Toggle Line Numbers OFF")
+                                           : qsTr("Toggle Line Numbers ON")
+                shortcut: "Ctrl+L"
+                onTriggered: root.showLineNumbers = !root.showLineNumbers
+            }
+            Action {
+                text: root.expandPath ? qsTr("Toggle Short Path")
+                                      : qsTr("Toggle Expand Path")
+                enabled: root.currentFilePath
+                onTriggered: root.expandPath = !root.expandPath
+            }
+            Action {
+                text: qsTr("Reset Filesystem")
+                enabled: sidebar.currentTabIndex === 1
+                onTriggered: fileSystemView.rootIndex = undefined
+            }
+            Action {
+                text: qsTr("Exit")
+                onTriggered: Qt.exit(0)
+                shortcut: StandardKey.Quit
+            }
+        }
+
+        MyMenu {
+            title: qsTr("Edit")
+
+            Action {
+                text: qsTr("Cut")
+                shortcut: StandardKey.Cut
+                enabled: editor.text.selectedText.length > 0
+                onTriggered: editor.text.cut()
+            }
+            Action {
+                text: qsTr("Copy")
+                shortcut: StandardKey.Copy
+                enabled: editor.text.selectedText.length > 0
+                onTriggered: editor.text.copy()
+            }
+            Action {
+                text: qsTr("Paste")
+                shortcut: StandardKey.Paste
+                enabled: editor.text.canPaste
+                onTriggered: editor.text.paste()
+            }
+            Action {
+                text: qsTr("Select All")
+                shortcut: StandardKey.SelectAll
+                enabled: editor.text.length > 0
+                onTriggered: editor.text.selectAll()
+            }
+            Action {
+                text: qsTr("Undo")
+                shortcut: StandardKey.Undo
+                enabled: editor.text.canUndo
+                onTriggered: editor.text.undo()
+            }
+        }
+    }
+    // Set up the layout of the main components in a row:
+    // [ Sidebar, Navigation, Editor ]
+    RowLayout {
+        anchors.fill: parent
+        spacing: 0
+
+        // Stores the buttons that navigate the application.
+        Sidebar {
+            id: sidebar
+            dragWindow: root
+            Layout.preferredWidth: 50
+            Layout.fillHeight: true
+        }
+
+        // Allows resizing parts of the UI.
+        SplitView {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            // Customized handle to drag between the Navigation and the Editor.
+            handle: Rectangle {
+                implicitWidth: 10
+                color: SplitHandle.pressed ? Colors.color2 : Colors.background
+                border.color: SplitHandle.hovered ? Colors.color2 : Colors.background
+                opacity: SplitHandle.hovered || navigationView.width < 15 ? 1.0 : 0.0
+
+                Behavior on opacity {
+                    OpacityAnimator {
+                        duration: 1400
+                    }
+                }
+            }
+
+            Rectangle {
+                id: navigationView
+                color: Colors.surface1
+                SplitView.preferredWidth: 250
+                SplitView.fillHeight: true
+                // The stack-layout provides different views, based on the
+                // selected buttons inside the sidebar.
+                StackLayout {
+                    anchors.fill: parent
+                    currentIndex: sidebar.currentTabIndex > 1 ? 1 : sidebar.currentTabIndex
+
+                    // Shows the help text.
+                    Text {
+                        text: qsTr("This example shows how to use and visualize the file system.\n\n"
+                                 + "Customized Qt Quick Components have been used to achieve this look.\n\n"
+                                 + "You can edit the files but they won't be changed on the file system.\n\n"
+                                 + "Click on the folder icon to the left to get started.")
+                        wrapMode: TextArea.Wrap
+                        color: Colors.text
+                    }
+
+                    // Shows the files on the file system.
+                    FileSystemView {
+                        id: fileSystemView
+                        color: Colors.surface1
+                        onFileClicked: path => root.currentFilePath = path
+                    }
+                }
+            }
+
+            // The main view that contains the editor or the scheme-manager.
+            StackLayout {
+                currentIndex: sidebar.currentTabIndex > 1 ? 1 : 0
+
+                SplitView.fillWidth: true
+                SplitView.fillHeight: true
+
+                Editor {
+                    id: editor
+                    showLineNumbers: root.showLineNumbers
+                    currentFilePath: root.currentFilePath
+                }
+
+                ColorScheme {
+                    Layout.fillWidth: true
+                    Layout.fillHeight: true
+                }
+
+            }
+        }
+    }
+
+    ResizeButton {
+        resizeWindow: root
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/app.qrc b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/app.qrc
new file mode 100644
index 000000000..ccd9eefec
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/app.qrc
@@ -0,0 +1,16 @@
+<RCC>
+    <qresource prefix="/qt/qml/FileSystemModule">
+        <file>qmldir</file>
+        <file>Main.qml</file>
+        <file>qml/About.qml</file>
+        <file>qml/Editor.qml</file>
+        <file>qml/Colors.qml</file>
+        <file>qml/FileSystemView.qml</file>
+        <file>qml/Icon.qml</file>
+        <file>qml/MyMenu.qml</file>
+        <file>qml/MyMenuBar.qml</file>
+        <file>qml/ResizeButton.qml</file>
+        <file>qml/Sidebar.qml</file>
+        <file>qml/WindowDragHandler.qml</file>
+    </qresource>
+</RCC>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons.qrc b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons.qrc
new file mode 100644
index 000000000..69bddc018
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons.qrc
@@ -0,0 +1,15 @@
+<RCC>
+    <qresource>
+        <file>icons/app_icon.svg</file>
+        <file>icons/folder_closed.svg</file>
+        <file>icons/folder_open.svg</file>
+        <file>icons/generic_file.svg</file>
+        <file>icons/globe.svg</file>
+        <file>icons/info_sign.svg</file>
+        <file>icons/leaf.svg</file>
+        <file>icons/light_bulb.svg</file>
+        <file>icons/qt_logo.svg</file>
+        <file>icons/read.svg</file>
+        <file>icons/resize.svg</file>
+    </qresource>
+</RCC>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/app_icon.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/app_icon.svg
new file mode 100644
index 000000000..5aae4221f
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/app_icon.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="800px" height="800px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path fill="#EBDBB2" d="M13.25 8.5a.75.75 0 1 1-.75-.75.75.75 0 0 1 .75.75zM9.911 21.35l.816.578C10.819 21.798 13 18.666 13 13h-1a15.503 15.503 0 0 1-2.089 8.35zM4 6.703V10a2.002 2.002 0 0 1-2 2v1a2.002 2.002 0 0 1 2 2v3.297A3.707 3.707 0 0 0 7.703 22H9v-1H7.703A2.706 2.706 0 0 1 5 18.297V15a2.999 2.999 0 0 0-1.344-2.5A2.999 2.999 0 0 0 5 10V6.703A2.706 2.706 0 0 1 7.703 4H9V3H7.703A3.707 3.707 0 0 0 4 6.703zM20 10V6.703A3.707 3.707 0 0 0 16.297 3H15v1h1.297A2.706 2.706 0 0 1 19 6.703V10a2.999 2.999 0 0 0 1.344 2.5A2.999 2.999 0 0 0 19 15v3.297A2.706 2.706 0 0 1 16.297 21H15v1h1.297A3.707 3.707 0 0 0 20 18.297V15a2.002 2.002 0 0 1 2-2v-1a2.002 2.002 0 0 1-2-2z"/><path fill="none" d="M0 0h24v24H0z"/></svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_closed.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_closed.svg
new file mode 100644
index 000000000..36f119c96
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_closed.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1792 1792"
+   id="svg51"
+   sodipodi:docname="folder_closed.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs55" />
+  <sodipodi:namedview
+     id="namedview53"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.45033482"
+     inkscape:cx="842.70632"
+     inkscape:cy="896"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg51" />
+  <path
+     fill="currentColor"
+     d="m 1718,672 v 704 q 0,92 -66,158 -66,66 -158,66 H 278 q -92,0 -158,-66 -66,-66 -66,-158 V 416 q 0,-92 66,-158 66,-66 158,-66 h 320 q 92,0 158,66 66,66 66,158 v 32 h 672 q 92,0 158,66 66,66 66,158 z"
+     id="path49" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_open.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_open.svg
new file mode 100644
index 000000000..daa55a7a1
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/folder_open.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1792 1792"
+   id="svg139"
+   sodipodi:docname="folder_open.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs143" />
+  <sodipodi:namedview
+     id="namedview141"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.24358259"
+     inkscape:cx="149.84651"
+     inkscape:cy="1098.1901"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg139" />
+  <path
+     fill="currentColor"
+     d="M 1590,1376 V 672 q 0,-40 -28,-68 -28,-28 -68,-28 H 790 q -40,0 -68,-28 -28,-28 -28,-68 v -64 q 0,-40 -28,-68 -28,-28 -68,-28 H 278 q -40,0 -68,28 -28,28 -28,68 v 960 q 0,40 28,68 28,28 68,28 h 1216 q 40,0 68,-28 28,-28 28,-68 z m 128,-704 v 704 q 0,92 -66,158 -66,66 -158,66 H 278 q -92,0 -158,-66 -66,-66 -66,-158 V 416 q 0,-92 66,-158 66,-66 158,-66 h 320 q 92,0 158,66 66,66 66,158 v 32 h 672 q 92,0 158,66 66,66 66,158 z"
+     id="path137" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/generic_file.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/generic_file.svg
new file mode 100644
index 000000000..9c855676e
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/generic_file.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1792 1792"
+   id="svg147"
+   sodipodi:docname="generic_file.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs151" />
+  <sodipodi:namedview
+     id="namedview149"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.12179129"
+     inkscape:cx="-578.85911"
+     inkscape:cy="1687.3127"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg147" />
+  <path
+     fill="currentColor"
+     d="m 1586,476 q 14,14 28,36 H 1142 V 40 q 22,14 36,28 z m -476,164 h 544 v 1056 q 0,40 -28,68 -28,28 -68,28 H 214 q -40,0 -68,-28 -28,-28 -28,-68 V 96 Q 118,56 146,28 174,0 214,0 h 800 v 544 q 0,40 28,68 28,28 68,28 z m 160,736 v -64 q 0,-14 -9,-23 -9,-9 -23,-9 H 534 q -14,0 -23,9 -9,9 -9,23 v 64 q 0,14 9,23 9,9 23,9 h 704 q 14,0 23,-9 9,-9 9,-23 z m 0,-256 v -64 q 0,-14 -9,-23 -9,-9 -23,-9 H 534 q -14,0 -23,9 -9,9 -9,23 v 64 q 0,14 9,23 9,9 23,9 h 704 q 14,0 23,-9 9,-9 9,-23 z m 0,-256 v -64 q 0,-14 -9,-23 -9,-9 -23,-9 H 534 q -14,0 -23,9 -9,9 -9,23 v 64 q 0,14 9,23 9,9 23,9 h 704 q 14,0 23,-9 9,-9 9,-23 z"
+     id="path145" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/globe.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/globe.svg
new file mode 100644
index 000000000..081433813
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/globe.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1792 1792"
+   id="svg155"
+   sodipodi:docname="globe.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs159" />
+  <sodipodi:namedview
+     id="namedview157"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.12179129"
+     inkscape:cx="504.9622"
+     inkscape:cy="1720.1558"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg155" />
+  <path
+     fill="currentColor"
+     d="m 886,128 q 209,0 385.5,103 176.5,103 279.5,279.5 103,176.5 103,385.5 0,209 -103,385.5 Q 1448,1458 1271.5,1561 1095,1664 886,1664 677,1664 500.5,1561 324,1458 221,1281.5 118,1105 118,896 118,687 221,510.5 324,334 500.5,231 677,128 886,128 Z m 274,521 q -2,1 -9.5,9.5 -7.5,8.5 -13.5,9.5 2,0 4.5,-5 2.5,-5 5,-11 2.5,-6 3.5,-7 6,-7 22,-15 14,-6 52,-12 34,-8 51,11 -2,-2 9.5,-13 11.5,-11 14.5,-12 3,-2 15,-4.5 12,-2.5 15,-7.5 l 2,-22 q -12,1 -17.5,-7 -5.5,-8 -6.5,-21 0,2 -6,8 0,-7 -4.5,-8 -4.5,-1 -11.5,1 -7,2 -9,1 -10,-3 -15,-7.5 -5,-4.5 -8,-16.5 -3,-12 -4,-15 -2,-5 -9.5,-10.5 -7.5,-5.5 -9.5,-10.5 -1,-2 -2.5,-5.5 -1.5,-3.5 -3,-6.5 -1.5,-3 -4,-5.5 -2.5,-2.5 -5.5,-2.5 -3,0 -7,5 -4,5 -7.5,10 -3.5,5 -4.5,5 -3,-2 -6,-1.5 -3,0.5 -4.5,1 -1.5,0.5 -4.5,3 -3,2.5 -5,3.5 -3,2 -8.5,3 -5.5,1 -8.5,2 15,-5 -1,-11 -10,-4 -16,-3 9,-4 7.5,-12 -1.5,-8 -8.5,-14 h 5 q -1,-4 -8.5,-8.5 -7.5,-4.5 -17.5,-8.5 -10,-4 -13,-6 -8,-5 -34,-9.5 -26,-4.5 -33,-0.5 -5,6 -4.5,10.5 0.5,4.5 4,14 3.5,9.5 3.5,12.5 1,6 -5.5,13 -6.5,7 -6.5,12 0,7 14,15.5 14,8.5 10,21.5 -3,8 -16,16 -13,8 -16,12 -5,8 -1.5,18.5 3.5,10.5 10.5,16.5 2,2 1.5,4 -0.5,2 -3.5,4.5 -3,2.5 -5.5,4 -2.5,1.5 -6.5,3.5 l -3,2 q -11,5 -20.5,-6 -9.5,-11 -13.5,-26 -7,-25 -16,-30 -23,-8 -29,1 -5,-13 -41,-26 -25,-9 -58,-4 6,-1 0,-15 -7,-15 -19,-12 3,-6 4,-17.5 1,-11.5 1,-13.5 3,-13 12,-23 1,-1 7,-8.5 6,-7.5 9.5,-13.5 3.5,-6 0.5,-6 35,4 50,-11 5,-5 11.5,-17 6.5,-12 10.5,-17 9,-6 14,-5.5 5,0.5 14.5,5.5 9.5,5 14.5,5 14,1 15.5,-11 1.5,-12 -7.5,-20 12,1 3,-17 -5,-7 -8,-9 -12,-4 -27,5 -8,4 2,8 -1,-1 -9.5,10.5 Q 927,340 919,346 q -8,6 -16,-5 -1,-1 -5.5,-13.5 Q 893,315 888,314 q -8,0 -16,15 3,-8 -11,-15 -14,-7 -24,-8 19,-12 -8,-27 -7,-4 -20.5,-5 -13.5,-1 -19.5,4 -5,7 -5.5,11.5 -0.5,4.5 5,8 5.5,3.5 10.5,5.5 5,2 11.5,4 6.5,2 8.5,3 14,10 8,14 -2,1 -8.5,3.5 -6.5,2.5 -11.5,4.5 -5,2 -6,4 -3,4 0,14 3,10 -2,14 -5,-5 -9,-17.5 -4,-12.5 -7,-16.5 7,9 -25,6 l -10,-1 q -4,0 -16,2 -12,2 -20.5,1 -8.5,-1 -13.5,-8 -4,-8 0,-20 1,-4 4,-2 -4,-3 -11,-9.5 -7,-6.5 -10,-8.5 -46,15 -94,41 6,1 12,-1 5,-2 13,-6.5 8,-4.5 10,-5.5 34,-14 42,-7 l 5,-5 q 14,16 20,25 -7,-4 -30,-1 -20,6 -22,12 7,12 5,18 -4,-3 -11.5,-10 -7.5,-7 -14.5,-11 -7,-4 -15,-5 -16,0 -22,1 -146,80 -235,222 7,7 12,8 4,1 5,9 1,8 2.5,11 1.5,3 11.5,-3 9,8 3,19 1,-1 44,27 19,17 21,21 3,11 -10,18 -1,-2 -9,-9 -8,-7 -9,-4 -3,5 0.5,18.5 3.5,13.5 10.5,12.5 -7,0 -9.5,16 -2.5,16 -2.5,35.5 0,19.5 -1,23.5 l 2,1 q -3,12 5.5,34.5 8.5,22.5 21.5,19.5 -13,3 20,43 6,8 8,9 3,2 12,7.5 9,5.5 15,10 6,4.5 10,10.5 4,5 10,22.5 6,17.5 14,23.5 -2,6 9.5,20 11.5,14 10.5,23 -1,0 -2.5,1 -1.5,1 -2.5,1 3,7 15.5,14 12.5,7 15.5,13 1,3 2,10 1,7 3,11 2,4 8,2 2,-20 -24,-62 -15,-25 -17,-29 -3,-5 -5.5,-15.5 Q 541,919 539,915 q 2,0 6,1.5 4,1.5 8.5,3.5 4.5,2 7.5,4 3,2 2,3 -3,7 2,17.5 5,10.5 12,18.5 7,8 17,19 10,11 12,13 6,6 14,19.5 8,13.5 0,13.5 9,0 20,10 11,10 17,20 5,8 8,26 3,18 5,24 2,7 8.5,13.5 6.5,6.5 12.5,9.5 l 16,8 q 0,0 13,7 5,2 18.5,10.5 13.5,8.5 21.5,11.5 10,4 16,4 6,0 14.5,-2.5 8.5,-2.5 13.5,-3.5 15,-2 29,15 14,17 21,21 36,19 55,11 -2,1 0.5,7.5 2.5,6.5 8,15.5 5.5,9 9,14.5 3.5,5.5 5.5,8.5 5,6 18,15 13,9 18,15 6,-4 7,-9 -3,8 7,20 10,12 18,10 14,-3 14,-32 -31,15 -49,-18 0,-1 -2.5,-5.5 -2.5,-4.5 -4,-8.5 -1.5,-4 -2.5,-8.5 -1,-4.5 0,-7.5 1,-3 5,-3 9,0 10,-3.5 1,-3.5 -2,-12.5 -3,-9 -4,-13 -1,-8 -11,-20 -10,-12 -12,-15 -5,9 -16,8 -11,-1 -16,-9 0,1 -1.5,5.5 -1.5,4.5 -1.5,6.5 -13,0 -15,-1 1,-3 2.5,-17.5 1.5,-14.5 3.5,-22.5 1,-4 5.5,-12 4.5,-8 7.5,-14.5 3,-6.5 4,-12.5 1,-6 -4.5,-9.5 -5.5,-3.5 -17.5,-2.5 -19,1 -26,20 -1,3 -3,10.5 -2,7.5 -5,11.5 -3,4 -9,7 -7,3 -24,2 -17,-1 -24,-5 -13,-8 -22.5,-29 -9.5,-21 -9.5,-37 0,-10 2.5,-26.5 2.5,-16.5 3,-25 0.5,-8.5 -5.5,-24.5 3,-2 9,-9.5 6,-7.5 10,-10.5 2,-1 4.5,-1.5 2.5,-0.5 4.5,0 2,0.5 4,-1.5 2,-2 3,-6 -1,-1 -4,-3 -3,-3 -4,-3 7,3 28.5,-1.5 21.5,-4.5 27.5,1.5 15,11 22,-2 0,-1 -2.5,-9.5 Q 870,931 872,926 q 5,27 29,9 3,3 15.5,5 12.5,2 17.5,5 3,2 7,5.5 4,3.5 5.5,4.5 1.5,1 5,-0.5 3.5,-1.5 8.5,-6.5 10,14 12,24 11,40 19,44 7,3 11,2 4,-1 4.5,-9.5 0.5,-8.5 0,-14 Q 1006,989 1005,982 l -1,-8 v -18 l -1,-8 q -15,-3 -18.5,-12 -3.5,-9 1.5,-18.5 5,-9.5 15,-18.5 1,-1 8,-3.5 7,-2.5 15.5,-6.5 8.5,-4 12.5,-8 21,-19 15,-35 7,0 11,-9 -1,0 -5,-3 -4,-3 -7.5,-5 -3.5,-2 -4.5,-2 9,-5 2,-16 5,-3 7.5,-11 2.5,-8 7.5,-10 9,12 21,2 7,-8 1,-16 5,-7 20.5,-10.5 15.5,-3.5 18.5,-9.5 7,2 8,-2 1,-4 1,-12 0,-8 3,-12 4,-5 15,-9 11,-4 13,-5 l 17,-11 q 3,-4 0,-4 18,2 31,-11 10,-11 -6,-20 3,-6 -3,-9.5 -6,-3.5 -15,-5.5 3,-1 11.5,-0.5 8.5,0.5 10.5,-1.5 15,-10 -7,-16 -17,-5 -43,12 z m -163,877 q 206,-36 351,-189 -3,-3 -12.5,-4.5 -9.5,-1.5 -12.5,-3.5 -18,-7 -24,-8 1,-7 -2.5,-13 -3.5,-6 -8,-9 -4.5,-3 -12.5,-8 -8,-5 -11,-7 -2,-2 -7,-6 -5,-4 -7,-5.5 -2,-1.5 -7.5,-4.5 -5.5,-3 -8.5,-2 -3,1 -10,1 l -3,1 q -3,1 -5.5,2.5 -2.5,1.5 -5.5,3 -3,1.5 -4,3 -1,1.5 0,2.5 -21,-17 -36,-22 -5,-1 -11,-5.5 -6,-4.5 -10.5,-7 -4.5,-2.5 -10,-1.5 -5.5,1 -11.5,7 -5,5 -6,15 -1,10 -2,13 -7,-5 0,-17.5 7,-12.5 2,-18.5 -3,-6 -10.5,-4.5 -7.5,1.5 -12,4.5 -4.5,3 -11.5,8.5 -7,5.5 -9,6.5 -2,1 -8.5,5.5 -6.5,4.5 -8.5,7.5 -3,4 -6,12 -3,8 -5,11 -2,-4 -11.5,-6.5 -9.5,-2.5 -9.5,-5.5 2,10 4,35 2,25 5,38 7,31 -12,48 -27,25 -29,40 -4,22 12,26 0,7 -8,20.5 -8,13.5 -7,21.5 0,6 2,16 z"
+     id="path153" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/info_sign.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/info_sign.svg
new file mode 100644
index 000000000..517f76360
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/info_sign.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1792 1792"
+   id="svg163"
+   sodipodi:docname="info_sign.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs167" />
+  <sodipodi:namedview
+     id="namedview165"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.48716518"
+     inkscape:cx="72.870561"
+     inkscape:cy="896"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg163" />
+  <path
+     fill="currentColor"
+     d="m 1142,1376 v -160 q 0,-14 -9,-23 -9,-9 -23,-9 h -96 V 672 q 0,-14 -9,-23 -9,-9 -23,-9 H 662 q -14,0 -23,9 -9,9 -9,23 v 160 q 0,14 9,23 9,9 23,9 h 96 v 320 h -96 q -14,0 -23,9 -9,9 -9,23 v 160 q 0,14 9,23 9,9 23,9 h 448 q 14,0 23,-9 9,-9 9,-23 z M 1014,480 V 320 q 0,-14 -9,-23 -9,-9 -23,-9 H 790 q -14,0 -23,9 -9,9 -9,23 v 160 q 0,14 9,23 9,9 23,9 h 192 q 14,0 23,-9 9,-9 9,-23 z m 640,416 q 0,209 -103,385.5 Q 1448,1458 1271.5,1561 1095,1664 886,1664 677,1664 500.5,1561 324,1458 221,1281.5 118,1105 118,896 118,687 221,510.5 324,334 500.5,231 677,128 886,128 1095,128 1271.5,231 1448,334 1551,510.5 1654,687 1654,896 Z"
+     id="path161" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/leaf.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/leaf.svg
new file mode 100644
index 000000000..c1cabb5cf
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/leaf.svg
@@ -0,0 +1,7 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" viewBox="-10 0 1034 1024">
+   <path fill="currentColor"
+d="M765 327l-14 -11l-538 502l503 -533l-14 -12q-48 -26 -106 -23.5t-109 19.5q-14 4 -28.5 10t-28.5 13q-30 14 -57.5 32.5t-52.5 41.5q-55 52 -90.5 119t-52.5 140q-5 21 -9 42t-7 42q-3 26 -5.5 52.5t-4.5 53.5q-1 22 1.5 45.5t33.5 21.5h11.5h10.5q78 -2 156 -6t153 -29
+q49 -16 94 -42.5t82 -62.5q27 -27 50 -60t39 -69.5t24 -75.5t5 -78q-3 -35 -12.5 -70t-33.5 -62v0zM844 160l30 30l-563 531z" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/light_bulb.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/light_bulb.svg
new file mode 100644
index 000000000..ed2ed55fb
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/light_bulb.svg
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-10 0 1538 1538"
+   id="svg4"
+   sodipodi:docname="light_bulb.svg"
+   width="1538"
+   height="1538"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs8" />
+  <sodipodi:namedview
+     id="namedview6"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     fit-margin-top="1"
+     fit-margin-left="1"
+     fit-margin-right="1"
+     fit-margin-bottom="1"
+     lock-margins="true"
+     inkscape:zoom="0.16"
+     inkscape:cx="1234.375"
+     inkscape:cy="409.375"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg4" />
+  <path
+     fill="currentColor"
+     d="m 983,449 q 0,13 -9.5,22.5 Q 964,481 951,481 938,481 928.5,471.5 919,462 919,449 919,403 865,378 811,353 759,353 746,353 736.5,343.5 727,334 727,321 q 0,-13 9.5,-22.5 9.5,-9.5 22.5,-9.5 50,0 99.5,16 49.5,16 87,54 37.5,38 37.5,90 z m 160,0 q 0,-72 -34.5,-134 -34.5,-62 -90,-101.5 Q 963,174 895.5,151.5 828,129 759,129 690,129 622.5,151.5 555,174 499.5,213.5 444,253 409.5,315 375,377 375,449 q 0,101 68,180 10,11 30.5,33 20.5,22 30.5,33 128,153 141,298 h 228 q 13,-145 141,-298 10,-11 30.5,-33 20.5,-22 30.5,-33 68,-79 68,-180 z m 128,0 q 0,155 -103,268 -45,49 -74.5,87 -29.5,38 -59.5,95.5 -30,57.5 -34,107.5 47,28 47,82 0,37 -25,64 25,27 25,64 0,52 -45,81 13,23 13,47 0,46 -31.5,71 -31.5,25 -77.5,25 -20,44 -60,70 -40,26 -87,26 -47,0 -87,-26 -40,-26 -60,-70 -46,0 -77.5,-25 -31.5,-25 -31.5,-71 0,-24 13,-47 -45,-29 -45,-81 0,-37 25,-64 -25,-27 -25,-64 0,-54 47,-82 Q 514,957 484,899.5 454,842 424.5,804 395,766 350,717 247,604 247,449 247,350 291.5,264.5 336,179 408.5,122.5 481,66 572.5,33.5 664,1 759,1 q 95,0 186.5,32.5 91.5,32.5 164,89 72.5,56.5 117,142 Q 1271,350 1271,449 Z"
+     id="path2" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/qt_logo.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/qt_logo.svg
new file mode 100644
index 000000000..062daff3e
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/qt_logo.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="462pt"
+        height="339pt"
+        viewBox="0 0 462 339"
+        version="1.1"
+        id="svg2"
+>
+    <path
+            fill="#41cd52"
+            d=" M 63.50 0.00 L 462.00 0.00 L 462.00 274.79 C 440.60 296.26 419.13 317.66 397.61 339.00 L 0.00 339.00 L 0.00 63.39 C 21.08 42.18 42.34 21.13 63.50 0.00 Z"
+            id="path6"/>
+    <path
+            d=" M 122.37 71.33 C 137.50 61.32 156.21 58.79 174.00 58.95 C 190.94 59.16 208.72 62.13 222.76 72.24 C 232.96 79.41 239.59 90.48 244.01 101.93 C 251.16 120.73 253.26 141.03 253.50 161.01 C 253.53 181.13 252.62 201.69 245.96 220.86 C 241.50 233.90 233.01 245.48 221.81 253.52 C 229.87 266.58 238.09 279.54 246.15 292.60 C 236.02 297.27 225.92 301.97 215.78 306.62 C 207.15 292.38 198.56 278.11 189.90 263.89 C 178.19 265.81 166.21 265.66 154.44 264.36 C 140.34 262.67 125.97 258.37 115.09 248.88 C 106.73 241.64 101.48 231.51 97.89 221.21 C 92.01 203.79 90.43 185.25 90.16 166.97 C 90.02 147.21 91.28 127.14 97.24 108.18 C 101.85 93.92 109.48 79.69 122.37 71.33 Z"
+            id="path8"
+            fill="#ffffff"/>
+    <path
+            d=" M 294.13 70.69 C 304.73 70.68 315.33 70.68 325.93 70.69 C 325.96 84.71 325.92 98.72 325.95 112.74 C 339.50 112.76 353.05 112.74 366.60 112.75 C 366.37 121.85 366.12 130.95 365.86 140.05 C 352.32 140.08 338.79 140.04 325.25 140.07 C 325.28 163.05 325.18 186.03 325.30 209.01 C 325.56 215.30 325.42 221.94 328.19 227.75 C 330.21 232.23 335.65 233.38 340.08 233.53 C 348.43 233.50 356.77 233.01 365.12 232.86 C 365.63 241.22 366.12 249.59 366.60 257.95 C 349.99 260.74 332.56 264.08 316.06 258.86 C 309.11 256.80 302.63 252.19 299.81 245.32 C 294.76 233.63 294.35 220.62 294.13 208.07 C 294.11 185.40 294.13 162.74 294.12 140.07 C 286.73 140.05 279.34 140.08 271.95 140.05 C 271.93 130.96 271.93 121.86 271.95 112.76 C 279.34 112.73 286.72 112.77 294.11 112.74 C 294.14 98.72 294.10 84.71 294.13 70.69 Z"
+            id="path10"
+            fill="#ffffff"/>
+    <path
+            fill="#41cd52"
+            d=" M 160.51 87.70 C 170.80 86.36 181.60 86.72 191.34 90.61 C 199.23 93.73 205.93 99.84 209.47 107.58 C 214.90 119.31 216.98 132.26 218.03 145.05 C 219.17 162.07 219.01 179.25 216.66 196.17 C 215.01 206.24 212.66 216.85 205.84 224.79 C 198.92 232.76 188.25 236.18 178.01 236.98 C 167.21 237.77 155.82 236.98 146.07 231.87 C 140.38 228.84 135.55 224.09 132.73 218.27 C 129.31 211.30 127.43 203.69 126.11 196.07 C 122.13 171.91 121.17 146.91 126.61 122.89 C 128.85 113.83 132.11 104.53 138.73 97.70 C 144.49 91.85 152.51 88.83 160.51 87.70 Z"
+            id="path12"/>
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/read.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/read.svg
new file mode 100644
index 000000000..c3af473d2
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/read.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   viewBox="-11 0 1792 1792"
+   id="svg184"
+   sodipodi:docname="read.svg"
+   width="1792"
+   height="1792"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs188" />
+  <sodipodi:namedview
+     id="namedview186"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="0.24358259"
+     inkscape:cx="519.33104"
+     inkscape:cy="1089.9794"
+     inkscape:window-width="1846"
+     inkscape:window-height="1016"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg184" />
+  <path
+     fill="currentColor"
+     d="m 1691.8576,478 q 40,57 18,129 l -275,906 q -19,64 -76.5,107.5 -57.5,43.5 -122.5,43.5 H 312.85764 q -77,0 -148.5,-53.5 Q 92.857644,1557 64.857644,1479 q -24,-67 -2,-127 0,-4 3,-27 3,-23 4,-37 1,-8 -3,-21.5 -4,-13.5 -3,-19.5 2,-11 8,-21 6,-10 16.5,-23.5 10.5,-13.5 16.499996,-23.5 23,-38 45,-91.5 22,-53.5 30,-91.5 3,-10 0.5,-30 -2.5,-20 -0.5,-28 3,-11 17,-28 14,-17 17,-23 21,-36 42,-92 21,-56 25,-90 1,-9 -2.5,-32 -3.5,-23 0.5,-28 4,-13 22,-30.5 18,-17.5 22,-22.5 19,-26 42.5,-84.5 23.5,-58.5 27.5,-96.5 1,-8 -3,-25.5 -4,-17.5 -2,-26.5 2,-8 9,-18 7,-10 18,-23 11,-13 17,-21 8,-12 16.5,-30.5 8.5,-18.5 15,-35 6.5,-16.5 16,-36 9.5,-19.5 19.5,-32 10,-12.5 26.5,-23.5 16.5,-11 36,-11.5 19.5,-0.5 47.5,5.5 l -1,3 q 38,-9 51,-9 h 760.99996 q 74,0 114,56 40,56 18,130 l -274,906 q -36,119 -71.5,153.5 -35.5,34.5 -128.5,34.5 H 208.85764 q -27,0 -38,15 -11,16 -1,43 24,70 144,70 h 922.99996 q 29,0 56,-15.5 27,-15.5 35,-41.5 l 300,-987 q 7,-22 5,-57 38,15 59,43 z m -1063.99996,2 q -4,13 2,22.5 6,9.5 20,9.5 h 607.99996 q 13,0 25.5,-9.5 12.5,-9.5 16.5,-22.5 l 21,-64 q 4,-13 -2,-22.5 -6,-9.5 -20,-9.5 H 690.85764 q -13,0 -25.5,9.5 -12.5,9.5 -16.5,22.5 z m -83,256 q -4,13 2,22.5 6,9.5 20,9.5 h 607.99996 q 13,0 25.5,-9.5 12.5,-9.5 16.5,-22.5 l 21,-64 q 4,-13 -2,-22.5 -6,-9.5 -20,-9.5 H 607.85764 q -13,0 -25.5,9.5 -12.5,9.5 -16.5,22.5 z"
+     id="path182" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/resize.svg b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/resize.svg
new file mode 100644
index 000000000..e86d612f3
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/icons/resize.svg
@@ -0,0 +1,6 @@
+<svg xmlns='http://www.w3.org/2000/svg' width='100' height='100'>
+    <line x1="00" y1="100" x2="100" y2="00" stroke="black" stroke-width="3" />
+    <line x1="20" y1="100" x2="100" y2="20" stroke="black" stroke-width="3" />
+    <line x1="40" y1="100" x2="100" y2="40" stroke="black" stroke-width="3" />
+    <line x1="60" y1="100" x2="100" y2="60" stroke="black" stroke-width="3" />
+</svg>
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/About.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/About.qml
new file mode 100644
index 000000000..178bf03e4
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/About.qml
@@ -0,0 +1,93 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Controls.Basic
+import FileSystemModule
+
+ApplicationWindow {
+    id: root
+    width: 650
+    height: 550
+    flags: Qt.Window | Qt.FramelessWindowHint
+    color: Colors.surface1
+
+    menuBar: MyMenuBar {
+        id: menuBar
+
+        dragWindow: root
+        implicitHeight: 27
+        infoText: "About Qt"
+    }
+
+    Image {
+        id: logo
+
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        anchors.margins: 20
+
+        source: "../icons/qt_logo.svg"
+        sourceSize.width: 80
+        sourceSize.height: 80
+        fillMode: Image.PreserveAspectFit
+
+        smooth: true
+        antialiasing: true
+        asynchronous: true
+    }
+
+    ScrollView {
+      anchors.top: logo.bottom
+      anchors.left: parent.left
+      anchors.right: parent.right
+      anchors.bottom: parent.bottom
+      anchors.margins: 20
+
+      TextArea {
+          selectedTextColor: Colors.textFile
+          selectionColor: Colors.selection
+          horizontalAlignment: Text.AlignHCenter
+          textFormat: Text.RichText
+
+          text: qsTr("<h3>About Qt</h3>"
+                   + "<p>This program uses Qt version %1.</p>"
+                   + "<p>Qt is a C++ toolkit for cross-platform application "
+                   + "development.</p>"
+                   + "<p>Qt provides single-source portability across all major desktop "
+                   + "operating systems. It is also available for embedded Linux and other "
+                   + "embedded and mobile operating systems.</p>"
+                   + "<p>Qt is available under multiple licensing options designed "
+                   + "to accommodate the needs of our various users.</p>"
+                   + "<p>Qt licensed under our commercial license agreement is appropriate "
+                   + "for development of proprietary/commercial software where you do not "
+                   + "want to share any source code with third parties or otherwise cannot "
+                   + "comply with the terms of GNU (L)GPL.</p>"
+                   + "<p>Qt licensed under GNU (L)GPL is appropriate for the "
+                   + "development of Qt&nbsp;applications provided you can comply with the terms "
+                   + "and conditions of the respective licenses.</p>"
+                   + "<p>Please see <a href=\"http://%2/\">%2</a> "
+                   + "for an overview of Qt licensing.</p>"
+                   + "<p>Copyright (C) %3 The Qt Company Ltd and other "
+                   + "contributors.</p>"
+                   + "<p>Qt and the Qt logo are trademarks of The Qt Company Ltd.</p>"
+                   + "<p>Qt is The Qt Company Ltd product developed as an open source "
+                   + "project. See <a href=\"http://%4/\">%4</a> for more information.</p>")
+                   .arg(Application.version).arg("qt.io/licensing").arg("2023").arg("qt.io")
+          color: Colors.textFile
+          wrapMode: Text.WordWrap
+          readOnly: true
+          antialiasing: true
+          background: null
+
+          onLinkActivated: function(link) {
+              Qt.openUrlExternally(link)
+          }
+      }
+    }
+
+    ResizeButton {
+        resizeWindow: root
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ColorScheme.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ColorScheme.qml
new file mode 100644
index 000000000..19c8cd905
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ColorScheme.qml
@@ -0,0 +1,118 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+import FileSystemModule
+
+ColumnLayout {
+    id: colorScheme
+
+    spacing: 20
+
+    // Inline component that customizes TabButton
+    component MyTabButton: TabButton {
+        id: root
+
+        implicitWidth: 150
+        implicitHeight: 30
+        padding: 6
+        spacing: 6
+
+        contentItem: Text {
+            anchors.centerIn: parent
+            horizontalAlignment: Text.AlignHCenter
+            verticalAlignment: Text.AlignVCenter
+
+            text: root.text
+            font.bold: true
+            color: Colors.text
+        }
+
+        background: Rectangle {
+            anchors.fill: parent
+            implicitHeight: 40
+
+            color: root.checked ? Colors.active : Colors.selection
+            Rectangle {
+                height: 4
+                width: parent.width
+                color: root.checked ? Colors.color1 : Colors.selection
+            }
+        }
+    }
+
+    Item {
+        // Spacer item
+        Layout.fillHeight: true
+        Layout.fillWidth: true
+    }
+
+    Text {
+        Layout.alignment: Qt.AlignHCenter
+
+        text: "Select a Scheme!"
+        font.pointSize: 30
+        font.bold: true
+        color: Colors.text
+    }
+
+    // Display all the color-scheme names. The model is a string-list provided
+    // by our python class.
+    TabBar {
+        id: schemeSelector
+
+        Layout.alignment: Qt.AlignHCenter
+
+        background: Rectangle {
+            color: Colors.surface1
+        }
+
+        Repeater {
+            model: Colors.getKeys()
+            MyTabButton {
+                text: modelData
+                onClicked: {
+                    Colors.setScheme(modelData)
+                    themePreviewContainer.background
+                            = (modelData === "Solarized") ? "#777777" : "#FEFAEC"
+                }
+            }
+        }
+    }
+
+    // The current colors can be visualized using the same method as above.
+    Rectangle {
+        id: themePreviewContainer
+
+        property color background: "#FEFAEC"
+
+        Layout.alignment: Qt.AlignHCenter
+
+        width: 700
+        height: 50
+        radius: 10
+        color: background
+
+        // Display all used colors inside a row
+        Row {
+            anchors.centerIn: parent
+            spacing: 10
+
+            Repeater {
+                model: Colors.currentColors
+                Rectangle {
+                    width: 35
+                    height: width
+                    radius: width / 2
+                    color: modelData
+                }
+            }
+        }
+    }
+    Item {
+        // Spacer item
+        Layout.fillHeight: true
+        Layout.fillWidth: true
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Editor.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Editor.qml
new file mode 100644
index 000000000..80f7c04c5
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Editor.qml
@@ -0,0 +1,160 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+import FileSystemModule
+
+pragma ComponentBehavior: Bound
+
+// This is the text editor that displays the currently open file, including
+// their corresponding line numbers.
+Rectangle {
+    id: root
+
+    required property string currentFilePath
+    required property bool showLineNumbers
+    property alias text: textArea
+    property int currentLineNumber: -1
+    property int rowHeight: Math.ceil(fontMetrics.lineSpacing)
+
+    color: Colors.background
+
+    onWidthChanged: textArea.update()
+    onHeightChanged: textArea.update()
+
+    RowLayout {
+        anchors.fill: parent
+        // We use a flickable to synchronize the position of the editor and
+        // the line numbers. This is necessary because the line numbers can
+        // extend the available height.
+        Flickable {
+            id: lineNumbers
+
+            // Calculate the width based on the logarithmic scale.
+            Layout.preferredWidth: fontMetrics.averageCharacterWidth
+                * (Math.floor(Math.log10(textArea.lineCount)) + 1) + 10
+            Layout.fillHeight: true
+
+            interactive: false
+            contentY: editorFlickable.contentY
+            visible: textArea.text !== "" && root.showLineNumbers
+
+            Column {
+                anchors.fill: parent
+                Repeater {
+                    id: repeatedLineNumbers
+
+                    model: LineNumberModel {
+                        lineCount: textArea.text !== "" ? textArea.lineCount : 0
+                    }
+
+                    delegate: Item {
+                        required property int index
+
+                        width: parent.width
+                        height: root.rowHeight
+                        Label {
+                            id: numbers
+
+                            text: parent.index + 1
+
+                            width: parent.width
+                            height: parent.height
+                            horizontalAlignment: Text.AlignLeft
+                            verticalAlignment: Text.AlignVCenter
+
+                            color: (root.currentLineNumber === parent.index)
+                                    ? Colors.iconIndicator : Qt.darker(Colors.text, 2)
+                            font: textArea.font
+                        }
+                        Rectangle {
+                            id: indicator
+
+                            anchors.left: numbers.right
+                            width: 1
+                            height: parent.height
+                            color: Qt.darker(Colors.text, 3)
+                        }
+                    }
+                }
+            }
+        }
+
+        Flickable {
+            id: editorFlickable
+
+            property alias textArea: textArea
+
+            // We use an inline component to customize the horizontal and vertical
+            // scroll-bars. This is convenient when the component is only used in one file.
+            component MyScrollBar: ScrollBar {
+                id: scrollBar
+                background: Rectangle {
+                    implicitWidth: scrollBar.interactive ? 8 : 4
+                    implicitHeight: scrollBar.interactive ? 8 : 4
+
+                    opacity: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.0
+                    color: Colors.background
+                    Behavior on opacity {
+                        OpacityAnimator {
+                            duration: 500
+                        }
+                    }
+                }
+                contentItem: Rectangle {
+                    implicitWidth: scrollBar.interactive ? 8 : 4
+                    implicitHeight: scrollBar.interactive ? 8 : 4
+                    opacity: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.0
+                    color: Colors.color1
+                    Behavior on opacity {
+                        OpacityAnimator {
+                            duration: 1000
+                        }
+                    }
+                }
+            }
+
+            Layout.fillHeight: true
+            Layout.fillWidth: true
+            ScrollBar.horizontal: MyScrollBar {}
+            ScrollBar.vertical: MyScrollBar {}
+
+            boundsBehavior: Flickable.StopAtBounds
+
+            TextArea.flickable: TextArea {
+                id: textArea
+                anchors.fill: parent
+
+                focus: false
+                topPadding: 0
+                leftPadding: 10
+
+                text: FileSystemModel.readFile(root.currentFilePath)
+                tabStopDistance: fontMetrics.averageCharacterWidth * 4
+
+                // Grab the current line number from the C++ interface.
+                onCursorPositionChanged: {
+                    root.currentLineNumber = FileSystemModel.currentLineNumber(
+                        textArea.textDocument, textArea.cursorPosition)
+                }
+
+                color: Colors.textFile
+                selectedTextColor: Colors.textFile
+                selectionColor: Colors.selection
+
+                textFormat: TextEdit.PlainText
+                renderType: Text.QtRendering
+                selectByMouse: true
+                antialiasing: true
+                background: null
+            }
+
+            FontMetrics {
+                id: fontMetrics
+                font: textArea.font
+            }
+        }
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/FileSystemView.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/FileSystemView.qml
new file mode 100644
index 000000000..db955168c
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/FileSystemView.qml
@@ -0,0 +1,156 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Effects
+import QtQuick.Controls.Basic
+import FileSystemModule
+
+pragma ComponentBehavior: Bound
+
+// This is the file system view which gets populated by the C++ model.
+Rectangle {
+    id: root
+
+    signal fileClicked(string filePath)
+    property alias rootIndex: fileSystemTreeView.rootIndex
+
+    TreeView {
+        id: fileSystemTreeView
+
+        property int lastIndex: -1
+
+        anchors.fill: parent
+        model: FileSystemModel
+        rootIndex: FileSystemModel.rootIndex
+        boundsBehavior: Flickable.StopAtBounds
+        boundsMovement: Flickable.StopAtBounds
+        clip: true
+
+        Component.onCompleted: fileSystemTreeView.toggleExpanded(0)
+
+        // The delegate represents a single entry in the filesystem.
+        delegate: TreeViewDelegate {
+            id: treeDelegate
+            indentation: 8
+            implicitWidth: fileSystemTreeView.width > 0 ? fileSystemTreeView.width : 250
+            implicitHeight: 25
+
+            // Since we have the 'ComponentBehavior Bound' pragma, we need to
+            // require these properties from our model. This is a convenient way
+            // to bind the properties provided by the model's role names.
+            required property int index
+            required property url filePath
+            required property string fileName
+
+            indicator: Image {
+                id: directoryIcon
+
+                x: treeDelegate.leftMargin + (treeDelegate.depth * treeDelegate.indentation)
+                anchors.verticalCenter: parent.verticalCenter
+                source: treeDelegate.hasChildren ? (treeDelegate.expanded
+                            ? "../icons/folder_open.svg" : "../icons/folder_closed.svg")
+                        : "../icons/generic_file.svg"
+                sourceSize.width: 20
+                sourceSize.height: 20
+                fillMode: Image.PreserveAspectFit
+
+                smooth: true
+                antialiasing: true
+                asynchronous: true
+            }
+
+            contentItem: Text {
+                text: treeDelegate.fileName
+                color: Colors.text
+            }
+
+            background: Rectangle {
+                color: (treeDelegate.index === fileSystemTreeView.lastIndex)
+                    ? Colors.selection
+                    : (hoverHandler.hovered ? Colors.active : "transparent")
+            }
+
+            // We color the directory icons with this MultiEffect, where we overlay
+            // the colorization color ontop of the SVG icons.
+            MultiEffect {
+                id: iconOverlay
+
+                anchors.fill: directoryIcon
+                source: directoryIcon
+                colorization: 1.0
+                brightness: 1.0
+                colorizationColor: {
+                    const isFile = treeDelegate.index === fileSystemTreeView.lastIndex
+                                    && !treeDelegate.hasChildren;
+                    if (isFile)
+                        return Qt.lighter(Colors.folder, 3)
+
+                    const isExpandedFolder = treeDelegate.expanded && treeDelegate.hasChildren;
+                    if (isExpandedFolder)
+                        return Colors.color2
+                    else
+                        return Colors.folder
+                }
+            }
+
+            HoverHandler {
+                id: hoverHandler
+            }
+
+            TapHandler {
+                acceptedButtons: Qt.LeftButton | Qt.RightButton
+                onSingleTapped: (eventPoint, button) => {
+                    switch (button) {
+                        case Qt.LeftButton:
+                            fileSystemTreeView.toggleExpanded(treeDelegate.row)
+                            fileSystemTreeView.lastIndex = treeDelegate.index
+                            // If this model item doesn't have children, it means it's
+                            // representing a file.
+                            if (!treeDelegate.hasChildren)
+                                root.fileClicked(treeDelegate.filePath)
+                        break;
+                        case Qt.RightButton:
+                            if (treeDelegate.hasChildren)
+                                contextMenu.popup();
+                        break;
+                    }
+                }
+            }
+
+            MyMenu {
+                id: contextMenu
+                Action {
+                    text: qsTr("Set as root index")
+                    onTriggered: {
+                        fileSystemTreeView.rootIndex = fileSystemTreeView.index(treeDelegate.row, 0)
+                    }
+                }
+                Action {
+                    text: qsTr("Reset root index")
+                    onTriggered: fileSystemTreeView.rootIndex = undefined
+                }
+            }
+        }
+
+        // Provide our own custom ScrollIndicator for the TreeView.
+        ScrollIndicator.vertical: ScrollIndicator {
+            active: true
+            implicitWidth: 15
+
+            contentItem: Rectangle {
+                implicitWidth: 6
+                implicitHeight: 6
+
+                color: Colors.color1
+                opacity: fileSystemTreeView.movingVertically ? 0.5 : 0.0
+
+                Behavior on opacity {
+                    OpacityAnimator {
+                        duration: 500
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenu.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenu.qml
new file mode 100644
index 000000000..1f1d30c56
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenu.qml
@@ -0,0 +1,45 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Controls.Basic
+import FileSystemModule
+
+Menu {
+    id: root
+
+    delegate: MenuItem {
+        id: menuItem
+        contentItem: Item {
+            Text {
+                anchors.verticalCenter: parent.verticalCenter
+                anchors.left: parent.left
+                anchors.leftMargin: 5
+
+                text: menuItem.text
+                color: enabled ? Colors.text : Colors.disabledText
+            }
+            Rectangle {
+                id: indicator
+
+                anchors.verticalCenter: parent.verticalCenter
+                anchors.right: parent.right
+                width: 6
+                height: parent.height
+
+                visible: menuItem.highlighted
+                color: Colors.color2
+            }
+        }
+        background: Rectangle {
+            implicitWidth: 210
+            implicitHeight: 35
+            color: menuItem.highlighted ? Colors.active : "transparent"
+        }
+    }
+    background: Rectangle {
+        implicitWidth: 210
+        implicitHeight: 35
+        color: Colors.surface2
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenuBar.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenuBar.qml
new file mode 100644
index 000000000..4874a2c03
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/MyMenuBar.qml
@@ -0,0 +1,177 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls.Basic
+import FileSystemModule
+
+// The MenuBar also serves as a controller for our window as we don't use any decorations.
+MenuBar {
+    id: root
+
+    required property ApplicationWindow dragWindow
+    property alias infoText: windowInfo.text
+
+    // Customization of the top level menus inside the MenuBar
+    delegate: MenuBarItem {
+        id: menuBarItem
+
+        contentItem: Text {
+            horizontalAlignment: Text.AlignLeft
+            verticalAlignment: Text.AlignVCenter
+
+            text: menuBarItem.text
+            font: menuBarItem.font
+            elide: Text.ElideRight
+            color: menuBarItem.highlighted ? Colors.textFile : Colors.text
+            opacity: enabled ? 1.0 : 0.3
+        }
+
+        background: Rectangle {
+            id: background
+
+            color: menuBarItem.highlighted ? Colors.selection : "transparent"
+            Rectangle {
+                id: indicator
+
+                width: 0; height: 3
+                anchors.horizontalCenter: parent.horizontalCenter
+                anchors.bottom: parent.bottom
+
+                color: Colors.color1
+                states: State {
+                    name: "active"
+                    when: menuBarItem.highlighted
+                    PropertyChanges {
+                        indicator.width: background.width - 2
+                    }
+                }
+                transitions: Transition {
+                    NumberAnimation {
+                        properties: "width"
+                        duration: 175
+                    }
+                }
+            }
+        }
+    }
+    // We use the contentItem property as a place to attach our window decorations. Beneath
+    // the usual menu entries within a MenuBar, it includes a centered information text, along
+    // with the minimize, maximize, and close buttons.
+    contentItem: RowLayout {
+        id: windowBar
+
+        Layout.fillWidth: true
+        Layout.fillHeight: true
+
+        spacing: root.spacing
+        Repeater {
+            id: menuBarItems
+
+            Layout.alignment: Qt.AlignLeft
+            model: root.contentModel
+        }
+
+        Item {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            Text {
+                id: windowInfo
+
+                width: parent.width; height: parent.height
+                horizontalAlignment: Text.AlignHCenter
+                verticalAlignment: Text.AlignVCenter
+                leftPadding: windowActions.width
+                color: Colors.text
+                clip: true
+            }
+        }
+
+        RowLayout {
+            id: windowActions
+
+            Layout.alignment: Qt.AlignRight
+            Layout.fillHeight: true
+
+            spacing: 0
+
+            component InteractionButton: Rectangle {
+                id: interactionButton
+
+                signal action()
+                property alias hovered: hoverHandler.hovered
+
+                Layout.fillHeight: true
+                Layout.preferredWidth: height
+
+                color: hovered ? Colors.background : "transparent"
+                HoverHandler {
+                    id: hoverHandler
+                }
+                TapHandler {
+                    id: tapHandler
+                    onTapped: interactionButton.action()
+                }
+            }
+
+            InteractionButton {
+                id: minimize
+
+                onAction: root.dragWindow.showMinimized()
+                Rectangle {
+                    anchors.centerIn: parent
+                    color: parent.hovered ? Colors.iconIndicator : Colors.icon
+                    height: 2
+                    width: parent.height - 14
+                }
+            }
+
+            InteractionButton {
+                id: maximize
+
+                onAction: root.dragWindow.showMaximized()
+                Rectangle {
+                    anchors.fill: parent
+                    anchors.margins: 7
+                    border.color: parent.hovered ? Colors.iconIndicator : Colors.icon
+                    border.width: 2
+                    color: "transparent"
+                }
+            }
+
+            InteractionButton {
+                id: close
+
+                color: hovered ? "#ec4143" : "transparent"
+                onAction: root.dragWindow.close()
+                Rectangle {
+                    anchors.centerIn: parent
+                    width: parent.height - 8; height: 2
+
+                    rotation: 45
+                    antialiasing: true
+                    transformOrigin: Item.Center
+                    color: parent.hovered ? Colors.iconIndicator : Colors.icon
+
+                    Rectangle {
+                        anchors.centerIn: parent
+                        width: parent.height
+                        height: parent.width
+
+                        antialiasing: true
+                        color: parent.color
+                    }
+                }
+            }
+        }
+    }
+
+    background: Rectangle {
+        color: Colors.surface2
+        // Make the empty space drag the specified root window.
+        WindowDragHandler {
+            dragWindow: root.dragWindow
+        }
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ResizeButton.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ResizeButton.qml
new file mode 100644
index 000000000..0df65bf82
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/ResizeButton.qml
@@ -0,0 +1,23 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick.Controls
+import FileSystemModule
+
+Button {
+    required property ApplicationWindow resizeWindow
+
+    icon.width: 20; icon.height: 20
+    anchors.right: parent.right
+    anchors.bottom: parent.bottom
+    rightPadding: 3
+    bottomPadding: 3
+
+    icon.source: "../icons/resize.svg"
+    icon.color: hovered ? Colors.iconIndicator : Colors.icon
+
+    background: null
+    checkable: false
+    display: AbstractButton.IconOnly
+    onPressed: resizeWindow.startSystemResize(Qt.BottomEdge | Qt.RightEdge)
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Sidebar.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Sidebar.qml
new file mode 100644
index 000000000..04880a55d
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/Sidebar.qml
@@ -0,0 +1,146 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls.Basic
+import FileSystemModule
+
+Rectangle {
+    id: root
+
+    property alias currentTabIndex: topBar.currentIndex
+    required property ApplicationWindow dragWindow
+    readonly property int tabBarSpacing: 10
+
+    color: Colors.surface2
+
+    component SidebarEntry: Button {
+        id: sidebarButton
+
+        Layout.alignment: Qt.AlignHCenter
+        Layout.fillWidth: true
+
+        icon.color: down || checked ? Colors.iconIndicator : Colors.icon
+        icon.width: 27
+        icon.height: 27
+
+        topPadding: 0
+        rightPadding: 0
+        bottomPadding: 0
+        leftPadding: 0
+        background: null
+
+        Rectangle {
+            id: indicator
+
+            anchors.verticalCenter: parent.verticalCenter
+            x: 2
+            width: 4
+            height: sidebarButton.icon.height * 1.2
+
+            visible: sidebarButton.checked
+            color: Colors.color1
+        }
+    }
+
+    // TabBar is designed to be horizontal, whereas we need a vertical bar.
+    // We can easily achieve that by using a Container.
+    component TabBar: Container {
+        id: tabBarComponent
+
+        Layout.fillWidth: true
+        // ButtonGroup ensures that only one button can be checked at a time.
+        ButtonGroup {
+            buttons: tabBarComponent.contentChildren
+
+            // We have to manage the currentIndex ourselves, which we do by setting it to the index
+            // of the currently checked button. We use setCurrentIndex instead of setting the
+            // currentIndex property to avoid breaking bindings. See "Managing the Current Index"
+            // in Container's documentation for more information.
+            onCheckedButtonChanged: tabBarComponent.setCurrentIndex(
+                Math.max(0, buttons.indexOf(checkedButton)))
+        }
+
+        contentItem: ColumnLayout {
+            spacing: tabBarComponent.spacing
+            Repeater {
+                model: tabBarComponent.contentModel
+            }
+        }
+    }
+
+    ColumnLayout {
+        anchors.fill: root
+        anchors.topMargin: root.tabBarSpacing
+        anchors.bottomMargin: root.tabBarSpacing
+
+        spacing: root.tabBarSpacing
+        TabBar {
+            id: topBar
+
+            spacing: root.tabBarSpacing
+            // Shows help text when clicked.
+            SidebarEntry {
+                id: infoTab
+                icon.source: "../icons/light_bulb.svg"
+                checkable: true
+                checked: true
+            }
+
+            // Shows the file system when clicked.
+            SidebarEntry {
+                id: filesystemTab
+
+                icon.source: "../icons/read.svg"
+                checkable: true
+            }
+
+            // Shows the scheme switcher
+            SidebarEntry {
+                icon.source: "../icons/leaf.svg"
+                checkable: true
+
+                Layout.alignment: Qt.AlignHCenter
+            }
+        }
+
+        // This item acts as a spacer to expand between the checkable and non-checkable buttons.
+        Item {
+            Layout.fillHeight: true
+            Layout.fillWidth: true
+
+            // Make the empty space drag our main window.
+            WindowDragHandler {
+                dragWindow: root.dragWindow
+            }
+        }
+
+        TabBar {
+            id: bottomBar
+
+            spacing: root.tabBarSpacing
+            // Opens the Qt website in the system's web browser.
+            SidebarEntry {
+                id: qtWebsiteButton
+                icon.source: "../icons/globe.svg"
+                checkable: false
+                onClicked: Qt.openUrlExternally("https://www.qt.io/")
+            }
+
+            // Opens the About Qt Window.
+            SidebarEntry {
+                id: aboutQtButton
+
+                icon.source: "../icons/info_sign.svg"
+                checkable: false
+                onClicked: aboutQtWindow.visible = !aboutQtWindow.visible
+            }
+        }
+    }
+
+    About {
+        id: aboutQtWindow
+        visible: false
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/WindowDragHandler.qml b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/WindowDragHandler.qml
new file mode 100644
index 000000000..0e140aca3
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qml/WindowDragHandler.qml
@@ -0,0 +1,16 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick
+import QtQuick.Controls
+
+// Allows dragging the window when placed on an unused section of the UI.
+DragHandler {
+
+    required property ApplicationWindow dragWindow
+
+    target: null
+    onActiveChanged: {
+        if (active) dragWindow.startSystemMove()
+    }
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qmldir b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qmldir
new file mode 100644
index 000000000..e9c99b07b
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/FileSystemModule/qmldir
@@ -0,0 +1,11 @@
+module FileSystemModule
+Main 1.0 Main.qml
+About 1.0 qml/About.qml
+Editor 1.0 qml/Editor.qml
+MyMenu 1.0 qml/MyMenu.qml
+Sidebar 1.0 qml/Sidebar.qml
+MyMenuBar 1.0 qml/MyMenuBar.qml
+ColorScheme 1.0 qml/ColorScheme.qml
+ResizeButton 1.0 qml/ResizeButton.qml
+FileSystemView 1.0 qml/FileSystemView.qml
+WindowDragHandler 1.0 qml/WindowDragHandler.qml
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/editormodels.py b/sources/pyside6/doc/tutorials/extendedexplorer/editormodels.py
new file mode 100644
index 000000000..688147726
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/editormodels.py
@@ -0,0 +1,116 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtWidgets import QFileSystemModel
+from PySide6.QtQuick import QQuickTextDocument
+from PySide6.QtQml import QmlElement, QmlSingleton
+from PySide6.QtCore import (Qt, QDir, QAbstractListModel, Slot, QFile, QTextStream,
+                            QMimeDatabase, QFileInfo, QStandardPaths, QModelIndex,
+                            Signal, Property)
+
+QML_IMPORT_NAME = "FileSystemModule"
+QML_IMPORT_MAJOR_VERSION = 1
+
+
+@QmlElement
+@QmlSingleton
+class FileSystemModel(QFileSystemModel):
+
+    rootIndexChanged = Signal()
+
+    def getDefaultRootDir():
+        return QStandardPaths.writableLocation(QStandardPaths.StandardLocation.HomeLocation)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.mRootIndex = QModelIndex()
+        self.mDb = QMimeDatabase()
+        self.setFilter(QDir.Filter.AllEntries | QDir.Filter.Hidden | QDir.Filter.NoDotAndDotDot)
+        self.setInitialDirectory()
+
+    # check for the correct mime type and then read the file.
+    # returns the text file's content or an error message on failure
+    @Slot(str, result=str)
+    def readFile(self, path):
+        if path == "":
+            return ""
+
+        file = QFile(path)
+
+        mime = self.mDb.mimeTypeForFile(QFileInfo(file))
+        if ('text' in mime.comment().lower()
+                or any('text' in s.lower() for s in mime.parentMimeTypes())):
+            if file.open(QFile.OpenModeFlag.ReadOnly | QFile.OpenModeFlag.Text):
+                stream = QTextStream(file).readAll()
+                file.close()
+                return stream
+            else:
+                return self.tr("Error opening the file!")
+        return self.tr("File type not supported!")
+
+    @Slot(QQuickTextDocument, int, result=int)
+    def currentLineNumber(self, textDocument, cursorPosition):
+        td = textDocument.textDocument()
+        tb = td.findBlock(cursorPosition)
+        return tb.blockNumber()
+
+    def setInitialDirectory(self, path=getDefaultRootDir()):
+        dir = QDir(path)
+        if dir.makeAbsolute():
+            self.setRootPath(dir.path())
+        else:
+            self.setRootPath(self.getDefaultRootDir())
+        self.setRootIndex(self.index(dir.path()))
+
+    # we only need one column in this example
+    def columnCount(self, parent):
+        return 1
+
+    @Property(QModelIndex, notify=rootIndexChanged)
+    def rootIndex(self):
+        return self.mRootIndex
+
+    def setRootIndex(self, index):
+        if (index == self.mRootIndex):
+            return
+        self.mRootIndex = index
+        self.rootIndexChanged.emit()
+
+
+@QmlElement
+class LineNumberModel(QAbstractListModel):
+
+    lineCountChanged = Signal()
+
+    def __init__(self, parent=None):
+        self.mLineCount = 0
+        super().__init__(parent=parent)
+
+    @Property(int, notify=lineCountChanged)
+    def lineCount(self):
+        return self.mLineCount
+
+    @lineCount.setter
+    def lineCount(self, n):
+        if n < 0:
+            print("lineCount must be greater then zero")
+            return
+        if self.mLineCount == n:
+            return
+
+        if self.mLineCount < n:
+            self.beginInsertRows(QModelIndex(), self.mLineCount, n - 1)
+            self.mLineCount = n
+            self.endInsertRows()
+        else:
+            self.beginRemoveRows(QModelIndex(), n, self.mLineCount - 1)
+            self.mLineCount = n
+            self.endRemoveRows()
+
+    def rowCount(self, parent):
+        return self.mLineCount
+
+    def data(self, index, role):
+        if not self.checkIndex(index) or role != Qt.ItemDataRole.DisplayRole:
+            return
+        return index.row()
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.md b/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.md
new file mode 100644
index 000000000..0ac7bec18
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.md
@@ -0,0 +1,210 @@
+# Extending the file system explorer example
+
+This tutorial shows how to extend the
+[Filesystem Explorer Example](filesystemexplorer_example)
+by adding a simple scheme manager. This feature will allow you to switch color
+schemes during the application's runtime. The color schemes will be declared in
+JSON format and made available through a custom Python-QML plugin.
+
+![Extended Explorer GIF](resources/extendedexplorer.gif)
+
+## Defining the color schemes
+
+To define your color scheme, you can use the same color names as the original
+example, so you don't have to rename every occurrence. The original colors are
+defined in the `Colors.qml` file as follows:
+
+```{literalinclude} resources/Colors.qml
+---
+language: QML
+caption: true
+linenos: true
+lines: 7-22
+---
+```
+
+The `schemes.json` file holds the color schemes. To start implementing this, you
+can use the [Catppuccin](https://github.com/catppuccin/catppuccin) scheme.
+
+```{literalinclude} schemes.json
+---json
+caption: true
+linenos: true
+start-at: "Catppuccin"
+end-at: "},"
+---
+```
+
+In addition to the "Catppuccin" color scheme, four other color schemes got
+implemented: Nordic, One Dark, Gruvbox, and Solarized. However, feel free to get
+creative and experiment with **your** schemes.
+
+To define a new color scheme, copy the structure from above and provide your
+color values
+
+## Implement the scheme manager
+
+After defining the color schemes, you can implement the actual scheme manager.
+The manager will read the `schemes.json` file and provide QML bindings to switch
+between schemes during runtime.
+
+To implement the scheme manager, create a Python-QML plugin that exposes the
+`SchemeManager` object to QML. This object will have methods to load the color
+schemes from the `schemes.json` file and switch between them.
+
+Create a new Python file called `schememanager.py` in your project directory. In
+this file, define the **SchemeManager** class:
+
+```{literalinclude} scheme_manager.py
+---
+language: python
+caption: true
+linenos: true
+start-at: "QML_IMPORT_NAME"
+end-at: "class SchemeManager"
+---
+```
+
+To integrate smoothly into the already existing code, attach the SchemeManager
+to the same QML module that's already present with
+`QML_IMPORT_NAME = "FileSystemModule"`. Additionally, use the`@QmlNamedElement`
+decorator to smoothly transition to using the custom plugin instead of the
+`Colors.qml` file. With these changes, we can avoid editing all previous
+assignments like:
+
+```QML
+import FileSystemModule
+...
+Rectangle {
+    color: Colors.background
+}
+```
+
+The constructor reads the `schemes.json` file once upon application start and
+then calls the `setTheme` member function.
+
+```{literalinclude} scheme_manager.py
+---
+language: python
+caption: true
+linenos: true
+lines: 18-24
+---
+```
+
+By adding the `SchemeManager` as a callable QML element named **Colors** to the
+FileSystemModule, the class is now accessible in the code without the need to
+import it each time or edit previous assignments. This, in turn, will streamline
+the workflow.
+
+After defining the schemes in the JSON format and making the `SchemeManager`
+class a callable element from QML under the name **Colors**, there are two
+remaining steps to fully integrate the new scheme manager in the example.
+
+The **first step** is to create a function in the `SchemeManager` class that
+loads a color scheme from the JSON file. The **second step** is to make the
+individual colors available in QML with the *same name* as used before with the
+syntax `Colors.<previousName>` as assignable properties.
+
+
+```{literalinclude} scheme_manager.py
+---
+language: python
+caption: true
+linenos: true
+lines: 26-31
+---
+```
+
+The `setScheme` method is responsible for switching between color schemes. To
+make this method accessible in QML, use the `@Slot(str)` decorator and specify
+that it takes a string as its input parameter. In this method, we populate a
+dictionary with the color values from the JSON file.
+
+> Note: For simplicity reasons no other error checking is performed.
+> You would probably want to validate the keys contained in the json.
+
+```{literalinclude} scheme_manager.py
+---
+language: python
+caption: true
+linenos: true
+start-at: "@Property(QColor"
+end-at: "return"
+---
+```
+
+To make the color property assignable in QML, use the `@Property` decorator.
+We simply return the corresponding color value from the dictionary for each
+property. This process is repeated for all other colors that are used in the
+application.
+At this point the application should start with the colors provided by the
+active scheme in the constructor.
+
+## Add the scheme switching to QML
+
+To visualize the current scheme and enable interactive scheme switching, start
+by adding a new entry to the `Sidebar.qml` file.
+
+```{literalinclude} FileSystemModule/qml/Sidebar.qml
+---
+language: QML
+caption: true
+linenos: true
+lines: 99-105
+---
+```
+
+To update the main content area of the application to display the `ColorScheme`,
+the logic that checks the active index from the Sidebar buttons needs to be
+modified. The necessary changes will be made to the Main.qml file:
+
+```{literalinclude} FileSystemModule/Main.qml
+---
+language: QML
+caption: true
+linenos: true
+lines: 170-187
+---
+```
+
+In addition, change the behavior of the application so that there are two
+`StackLayouts`: one for the resizable navigation and one for the main content
+area where we display our color scheme switching functionality. These changes
+will also be made to the Main.qml file.
+
+```{literalinclude} FileSystemModule/Main.qml
+---
+language: QML
+caption: true
+linenos: true
+lines: 147-150
+---
+```
+
+To complete our implementation, the `ColorScheme.qml` file needs to be created.
+The implementation is straightforward and follows the same principles as in the
+original example. If anything is unclear, please refer to the documentation
+provided there. To display all colors and scheme names, use a `Repeater`. The
+model for the Repeater is provided by our `scheme_manager.py`file as a
+`QStringList`.
+
+```{literalinclude} FileSystemModule/qml/ColorScheme.qml
+---
+language: QML
+caption: true
+linenos: true
+lines: 97-111
+---
+```
+
+When examining the code in more detail, you will notice that there are different
+ways to retrieve the models. The `getKeys()` method is defined as a **Slot** and
+therefore requires parentheses when called. On the other hand, the `currentColors`
+model is defined as a **property** and is therefore assigned as a property in QML.
+The reason for this is to receive notifications when the color scheme is switched
+so that the colors displayed in the application can be updated. The keys for the
+color schemes are loaded only once at application startup and do not rely on any
+notifications.
+
+![Extended Explorer GIF](resources/colorscheme.png)
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.pyproject b/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.pyproject
new file mode 100644
index 000000000..77a3969ae
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/extendedexplorer.pyproject
@@ -0,0 +1,31 @@
+{
+ "files": [
+    "main.py",
+    "editormodels.py",
+    "scheme_manager.py",
+    "schemes.json",
+    "FileSystemModule/qmldir",
+    "FileSystemModule/app.qrc",
+    "FileSystemModule/icons.qrc",
+    "FileSystemModule/Main.qml",
+    "FileSystemModule/qml/About.qml",
+    "FileSystemModule/qml/ColorScheme.qml",
+    "FileSystemModule/qml/Editor.qml",
+    "FileSystemModule/qml/FileSystemView.qml",
+    "FileSystemModule/qml/MyMenu.qml",
+    "FileSystemModule/qml/MyMenuBar.qml",
+    "FileSystemModule/qml/ResizeButton.qml",
+    "FileSystemModule/qml/Sidebar.qml",
+    "FileSystemModule/qml/WindowDragHandler.qml",
+    "FileSystemModule/icons/app_icon.svg",
+    "FileSystemModule/icons/folder_closed.svg",
+    "FileSystemModule/icons/folder_open.svg",
+    "FileSystemModule/icons/generic_file.svg",
+    "FileSystemModule/icons/globe.svg",
+    "FileSystemModule/icons/info_sign.svg",
+    "FileSystemModule/icons/light_bulb.svg",
+    "FileSystemModule/icons/qt_logo.svg",
+    "FileSystemModule/icons/read.svg",
+    "FileSystemModule/icons/resize.svg"
+    ]
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/main.py b/sources/pyside6/doc/tutorials/extendedexplorer/main.py
new file mode 100644
index 000000000..f1e6e7d93
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/main.py
@@ -0,0 +1,50 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+"""
+This example shows how to customize Qt Quick Controls by implementing a simple filesystem explorer.
+"""
+
+# Compile both resource files app.qrc and icons.qrc and include them here if you wish
+# to load them from the resource system. Currently, all resources are loaded locally
+# import FileSystemModule.rc_icons
+# import FileSystemModule.rc_app
+
+from scheme_manager import SchemeManager
+from editormodels import FileSystemModel
+import PySide6
+from PySide6.QtGui import QGuiApplication, QIcon
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QCommandLineParser
+
+import sys
+
+if __name__ == '__main__':
+    app = QGuiApplication(sys.argv)
+    app.setOrganizationName("QtProject")
+    app.setApplicationName("File System Explorer")
+    app.setApplicationVersion(PySide6.__version__)
+    app.setWindowIcon(QIcon("FileSystemModule/icons/app_icon.svg"))
+
+    parser = QCommandLineParser()
+    parser.setApplicationDescription("Qt Filesystemexplorer Example")
+    parser.addHelpOption()
+    parser.addVersionOption()
+    parser.addPositionalArgument("", "Initial directory", "[path]")
+    parser.process(app)
+    args = parser.positionalArguments()
+
+    engine = QQmlApplicationEngine()
+    # Include the path of this file to search for the 'qmldir' module
+    engine.addImportPath(sys.path[0])
+
+    engine.loadFromModule("FileSystemModule", "Main")
+
+    if not engine.rootObjects():
+        sys.exit(-1)
+
+    if (len(args) == 1):
+        fsm = engine.singletonInstance("FileSystemModule", "FileSystemModel")
+        fsm.setInitialDirectory(args[0])
+
+    sys.exit(app.exec())
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/resources/Colors.qml b/sources/pyside6/doc/tutorials/extendedexplorer/resources/Colors.qml
new file mode 100644
index 000000000..280f89286
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/resources/Colors.qml
@@ -0,0 +1,22 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+pragma Singleton
+import QtQuick
+
+QtObject {
+    readonly property color background: "#23272E"
+    readonly property color surface1: "#1E2227"
+    readonly property color surface2: "#090A0C"
+    readonly property color text: "#ABB2BF"
+    readonly property color textFile: "#C5CAD3"
+    readonly property color disabledText: "#454D5F"
+    readonly property color selection: "#2C313A"
+    readonly property color active: "#23272E"
+    readonly property color inactive: "#3E4452"
+    readonly property color folder: "#3D4451"
+    readonly property color icon: "#3D4451"
+    readonly property color iconIndicator: "#E5C07B"
+    readonly property color color1: "#E06B74"
+    readonly property color color2: "#62AEEF"
+}
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/resources/colorscheme.png b/sources/pyside6/doc/tutorials/extendedexplorer/resources/colorscheme.png
new file mode 100644
index 000000000..410538ca3
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/resources/colorscheme.png
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.gif b/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.gif
new file mode 100644
index 000000000..9e59f64aa
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.gif
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.webp b/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.webp
new file mode 100644
index 000000000..79a14f34c
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/resources/extendedexplorer.webp
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/scheme_manager.py b/sources/pyside6/doc/tutorials/extendedexplorer/scheme_manager.py
new file mode 100644
index 000000000..8d732093c
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/scheme_manager.py
@@ -0,0 +1,97 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import json
+from pathlib import Path
+from PySide6.QtCore import Slot, QObject, Property, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtQml import QmlNamedElement, QmlSingleton
+
+QML_IMPORT_NAME = "FileSystemModule"
+QML_IMPORT_MAJOR_VERSION = 1
+
+
+@QmlNamedElement("Colors")
+@QmlSingleton
+class SchemeManager(QObject):
+
+    schemeChanged = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        with open(Path(__file__).parent / "schemes.json", 'r') as f:
+            self.m_schemes = json.load(f)
+        self.m_activeScheme = {}
+        self.m_activeSchemeName = "Catppuccin"
+        self.setScheme(self.m_activeSchemeName)
+
+    @Slot(str)
+    def setScheme(self, theme):
+        for k, v in self.m_schemes[theme].items():
+            self.m_activeScheme[k] = QColor.fromString(v)
+        self.m_activeSchemeName = theme
+        self.schemeChanged.emit()
+
+    @Slot(result='QStringList')
+    def getKeys(self):
+        return self.m_schemes.keys()
+
+    @Property('QStringList', notify=schemeChanged)
+    def currentColors(self):
+        return self.m_schemes[self.m_activeSchemeName].values()
+
+    @Property(QColor, notify=schemeChanged)
+    def background(self):
+        return self.m_activeScheme["background"]
+
+    @Property(QColor, notify=schemeChanged)
+    def surface1(self):
+        return self.m_activeScheme["surface1"]
+
+    @Property(QColor, notify=schemeChanged)
+    def surface2(self):
+        return self.m_activeScheme["surface2"]
+
+    @Property(QColor, notify=schemeChanged)
+    def text(self):
+        return self.m_activeScheme["text"]
+
+    @Property(QColor, notify=schemeChanged)
+    def textFile(self):
+        return self.m_activeScheme["textFile"]
+
+    @Property(QColor, notify=schemeChanged)
+    def disabledText(self):
+        return self.m_activeScheme["disabledText"]
+
+    @Property(QColor, notify=schemeChanged)
+    def selection(self):
+        return self.m_activeScheme["selection"]
+
+    @Property(QColor, notify=schemeChanged)
+    def active(self):
+        return self.m_activeScheme["active"]
+
+    @Property(QColor, notify=schemeChanged)
+    def inactive(self):
+        return self.m_activeScheme["inactive"]
+
+    @Property(QColor, notify=schemeChanged)
+    def folder(self):
+        return self.m_activeScheme["folder"]
+
+    @Property(QColor, notify=schemeChanged)
+    def icon(self):
+        return self.m_activeScheme["icon"]
+
+    @Property(QColor, notify=schemeChanged)
+    def iconIndicator(self):
+        return self.m_activeScheme["iconIndicator"]
+
+    @Property(QColor, notify=schemeChanged)
+    def color1(self):
+        return self.m_activeScheme["color1"]
+
+    @Property(QColor, notify=schemeChanged)
+    def color2(self):
+        return self.m_activeScheme["color2"]
diff --git a/sources/pyside6/doc/tutorials/extendedexplorer/schemes.json b/sources/pyside6/doc/tutorials/extendedexplorer/schemes.json
new file mode 100644
index 000000000..e4f2d8c81
--- /dev/null
+++ b/sources/pyside6/doc/tutorials/extendedexplorer/schemes.json
@@ -0,0 +1,82 @@
+{
+  "Catppuccin": {
+    "background": "#1E1E2E",
+    "surface1": "#181825",
+    "surface2": "#11111B",
+    "text": "#CDD6F4",
+    "textFile": "#CDD6F4",
+    "disabledText": "#363659",
+    "selection": "#45475A",
+    "active": "#1E1E2E",
+    "inactive": "#6C7086",
+    "folder": "#6C7086",
+    "icon": "#6C7086",
+    "iconIndicator": "#FFCC66",
+    "color1": "#CBA6F7",
+    "color2": "#89DCEB"
+  },
+  "Nordic": {
+    "background": "#2E3440",
+    "surface1": "#2B2F3A",
+    "surface2": "#262A35",
+    "text": "#D8DEE9",
+    "textFile": "#D8DEE9",
+    "disabledText": "#4D556A",
+    "selection": "#495468",
+    "active": "#2E3440",
+    "inactive": "#555B6A",
+    "folder": "#495468",
+    "icon": "#495468",
+    "iconIndicator": "#FFC40D",
+    "color1": "#81B6C6",
+    "color2": "#5E81AC"
+  },
+  "One Dark": {
+    "background": "#23272E",
+    "surface1": "#1E2227",
+    "surface2": "#090A0C",
+    "text": "#ABB2BF",
+    "textFile": "#C5CAD3",
+    "disabledText": "#2B303B",
+    "selection": "#2C313A",
+    "active": "#23272E",
+    "inactive": "#3E4452",
+    "folder": "#3D4451",
+    "icon": "#3D4451",
+    "iconIndicator": "#E5C07B",
+    "color1": "#E06B74",
+    "color2": "#62AEEF"
+  },
+  "Gruvbox": {
+    "background": "#292828",
+    "surface1": "#171819",
+    "surface2": "#090A0C",
+    "text": "#D4BE98",
+    "textFile": "#E1D2B7",
+    "disabledText": "#2C313A",
+    "selection": "#333130",
+    "active": "#292828",
+    "inactive": "#383737",
+    "folder": "#383737",
+    "icon": "#383737",
+    "iconIndicator": "#FFCC66",
+    "color1": "#A7B464",
+    "color2": "#D3869B"
+  },
+  "Solarized": {
+    "background": "#FDF6E3",
+    "surface1": "#EEE8D5",
+    "surface2": "#DDD6C1",
+    "text": "#6D6D6D",
+    "textFile": "#333333",
+    "disabledText": "#ADADAD",
+    "selection": "#D1CBB8",
+    "active": "#FDF6E3",
+    "inactive": "#8C8364",
+    "folder": "#5F5944",
+    "icon": "#5F5944",
+    "iconIndicator": "#002B36",
+    "color1": "#B58900",
+    "color2": "#6B9E75"
+  }
+}
diff --git a/sources/pyside6/doc/tutorials/index.rst b/sources/pyside6/doc/tutorials/index.rst
index 3c835cf5a..8a69a3c6f 100644
--- a/sources/pyside6/doc/tutorials/index.rst
+++ b/sources/pyside6/doc/tutorials/index.rst
@@ -15,86 +15,78 @@ If you want to see the available widgets in action, you can check the
 `Qt Widget Gallery <https://doc.qt.io/qt-6/gallery.html>`_ to learn their
 names and how they look like.
 
-.. panels::
-    :container: container-lg pb-1
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center
-
-    :img-top: basictutorial/widgets.png
-
-    .. link-button:: basictutorial/widgets
-        :type: ref
-        :text: Your First QtWidgets Application
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: basictutorial/clickablebutton.png
-
-    .. link-button:: basictutorial/clickablebutton
-        :type: ref
-        :text: Using a Simple Button
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: basictutorial/signals_slots.png
-
-    .. link-button:: basictutorial/signals_and_slots
-        :type: ref
-        :text: Signals and Slots
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: basictutorial/dialog.png
-
-    .. link-button:: basictutorial/dialog
-        :type: ref
-        :text: Creating a Dialog Application
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: basictutorial/tablewidget.png
-
-    .. link-button:: basictutorial/tablewidget
-        :type: ref
-        :text: Displaying Data Using a Table Widget
-        :classes: btn-link btn-block stretched-link
-
-    ---
-    :img-top: basictutorial/treewidget.png
-
-    .. link-button:: basictutorial/treewidget
-        :type: ref
-        :text: Displaying Data Using a Tree Widget
-        :classes: btn-link btn-block stretched-link
-
-    ---
-    :img-top: basictutorial/uifiles.png
-
-    .. link-button:: basictutorial/uifiles
-        :type: ref
-        :text: Using .ui files from Designer or QtCreator with QUiLoader and pyside6-uic
-        :classes: btn-link btn-block stretched-link
-
-    ---
-    :img-top: basictutorial/player-new.png
-
-    .. link-button:: basictutorial/qrcfiles
-        :type: ref
-        :text: Using .qrc Files (pyside6-rcc)
-        :classes: btn-link btn-block stretched-link
-
-    ---
-    :img-top: basictutorial/translations.png
-
-    .. link-button:: basictutorial/translations
-        :type: ref
-        :text: Translating Applications
-        :classes: btn-link btn-block stretched-link
-
-    ---
-    :img-top: basictutorial/widgetstyling-yes.png
-
-    .. link-button:: basictutorial/widgetstyling
-        :type: ref
-        :text: Styling the Widgets Application
-        :classes: btn-link btn-block stretched-link
+.. grid:: 1 3 3 3
+    :gutter: 2
 
+    .. grid-item-card:: Basic Widget
+        :class-item: cover-img
+        :link: basictutorial/widgets.html
+        :img-top: basictutorial/widgets.png
+
+        Your first QtWidgets Application
+
+    .. grid-item-card:: Basic Button
+        :class-item: cover-img
+        :link: basictutorial/clickablebutton.html
+        :img-top: basictutorial/clickablebutton.png
+
+        Using a Simple Button
+
+    .. grid-item-card:: Basic Connections
+        :class-item: cover-img
+        :link: basictutorial/signals_and_slots.html
+        :img-top: basictutorial/signals_slots.png
+
+        Signals and Slots
+
+    .. grid-item-card:: Basic Dialog
+        :class-item: cover-img
+        :link: basictutorial/dialog.html
+        :img-top: basictutorial/dialog.png
+
+        Creating a Dialog Application
+
+    .. grid-item-card:: Basic Table
+        :class-item: cover-img
+        :link: basictutorial/tablewidget.html
+        :img-top: basictutorial/tablewidget.png
+
+        Displaying Data Using a Table Widget
+
+    .. grid-item-card:: Basic Tree
+        :class-item: cover-img
+        :link: basictutorial/treewidget.html
+        :img-top: basictutorial/treewidget.png
+
+        Displaying Data Using a Tree Widget
+
+    .. grid-item-card:: Basic ``ui`` files
+        :class-item: cover-img
+        :link: basictutorial/uifiles.html
+        :img-top: basictutorial/uifiles.png
+
+        Using .ui files from Designer or QtCreator with QUiLoader and pyside6-uic
+
+    .. grid-item-card:: Basic ``qrc`` files
+        :class-item: cover-img
+        :link: basictutorial/qrcfiles.html
+        :img-top: basictutorial/player-new.png
+
+        Using .qrc Files (pyside6-rcc)
+
+    .. grid-item-card:: Basic Translations
+        :class-item: cover-img
+        :link: basictutorial/translations.html
+        :img-top: basictutorial/translations.png
+
+        Translating Applications
+
+    .. grid-item-card:: Basic Widget Style
+        :class-item: cover-img
+        :link: basictutorial/widgetstyling.html
+        :img-top: basictutorial/widgetstyling-yes.png
+
+        Styling the Widgets Application
 
 .. toctree::
     :hidden:
@@ -114,39 +106,43 @@ names and how they look like.
 Quick/QML: Basic tutorials
 --------------------------
 
-.. panels::
-    :container: container-lg pb-1
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center
+.. grid:: 1 3 3 3
+    :gutter: 2
+
+    .. grid-item-card:: Basic Quick
+        :class-item: cover-img
+        :link: basictutorial/qml.html
+        :img-top: basictutorial/greenapplication.png
+
+        Your First QtQuick/QML Application
 
-    :img-top: basictutorial/greenapplication.png
+    .. grid-item-card:: Basic QML Integration
+        :class-item: cover-img
+        :link: qmlintegration/qmlintegration.html
+        :img-top: qmlintegration/textproperties_material.png
 
-    .. link-button:: basictutorial/qml
-        :type: ref
-        :text: Your First QtQuick/QML Application
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: qmlintegration/textproperties_material.png
+        Python-QML integration
 
-    .. link-button:: qmlintegration/qmlintegration
-        :type: ref
-        :text: Python-QML integration
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: qmlapp/qmlapplication.png
+    .. grid-item-card:: QML Application
+        :class-item: cover-img
+        :link: qmlapp/qmlapplication.html
+        :img-top: qmlapp/qmlapplication.png
 
-    .. link-button:: qmlapp/qmlapplication
-        :type: ref
-        :text: QML Application Tutorial (QtCreator)
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: qmlsqlintegration/example_list_view.png
+        QML Application Tutorial (QtCreator)
 
-    .. link-button:: qmlsqlintegration/qmlsqlintegration
-        :type: ref
-        :text: QML, SQL and PySide Integration Tutorial
-        :classes: btn-link btn-block stretched-link
+    .. grid-item-card:: Advanced QML Integration
+        :class-item: cover-img
+        :link: qmlsqlintegration/qmlsqlintegration.html
+        :img-top: qmlsqlintegration/example_list_view.png
 
+        QML, SQL and PySide Integration Tutorial
+
+    .. grid-item-card:: Extended Explorer
+        :class-item: cover-img
+        :link: extendedexplorer/extendedexplorer.html
+        :img-top: extendedexplorer/resources/extendedexplorer.webp
+
+        Extending an Qt Quick Controls example
 
 .. toctree::
     :maxdepth: 1
@@ -156,28 +152,27 @@ Quick/QML: Basic tutorials
     qmlintegration/qmlintegration.rst
     qmlapp/qmlapplication.rst
     qmlsqlintegration/qmlsqlintegration.rst
+    extendedexplorer/extendedexplorer.md
 
 General Applications
 --------------------
 
-.. panels::
-    :container: container-lg pb-1
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    :img-top: datavisualize/images/datavisualization_app.png
+    .. grid-item-card:: Data Visualization
+        :class-item: cover-img
+        :link: datavisualize/index.html
+        :img-top: datavisualize/images/datavisualization_app.png
 
-    .. link-button:: datavisualize/index
-        :type: ref
-        :text: Data Visualization Tool
-        :classes: btn-link btn-block stretched-link
-    ---
-    :img-top: expenses/expenses_tool.png
+        Data Visualization Tool
 
-    .. link-button:: expenses/expenses
-        :type: ref
-        :text: Expenses Tool
-        :classes: btn-link btn-block stretched-link
+    .. grid-item-card:: Expenses Application
+        :class-item: cover-img
+        :link: expenses/expenses.html
+        :img-top: expenses/expenses_tool.png
+
+        Expenses administration tool
 
 .. toctree::
     :hidden:
@@ -185,6 +180,13 @@ General Applications
     datavisualize/index.rst
     expenses/expenses.rst
 
+Qt Overviews
+------------
+
+.. toctree::
+    :maxdepth: 1
+
+    ../overviews/overviews-main.rst
 
 C++ and Python
 --------------
@@ -200,4 +202,5 @@ Debug a PySide6 Application
     :maxdepth: 1
 
     debugging/mixed_debugging.rst
+    debugging/qml_debugging.rst
 
diff --git a/sources/pyside6/doc/tutorials/portingguide/chapter1/chapter1.rst b/sources/pyside6/doc/tutorials/portingguide/chapter1/chapter1.rst
index 2a3bd7079..87fb97660 100644
--- a/sources/pyside6/doc/tutorials/portingguide/chapter1/chapter1.rst
+++ b/sources/pyside6/doc/tutorials/portingguide/chapter1/chapter1.rst
@@ -26,7 +26,7 @@ the tables. Port these helper functions first. Here is how
 the C++ and Python versions of these functions look like:
 
 C++ version
-------------
+-----------
 
 .. literalinclude:: initdb.h
    :language: c++
@@ -34,7 +34,7 @@ C++ version
    :lines: 9-33
 
 Python version
----------------
+--------------
 
 .. literalinclude:: createdb.py
    :language: python
@@ -45,16 +45,16 @@ Now that the helper functions are in place, port ``initDb``.
 Here is how the C++ and Python versions of this function
 looks like:
 
-C++ version
-------------
+C++ version (initDb)
+--------------------
 
 .. literalinclude:: initdb.h
    :language: c++
    :linenos:
    :lines: 35-112
 
-Python version
----------------
+Python version (init_db)
+------------------------
 
 .. literalinclude:: createdb.py
    :language: python
@@ -77,7 +77,7 @@ test it, add the following code to ``main.py`` and run it:
 
 Use the following command from the prompt to run:
 
-.. code-block::
+.. code-block:: bash
 
     python main.py
 
diff --git a/sources/pyside6/doc/tutorials/portingguide/chapter2/chapter2.rst b/sources/pyside6/doc/tutorials/portingguide/chapter2/chapter2.rst
index fa6ef1116..83ba3357b 100644
--- a/sources/pyside6/doc/tutorials/portingguide/chapter2/chapter2.rst
+++ b/sources/pyside6/doc/tutorials/portingguide/chapter2/chapter2.rst
@@ -47,16 +47,16 @@ For example, painting stars to represent the rating for
 each book in the table. Here is how the reimplemented
 code looks like:
 
-C++ version
-------------
+C++ version (bookdelegate)
+--------------------------
 
 .. literalinclude:: bookdelegate.cpp
    :language: c++
    :linenos:
    :lines: 22-
 
-Python version
----------------
+Python version (bookdelegate)
+-----------------------------
 
 .. literalinclude:: bookdelegate.py
    :language: python
diff --git a/sources/pyside6/doc/tutorials/portingguide/chapter3/chapter3.rst b/sources/pyside6/doc/tutorials/portingguide/chapter3/chapter3.rst
index 1d48d4ea3..98d4d3982 100644
--- a/sources/pyside6/doc/tutorials/portingguide/chapter3/chapter3.rst
+++ b/sources/pyside6/doc/tutorials/portingguide/chapter3/chapter3.rst
@@ -21,9 +21,9 @@ and add the following imports to it:
 To generate this Python code, run the following command on the
 prompt:
 
-.. code-block::
+.. code-block:: bash
 
-   pyside6-uic bookwindow.ui > ui_bookwindow.py
+    pyside6-uic bookwindow.ui -o ui_bookwindow.py
 
 Try porting the remaining code now. To begin with, here is
 how both the versions of the constructor code looks:
@@ -101,9 +101,9 @@ image only.
 Now, run the ``pyside6-rcc`` tool on the ``books.qrc`` file
 to generate ``rc_books.py``.
 
-.. code-block::
+.. code-block:: bash
 
-   pyside6-rcc books.qrc > rc_books.py
+    pyside6-rcc books.qrc -o rc_books.py
 
 Once you have the Python script generated, make the
 following changes to ``bookdelegate.py`` and ``main.py``:
diff --git a/sources/pyside6/doc/tutorials/portingguide/index.rst b/sources/pyside6/doc/tutorials/portingguide/index.rst
index dc84b0c05..0b89c2ff8 100644
--- a/sources/pyside6/doc/tutorials/portingguide/index.rst
+++ b/sources/pyside6/doc/tutorials/portingguide/index.rst
@@ -63,7 +63,7 @@ C++ vs Python
       doStuff(key, value)
 
 In this example, ``func()`` would treat ``var`` as a local
-name without the ``global`` statement.  This would lead to
+name without the ``global`` statement. This would lead to
 a ``NameError`` in the ``value is None`` handling, on
 accessing ``var``. For more information about this, see
 `Python refernce documentation <python refdoc>`_.
diff --git a/sources/pyside6/doc/tutorials/qmlapp/qmlapplication.rst b/sources/pyside6/doc/tutorials/qmlapp/qmlapplication.rst
index b68a3686e..c6d72e742 100644
--- a/sources/pyside6/doc/tutorials/qmlapp/qmlapplication.rst
+++ b/sources/pyside6/doc/tutorials/qmlapp/qmlapplication.rst
@@ -15,15 +15,15 @@ defined in the QML file.
 Before you begin, install the following prerequisites:
 
 * The `PySide6 <https://pypi.org/project/PySide6/>`_ Python packages.
-* Qt Creator v4.9 beta1 or later from
+* *Qt Creator* from
   `https://download.qt.io
-  <https://download.qt.io/snapshots/qtcreator/4.9/4.9.0-beta1/>`_.
+  <https://download.qt.io/snapshots/qtcreator/>`_.
 
 
 The following step-by-step instructions guide you through application
-development process using Qt Creator:
+development process using *Qt Creator*:
 
-#. Open Qt Creator and select **File > New File or Project..** menu item
+#. Open *Qt Creator* and select **File > New File or Project..** menu item
    to open following dialog:
 
    .. image:: newpyproject.png
diff --git a/sources/pyside6/doc/tutorials/qmlintegration/qmlintegration.rst b/sources/pyside6/doc/tutorials/qmlintegration/qmlintegration.rst
index d9de42ee2..ff6fe3e31 100644
--- a/sources/pyside6/doc/tutorials/qmlintegration/qmlintegration.rst
+++ b/sources/pyside6/doc/tutorials/qmlintegration/qmlintegration.rst
@@ -2,17 +2,17 @@ Python-QML integration
 ======================
 
 This tutorial provides a quick walk-through of a python application that loads, and interacts with
-a QML file.  QML is a declarative language that lets you design UIs faster than a traditional
-language, such as C++.  The QtQml and QtQuick modules provides the necessary infrastructure for
+a QML file. QML is a declarative language that lets you design UIs faster than a traditional
+language, such as C++. The QtQml and QtQuick modules provides the necessary infrastructure for
 QML-based UIs.
 
 In this tutorial, you will learn how to integrate Python with a QML application.
 This mechanism will help us to understand how to use Python as a backend for certain
-signals from the UI elements in the QML interface.  Additionally, you will learn how to provide
+signals from the UI elements in the QML interface. Additionally, you will learn how to provide
 a modern look to your QML application using one of the features from Qt Quick Controls 2.
 
 The tutorial is based on an application that allow you to set many text properties, like increasing
-the font size, changing the color, changing the style, and so on.  Before you begin, install the
+the font size, changing the color, changing the style, and so on. Before you begin, install the
 `PySide6 <https://pypi.org/project/PySide6/>`_ Python packages.
 
 The following step-by-step process will guide you through the key elements of the QML based
@@ -35,7 +35,7 @@ application and PySide6 integration:
    Notice that we only need a :code:`QQmlApplicationEngine` to
    :code:`load` the QML file.
 
-#. Define the `Bridge` class, containing all the logic for the element
+#. Define the ``Bridge`` class, containing all the logic for the element
    that will be register in QML:
 
    .. literalinclude:: main.py
@@ -48,7 +48,7 @@ application and PySide6 integration:
    class and the variables :code:`QML_IMPORT_NAME` and
    :code:`QML_IMPORT_MAJOR_VERSION`.
 
-#. Now, go back to the QML file and connect the signals to the slots defined in the `Bridge` class:
+#. Now, go back to the QML file and connect the signals to the slots defined in the ``Bridge`` class:
 
    .. code:: js
 
@@ -68,7 +68,7 @@ application and PySide6 integration:
 
    The properties *Italic*, *Bold*, and *Underline* are mutually
    exclusive, this means only one can be active at any time.
-   To achieve  this each time we select one of these options, we
+   To achieve this each time we select one of these options, we
    check the three properties via the QML element property as you can
    see in the above snippet.
    Only one of the three will return *True*, while the other two
@@ -95,22 +95,22 @@ application and PySide6 integration:
 
 #. Now, for changing the look of our application, you have two options:
 
-   1. Use the command line: execute the python file adding the option, `--style`::
+   1. Use the command line: execute the python file adding the option, ``--style``::
 
        python main.py --style material
 
-   2. Use a `qtquickcontrols2.conf` file:
+   2. Use a ``qtquickcontrols2.conf`` file:
 
       .. literalinclude:: qtquickcontrols2.conf
          :linenos:
 
-      Then add it to your `.qrc` file:
+      Then add it to your ``.qrc`` file:
 
       .. literalinclude:: style.qrc
          :linenos:
 
-      Generate the *rc* file running, `pyside6-rcc style.qrc > style_rc.py`
-      And finally import it from your `main.py` script.
+      Generate the *rc* file running, ``pyside6-rcc style.qrc -o style_rc.py``
+      And finally import it from your ``main.py`` script.
 
    .. literalinclude:: main.py
       :linenos:
diff --git a/sources/pyside6/doc/tutorials/qmlsqlintegration/qmlsqlintegration.rst b/sources/pyside6/doc/tutorials/qmlsqlintegration/qmlsqlintegration.rst
index 4c0131f32..eee3f807e 100644
--- a/sources/pyside6/doc/tutorials/qmlsqlintegration/qmlsqlintegration.rst
+++ b/sources/pyside6/doc/tutorials/qmlsqlintegration/qmlsqlintegration.rst
@@ -14,9 +14,9 @@ name of our table, and define the global function ``createTable()`` that creates
 doesn't already exist.
 The database contains a single line to mock the beginning of a conversation.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 3-42
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 4-43
 
 The ``SqlConversationModel`` class offers the read-only data model required for the non-editable
 contacts list. It derives from the :ref:`QSqlQueryModel` class, which is the logical choice for
@@ -26,25 +26,25 @@ Then, we proceed to create the table, set its name to the one defined previously
 We add the necessary attributes to the table, to have a program that reflects the idea
 of a chat application.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 46-58
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 47-59
 
 In ``setRecipient()``, you set a filter over the returned results from the database, and
 emit a signal every time the recipient of the message changes.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 60-69
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 61-70
 
 The ``data()`` function falls back to ``QSqlTableModel``'s implementation if the role is not a
 custom user role.
 If you get a user role, we can subtract :meth:`~.QtCore.Qt.UserRole` from it to get the index of
 that field, and then use that index to find the value to be returned.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 71-78
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 72-79
 
 
 In ``roleNames()``, we return a Python dictionary with our custom role and role names as key-values
@@ -53,27 +53,27 @@ Alternatively, it can be useful to declare an Enum to hold all of the role value
 Note that ``names`` has to be a hash to be used as a dictionary key,
 and that's why we're using the ``hash`` function.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 80-94
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 81-95
 
 The ``send_message()`` function uses the given recipient and message to insert a new record into
 the database.
 Using :meth:`~.QSqlTableModel.OnManualSubmit` requires you to also call ``submitAll()``,
 since all the changes will be cached in the model until you do so.
 
-   .. literalinclude:: sqlDialog.py
-      :linenos:
-      :lines: 96-115
+.. literalinclude:: sqlDialog.py
+   :linenos:
+   :lines: 97-116
 
 chat.qml
 --------
 
 Let's look at the ``chat.qml`` file.
 
-   .. literalinclude:: chat.qml
-      :linenos:
-      :lines: 3-5
+.. literalinclude:: chat.qml
+   :linenos:
+   :lines: 4-6
 
 First, import the Qt Quick module.
 This gives us access to graphical primitives such as Item, Rectangle, Text, and so on.
@@ -86,9 +86,9 @@ root type, Window:
 
 Let's step through the ``chat.qml`` file.
 
-   .. literalinclude:: chat.qml
-      :linenos:
-      :lines: 8-13
+.. literalinclude:: chat.qml
+   :linenos:
+   :lines: 9-14
 
 ``ApplicationWindow`` is a Window with some added convenience for creating a header and a footer.
 It also provides the foundation for popups and supports some basic styling, such as the background
@@ -101,9 +101,9 @@ Once we've set these, we have a properly sized, empty window ready to be filled
 Because we are exposing the :code:`SqlConversationModel` class to QML, we will
 declare a component to access it:
 
-     .. literalinclude:: chat.qml
-        :linenos:
-        :lines: 15-17
+.. literalinclude:: chat.qml
+   :linenos:
+   :lines: 16-18
 
 There are two ways of laying out items in QML: `Item Positioners`_ and `Qt Quick Layouts`_.
 
@@ -113,13 +113,13 @@ There are two ways of laying out items in QML: `Item Positioners`_ and `Qt Quick
   resizable user interfaces.
   Below, we use `ColumnLayout`_ to vertically lay out a `ListView`_ and a `Pane`_.
 
-     .. literalinclude:: chat.qml
-        :linenos:
-        :lines: 19-22
+  .. literalinclude:: chat.qml
+     :linenos:
+     :lines: 20-23
 
-     .. literalinclude:: chat.qml
-        :linenos:
-        :lines: 71-73
+  .. literalinclude:: chat.qml
+     :linenos:
+     :lines: 72-74
 
 Pane is basically a rectangle whose color comes from the application's style.
 It's similar to `Frame`_, but it has no stroke around its border.
@@ -144,18 +144,16 @@ remaining space that is left after accommodating the Pane.
 .. _attached properties: https://doc.qt.io/qt-5/qml-qtquick-layouts-layout.html
 .. _Layout.fillWidth: https://doc.qt.io/qt-5/qml-qtquick-layouts-layout.html#fillWidth-attached-prop
 .. _Layout.fillHeight: https://doc.qt.io/qt-5/qml-qtquick-layouts-layout.html#fillHeight-attached-prop
-.. _ListView: https://doc.qt.io/qt-5/qml-qtquick-listview.html
 .. _Qt Quick QML Types: https://doc.qt.io/qt-5/qtquick-qmlmodule.html
 
 Let's look at the ``Listview`` in detail:
 
-   .. literalinclude:: chat.qml
-      :linenos:
-      :lines: 22-69
+.. literalinclude:: chat.qml
+   :linenos:
+   :lines: 23-70
 
 After filling the ``width`` and ``height`` of its parent, we also set some margins on the view.
 
-
 Next, we set `displayMarginBeginning`_ and `displayMarginEnd`_.
 These properties ensure that the delegates outside the view don't disappear when you
 scroll at the edges of the view.
@@ -179,9 +177,9 @@ At the bottom of the screen, we place a `TextArea`_ item to allow multi-line tex
 button to send the message.
 We use Pane to cover the area under these two items:
 
-   .. literalinclude:: chat.qml
-      :linenos:
-      :lines: 71-95
+.. literalinclude:: chat.qml
+   :linenos:
+   :lines: 72-96
 
 The `TextArea`_ should fill the available width of the screen.
 We assign some placeholder text to provide a visual cue to the contact as to where they should begin
@@ -203,16 +201,16 @@ main.py
 We use ``logging`` instead of Python's ``print()``, because it provides a better way to control the
 messages levels that our application will generate (errors, warnings, and information messages).
 
-   .. literalinclude:: main.py
-      :linenos:
-      :lines: 3-15
+.. literalinclude:: main.py
+   :linenos:
+   :lines: 4-16
 
 ``connectToDatabase()`` creates a connection with the SQLite database, creating the actual file
 if it doesn't already exist.
 
-   .. literalinclude:: main.py
-      :linenos:
-      :lines: 18-38
+.. literalinclude:: main.py
+   :linenos:
+   :lines: 19-39
 
 A few interesting things happen in the ``main`` function:
 
@@ -227,8 +225,8 @@ A few interesting things happen in the ``main`` function:
 
 Finally, the Qt application runs, and your program starts.
 
-   .. literalinclude:: main.py
-      :linenos:
-      :lines: 41-51
+.. literalinclude:: main.py
+   :linenos:
+   :lines: 42-52
 
 .. image:: example_list_view.png
diff --git a/sources/pyside6/doc/videos.rst b/sources/pyside6/doc/videos.rst
index bd2ee60af..919c9ff38 100644
--- a/sources/pyside6/doc/videos.rst
+++ b/sources/pyside6/doc/videos.rst
@@ -6,205 +6,150 @@ Videos
 Tutorials
 ---------
 
-.. panels::
-    :body: align-items-center justify-content-center text-center
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center img-responsive card-img-top-main
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    Resources overview
-    ^^^^^^^^^^^^^^^^^^
-    .. raw:: html
+    .. grid-item-card:: Resources overview
+        :img-top: https://img.youtube.com/vi/sywLvidNkbw/mqdefault.jpg
+        :link: https://www.youtube.com/embed/sywLvidNkbw
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/sywLvidNkbw" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
-    ---
+    .. grid-item-card:: Repository overview
+        :img-top: https://img.youtube.com/vi/RP0K1B7fqMs/mqdefault.jpg
+        :link: https://www.youtube.com/embed/RP0K1B7fqMs
 
-    Repository overview
-    ^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: Shiboken overview
+        :img-top: https://img.youtube.com/vi/RUwV_sx_gBM/mqdefault.jpg
+        :link: https://www.youtube.com/embed/RUwV_sx_gBM
 
-    .. raw:: html
+    .. grid-item-card:: Tutorial
+        :img-top: https://img.youtube.com/vi/Cqo0-EQmy1Q/mqdefault.jpg
+        :link: https://www.youtube.com/embed/Cqo0-EQmy1Q
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/RP0K1B7fqMs" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
-    ---
+        How to create a simple Qt Widgets app with PySide6
 
-    Shiboken overview
-    ^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: Tutorial
+        :img-top: https://img.youtube.com/vi/JxfiUx60Mbg/mqdefault.jpg
+        :link: https://www.youtube.com/embed/JxfiUx60Mbg
 
-    .. raw:: html
+        Making a QML Application in Python
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/RUwV_sx_gBM" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+    .. grid-item-card:: Tutorial
+        :img-top: https://img.youtube.com/vi/i-utZN_NP6c/mqdefault.jpg
+        :link: https://www.youtube.com/embed/i-utZN_NP6c
 
-Community events
-----------------
+        How to install PySide6 on a new virtual environment
 
-.. panels::
-    :body: align-items-center justify-content-center text-center
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center img-responsive card-img-top-main
 
-    Akademy 2021: Qt for Python
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Community events
+----------------
 
-    .. raw:: html
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/Ftm68AzYvr8" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+    .. grid-item-card:: Akademy 2021
+        :img-top: https://img.youtube.com/vi/Ftm68AzYvr8/mqdefault.jpg
+        :link: https://www.youtube.com/embed/Ftm68AzYvr8
 
+        Qt for Python
 
 Webinars
 --------
 
-.. panels::
-    :body: align-items-center justify-content-center text-center
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center img-responsive card-img-top-main
-
-    How your Python projects can benefit from Qt
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    .. raw:: html
-
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/eqHveQ5JTZU" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
-
-    ---
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    Interoperability of Python and C++ using Shiboken
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: Online Webinar
+        :img-top: https://img.youtube.com/vi/eqHveQ5JTZU/mqdefault.jpg
+        :link: https://www.youtube.com/embed/eqHveQ5JTZU
 
-    .. raw:: html
+        How your Python projects can benefit from Qt
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/wOMlDutOWXI" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+    .. grid-item-card:: Online Webinar
+        :img-top: https://img.youtube.com/vi/wOMlDutOWXI/mqdefault.jpg
+        :link: https://www.youtube.com/embed/wOMlDutOWXI
 
-    ---
+        Interoperability of Python and C++ using Shiboken
 
-    Developing your first Qt for Python application
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    .. grid-item-card:: Online Webinar
+        :img-top: https://img.youtube.com/vi/HDBjmSiOBxY/mqdefault.jpg
+        :link: https://www.youtube.com/embed/HDBjmSiOBxY
 
-    .. raw:: html
+        Developing your first Qt for Python application
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/HDBjmSiOBxY" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+    .. grid-item-card:: Online Webinar
+        :img-top: https://img.youtube.com/vi/wKqLaNqxgas/mqdefault.jpg
+        :link: https://www.youtube.com/embed/wKqLaNqxgas
 
-    ---
-
-    Creating user interfaces with Qt for Python
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    .. raw:: html
-
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/wKqLaNqxgas" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Creating user interfaces with Qt for Python
 
 Conferences
 -----------
 
-.. panels::
-    :body: align-items-center justify-content-center text-center
-    :container: container-lg pb-3
-    :column: col-lg-4 col-md-4 col-sm-6 col-xs-12 p-2
-    :img-top-cls: d-flex align-self-center img-responsive card-img-top-main
-
-    Boosting Projects with Python
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    .. raw:: html
-
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/SylgpRc-Lrg" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
-
-    ---
-
-    Prototypes to Hybrid Applications
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. grid:: 1 3 3 3
+    :gutter: 2
 
-    .. raw:: html
+    .. grid-item-card:: PyConES 2023
+        :img-top: https://img.youtube.com/vi/XuqdTvisqkQ/mqdefault.jpg
+        :link: https://www.youtube.com/embed/XuqdTvisqkQ
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/Vb1dbLQafyM" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Asynchronous programming with asyncio and Qt
 
-    ---
+    .. grid-item-card:: QtWS 2022
+        :img-top: https://img.youtube.com/vi/8wcdN1Iw1Uk/mqdefault.jpg
+        :link: https://www.youtube.com/embed/8wcdN1Iw1Uk
 
-    Using Shiboken to Enhance Application
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        5 Reasons Why You Should Use the Latest Qt for Python
 
-    .. raw:: html
+    .. grid-item-card:: QtDeCon 2022
+        :img-top: https://img.youtube.com/vi/ZUNg19OlDeE/mqdefault.jpg
+        :link: https://www.youtube.com/embed/ZUNg19OlDeE
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/mAfEVPgHRt8" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Hybrid Qt Development: Boosting Your Projects with Python
 
-    ---
+    .. grid-item-card:: QtWS 2021
+        :img-top: https://img.youtube.com/vi/SylgpRc-Lrg/mqdefault.jpg
+        :link: https://www.youtube.com/embed/SylgpRc-Lrg
 
-    Intro to Qt for Python
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Hybrid Qt Development: boosting Projects with Python
 
-    .. raw:: html
+    .. grid-item-card:: QtWS 2020
+        :img-top: https://img.youtube.com/vi/Vb1dbLQafyM/mqdefault.jpg
+        :link: https://www.youtube.com/embed/Vb1dbLQafyM
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/214TWASZVgA" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Prototypes to Hybrid Applications
 
-    ---
+    .. grid-item-card:: QtWS 2019
+        :img-top: https://img.youtube.com/vi/mAfEVPgHRt8/mqdefault.jpg
+        :link: https://www.youtube.com/embed/mAfEVPgHRt8
 
-    Using C++ project in Python
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        Using Shiboken to Enhance Application
 
-    .. raw:: html
+    .. grid-item-card:: QtWS 2019
+        :img-top: https://img.youtube.com/vi/214TWASZVgA/mqdefault.jpg
+        :link: https://www.youtube.com/embed/214TWASZVgA
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/XmY-tWTi9gY" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Intro to Qt for Python
 
-    ---
+    .. grid-item-card:: QtWS 2019
+        :img-top: https://img.youtube.com/vi/XmY-tWTi9gY/mqdefault.jpg
+        :link: https://www.youtube.com/embed/XmY-tWTi9gY
 
-    Qt for Python in 20 min
-    ^^^^^^^^^^^^^^^^^^^^^^^
+        Using C++ project in Python
 
-    .. raw:: html
+    .. grid-item-card:: QtWS 2019
+        :img-top: https://img.youtube.com/vi/rRDoToEOlbY/mqdefault.jpg
+        :link: https://www.youtube.com/embed/rRDoToEOlbY
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/IhxZ99usPqY" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        Using Qt for Python for embedded system development
 
-    ---
+    .. grid-item-card:: QtWS 2018
+        :img-top: https://img.youtube.com/vi/IhxZ99usPqY/mqdefault.jpg
+        :link: https://www.youtube.com/embed/IhxZ99usPqY
 
-    A walk to PySide
-    ^^^^^^^^^^^^^^^^
+        Qt for Python in 20 min
 
-    .. raw:: html
+    .. grid-item-card:: QtWS 2017
+        :img-top: https://img.youtube.com/vi/Sb4FV6SdHHQ/mqdefault.jpg
+        :link: https://www.youtube.com/embed/Sb4FV6SdHHQ
 
-      <div class='embed-container'>
-        <iframe width="175" height="195" src="https://www.youtube.com/embed/Sb4FV6SdHHQ" frameborder="0" allowfullscreen>
-        </iframe>
-      </div>
+        A walk to PySide
diff --git a/sources/pyside6/libpyside/CMakeLists.txt b/sources/pyside6/libpyside/CMakeLists.txt
index e5f163996..ebfe123dd 100644
--- a/sources/pyside6/libpyside/CMakeLists.txt
+++ b/sources/pyside6/libpyside/CMakeLists.txt
@@ -1,7 +1,48 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(libpyside)
 
 set(libpyside_libraries Qt::Core Qt::CorePrivate)
 
+set(CMAKE_AUTOMOC ON)
+
+set(libpyside_HEADERS # installed below
+    class_property.h
+    dynamicqmetaobject.h
+    feature_select.h
+    globalreceiverv2.h
+    pysideclassdecorator_p.h
+    pysideclassinfo.h
+    pysideclassinfo_p.h
+    pysidecleanup.h
+    pyside.h
+    pysideinit.h
+    pysidelogging_p.h
+    pysidemacros.h
+    pysidemetafunction.h
+    pysidemetafunction_p.h
+    pysidemetatype.h
+    pyside_numpy.h
+    pyside_p.h
+    pysideproperty.h
+    pysideproperty_p.h
+    pysideqapp.h
+    pysideqenum.h
+    pysideqhash.h
+    pysideqmetatype.h
+    pysideqobject.h
+    pysideqslotobject_p.h
+    pysidesignal.h
+    pysidesignal_p.h
+    pysideslot_p.h
+    pysidestaticstrings.h
+    pysideutils.h
+    pysideweakref.h
+    qobjectconnect.h
+    signalmanager.h
+)
+
 set(libpyside_SRC
     class_property.cpp
     dynamicqmetaobject.cpp
@@ -11,16 +52,17 @@ set(libpyside_SRC
     pysideclassdecorator.cpp
     pysideclassinfo.cpp
     pysideqenum.cpp
+    pysideqslotobject_p.cpp
     pysidemetafunction.cpp
     pysidesignal.cpp
     pysideslot.cpp
     pysideproperty.cpp
-    pysideqflags.cpp
     pysideweakref.cpp
     pyside.cpp
     pyside_numpy.cpp
     pysidestaticstrings.cpp
     qobjectconnect.cpp
+    ${libpyside_HEADERS}
 )
 
 qt6_add_resources(libpyside_SRC libpyside.qrc)
@@ -58,7 +100,7 @@ target_include_directories(pyside6 PUBLIC
   $<INSTALL_INTERFACE:include/PySide6>
 )
 
-target_compile_definitions(pyside6 PRIVATE -DQT_LEAN_HEADERS=1)
+target_compile_definitions(pyside6 PRIVATE -DQT_LEAN_HEADERS=1 -DQT_NO_KEYWORDS=1)
 
 target_link_libraries(pyside6
                       PRIVATE Shiboken6::libshiboken ${libpyside_libraries})
@@ -82,42 +124,6 @@ endif()
 # install stuff
 #
 
-set(libpyside_HEADERS
-    class_property.h
-    dynamicqmetaobject.h
-    feature_select.h
-    globalreceiverv2.h
-    pysideclassdecorator_p.h
-    pysideclassinfo.h
-    pysideclassinfo_p.h
-    pysidecleanup.h
-    pyside.h
-    pysideinit.h
-    pysidelogging_p.h
-    pysidemacros.h
-    pysidemetafunction.h
-    pysidemetafunction_p.h
-    pysidemetatype.h
-    pyside_numpy.h
-    pyside_p.h
-    pysideproperty.h
-    pysideproperty_p.h
-    pysideqapp.h
-    pysideqenum.h
-    pysideqflags.h
-    pysideqhash.h
-    pysideqmetatype.h
-    pysideqobject.h
-    pysidesignal.h
-    pysidesignal_p.h
-    pysideslot_p.h
-    pysidestaticstrings.h
-    pysideutils.h
-    pysideweakref.h
-    qobjectconnect.h
-    signalmanager.h
-)
-
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(LIBRARY_OUTPUT_SUFFIX ${CMAKE_DEBUG_POSTFIX})
 else()
diff --git a/sources/pyside6/libpyside/class_property.cpp b/sources/pyside6/libpyside/class_property.cpp
index c255ef1e9..2bed97ef5 100644
--- a/sources/pyside6/libpyside/class_property.cpp
+++ b/sources/pyside6/libpyside/class_property.cpp
@@ -5,6 +5,7 @@
 #include "pysidestaticstrings.h"
 #include "feature_select.h"
 
+#include <pep384ext.h>
 #include <shiboken.h>
 #include <sbkstaticstrings.h>
 
@@ -23,14 +24,54 @@ extern "C" {
 // `class_property.__get__()`: Always pass the class instead of the instance.
 static PyObject *PyClassProperty_descr_get(PyObject *self, PyObject * /*ob*/, PyObject *cls)
 {
-    return PyProperty_Type.tp_descr_get(self, cls, cls);
+    return PepExt_Type_GetDescrGetSlot(&PyProperty_Type)(self, cls, cls);
 }
 
 // `class_property.__set__()`: Just like the above `__get__()`.
 static int PyClassProperty_descr_set(PyObject *self, PyObject *obj, PyObject *value)
 {
     PyObject *cls = PyType_Check(obj) ? obj : reinterpret_cast<PyObject *>(Py_TYPE(obj));
-    return PyProperty_Type.tp_descr_set(self, cls, value);
+    return PepExt_Type_GetDescrSetSlot(&PyProperty_Type)(self, cls, value);
+}
+
+// PYSIDE-2230: Why is this metaclass necessary?
+//
+// The problem is that the property object already exists as a Python
+// object. We derive a subclass for class properties, without
+// repeating everything but just by adding something to support
+// the class-ness.
+//
+// But this Python property has as metaclass `type` which is incompatible
+// now with SbkObjectType, which generates physically larger types that
+// are incompatible with properties by using PEP 697.
+// Adding a compatible metaclass that is unrelated to `SbkObjectType`
+// is the correct solution. Re-using `SbkObjectType` was actually an abuse,
+// since Python properties are in no way PySide objects.
+
+static PyTypeObject *createClassPropertyTypeType()
+{
+    PyType_Slot PyClassPropertyType_Type_slots[] = {
+        {Py_tp_base, static_cast<void *>(&PyType_Type)},
+        {Py_tp_alloc, reinterpret_cast<void *>(PyType_GenericAlloc)},
+        {Py_tp_free, reinterpret_cast<void *>(PyObject_GC_Del)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PyClassPropertyType_Type_spec = {
+        "1:Shiboken.ClassPropertyType",
+        0,
+        0, // sizeof(PyMemberDef), not for PyPy without a __len__ defined
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_TYPE_SUBCLASS,
+        PyClassPropertyType_Type_slots,
+    };
+
+    return SbkType_FromSpec(&PyClassPropertyType_Type_spec);
+}
+
+PyTypeObject *PyClassPropertyType_TypeF()
+{
+    static auto *type = createClassPropertyTypeType();
+    return type;
 }
 
 // The property `__doc__` default does not work for class properties
@@ -40,36 +81,38 @@ static int PyClassProperty_tp_init(PyObject *self, PyObject *args, PyObject *kwa
 {
     auto hold = Py_TYPE(self);
     self->ob_type = &PyProperty_Type;
-    auto ret =  PyProperty_Type.tp_init(self, args, kwargs);
+    auto ret = PepExt_Type_GetInitSlot(&PyProperty_Type)(self, args, kwargs);
     self->ob_type = hold;
     return ret;
 }
 
-static PyType_Slot PyClassProperty_slots[] = {
-    {Py_tp_getset,      nullptr},    // will be set below
-    {Py_tp_base,        reinterpret_cast<void *>(&PyProperty_Type)},
-    {Py_tp_descr_get,   reinterpret_cast<void *>(PyClassProperty_descr_get)},
-    {Py_tp_descr_set,   reinterpret_cast<void *>(PyClassProperty_descr_set)},
-    {Py_tp_init,        reinterpret_cast<void *>(PyClassProperty_tp_init)},
-    {0, 0}
-};
-
-static PyType_Spec PyClassProperty_spec = {
-    "2:PySide6.QtCore.PyClassProperty",
-    sizeof(propertyobject),
-    0,
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-    PyClassProperty_slots,
-};
+static PyTypeObject *createPyClassPropertyType()
+{
+    PyType_Slot PyClassProperty_slots[] = {
+        {Py_tp_getset,      reinterpret_cast<void *>(PyProperty_Type.tp_getset)},    // will be set below
+        {Py_tp_base,        reinterpret_cast<void *>(&PyProperty_Type)},
+        {Py_tp_descr_get,   reinterpret_cast<void *>(PyClassProperty_descr_get)},
+        {Py_tp_descr_set,   reinterpret_cast<void *>(PyClassProperty_descr_set)},
+        {Py_tp_init,        reinterpret_cast<void *>(PyClassProperty_tp_init)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PyClassProperty_spec = {
+        "2:PySide6.QtCore.PyClassProperty",
+        sizeof(propertyobject),
+        0,
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        PyClassProperty_slots,
+    };
+
+    if (_PepRuntimeVersion() >= 0x030A00)
+        PyClassProperty_spec.basicsize = sizeof(propertyobject310);
+    return SbkType_FromSpecWithMeta(&PyClassProperty_spec, PyClassPropertyType_TypeF());
+}
 
 PyTypeObject *PyClassProperty_TypeF()
 {
-    static PyTypeObject *type = nullptr;
-    if (type == nullptr) {
-        // Provide the same `tp_getset`, which is not inherited.
-        PyClassProperty_slots[0].pfunc = PyProperty_Type.tp_getset;
-        type = SbkType_FromSpec(&PyClassProperty_spec);
-    }
+    static auto *type = createPyClassPropertyType();
     return type;
 }
 
@@ -96,11 +139,9 @@ static int SbkObjectType_meta_setattro(PyObject *obj, PyObject *name, PyObject *
                                 && !PyObject_IsInstance(value, class_prop);
     if (call_descr_set) {
         // Call `class_property.__set__()` instead of replacing the `class_property`.
-        return Py_TYPE(descr)->tp_descr_set(descr, obj, value);
-    } else {
-        // Replace existing attribute.
-        return PyType_Type.tp_setattro(obj, name, value);
-    }
+        return PepExt_Type_GetDescrSetSlot(Py_TYPE(descr))(descr, obj, value);
+    } // Replace existing attribute.
+    return PepExt_Type_GetSetAttroSlot(&PyType_Type)(obj, name, value);
 }
 
 } // extern "C"
@@ -108,7 +149,7 @@ static int SbkObjectType_meta_setattro(PyObject *obj, PyObject *name, PyObject *
 /*
  * These functions are added to the SbkObjectType_TypeF() dynamically.
  */
-namespace PySide { namespace ClassProperty {
+namespace PySide::ClassProperty {
 
 static const char *PyClassProperty_SignatureStrings[] = {
     "PySide6.QtCore.PyClassProperty(cls,"
@@ -125,7 +166,6 @@ void init(PyObject *module)
 {
     PyTypeObject *type = SbkObjectType_TypeF();
     type->tp_setattro = SbkObjectType_meta_setattro;
-    reinterpret_cast<PyObject *>(type)->ob_type = type;
 
     if (InitSignatureStrings(PyClassProperty_TypeF(), PyClassProperty_SignatureStrings) < 0)
         return;
@@ -135,5 +175,4 @@ void init(PyObject *module)
     PyModule_AddObject(module, "PyClassProperty", classproptype);
 }
 
-} // namespace ClassProperty
-} // namespace PySide
+} // namespace PySide::ClassProperty
diff --git a/sources/pyside6/libpyside/class_property.h b/sources/pyside6/libpyside/class_property.h
index 10378294e..f2ed29f1f 100644
--- a/sources/pyside6/libpyside/class_property.h
+++ b/sources/pyside6/libpyside/class_property.h
@@ -9,25 +9,35 @@
 
 extern "C" {
 
-typedef struct {
+struct propertyobject {
     PyObject_HEAD
     PyObject *prop_get;
     PyObject *prop_set;
     PyObject *prop_del;
     PyObject *prop_doc;
     int getter_doc;
-} propertyobject;
+};
+
+struct propertyobject310 {
+    PyObject_HEAD
+    PyObject *prop_get;
+    PyObject *prop_set;
+    PyObject *prop_del;
+    PyObject *prop_doc;
+    // Note: This is a problem with Limited API: We have no direct access.
+    //       You need to pick it from runtime info.
+    PyObject *prop_name;
+    int getter_doc;
+};
 
 PYSIDE_API PyTypeObject *PyClassProperty_TypeF();
 
 } // extern "C"
 
-namespace PySide {
-namespace ClassProperty {
+namespace PySide::ClassProperty {
 
 PYSIDE_API void init(PyObject *module);
 
-} // namespace ClassProperty
-} // namespace PySide
+} // namespace PySide::ClassProperty
 
 #endif // CLASS_PROPERTY_H
diff --git a/sources/pyside6/libpyside/dynamicqmetaobject.cpp b/sources/pyside6/libpyside/dynamicqmetaobject.cpp
index a3a16b6a0..048001f81 100644
--- a/sources/pyside6/libpyside/dynamicqmetaobject.cpp
+++ b/sources/pyside6/libpyside/dynamicqmetaobject.cpp
@@ -10,6 +10,7 @@
 #include "pysideslot_p.h"
 #include "pysideqenum.h"
 #include "pyside_p.h"
+#include "pysidestaticstrings.h"
 
 #include <shiboken.h>
 
@@ -23,6 +24,8 @@
 #include <cstring>
 #include <vector>
 
+using namespace Qt::StringLiterals;
+
 using namespace PySide;
 
 // MetaObjectBuilder: Provides the QMetaObject's returned by
@@ -50,7 +53,8 @@ public:
                       const QByteArray &signature) const;
     int indexOfProperty(const QByteArray &name) const;
     int addSlot(const QByteArray &signature);
-    int addSlot(const QByteArray &signature, const QByteArray &type);
+    int addSlot(const QByteArray &signature, const QByteArray &type,
+                const QByteArray &tag = {});
     int addSignal(const QByteArray &signature);
     void removeMethod(QMetaMethod::MethodType mtype, int index);
     int getPropertyNotifyId(PySideProperty *property) const;
@@ -181,8 +185,8 @@ int MetaObjectBuilder::indexOfProperty(const QByteArray &name) const
 static bool checkMethodSignature(const QByteArray &signature)
 {
     // Common mistake not to add parentheses to the signature.
-    const int openParen = signature.indexOf('(');
-    const int closingParen = signature.lastIndexOf(')');
+    const auto openParen = signature.indexOf('(');
+    const auto closingParen = signature.lastIndexOf(')');
     const bool ok = openParen != -1 && closingParen != -1 && openParen < closingParen;
     if (!ok) {
          const QByteArray message =
@@ -208,13 +212,17 @@ int MetaObjectBuilder::addSlot(const char *signature)
 }
 
 int MetaObjectBuilderPrivate::addSlot(const QByteArray &signature,
-                                      const QByteArray &type)
+                                      const QByteArray &type,
+                                      const QByteArray &tag)
 {
     if (!checkMethodSignature(signature))
         return -1;
     m_dirty = true;
     QMetaMethodBuilder methodBuilder = ensureBuilder()->addSlot(signature);
-    methodBuilder.setReturnType(type);
+    if (!type.isEmpty() && type != "void"_ba)
+        methodBuilder.setReturnType(type);
+    if (!tag.isEmpty())
+        methodBuilder.setTag(tag);
     return m_baseObject->methodCount() + methodBuilder.index();
 }
 
@@ -581,7 +589,8 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
     // Leave the properties to be registered after signals because they may depend on
     // notify signals.
     for (PyTypeObject *baseType : basesToCheck) {
-        PyObject *attrs = baseType->tp_dict;
+        AutoDecRef tpDict(PepType_GetDict(baseType));
+        PyObject *attrs = tpDict.object();
         PyObject *key = nullptr;
         PyObject *value = nullptr;
         Py_ssize_t pos = 0;
@@ -600,51 +609,40 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
                         //     Signal(..., arguments=['...', ...]
                         // the arguments are now on data-data->signalArguments
                         auto builder = m_builder->addSignal(sig);
-                        if (data->signalArguments && !data->signalArguments->isEmpty())
-                            builder.setParameterNames(*data->signalArguments);
+                        if (!data->signalArguments.isEmpty())
+                            builder.setParameterNames(data->signalArguments);
                     }
                 }
             }
         }
     }
 
-    AutoDecRef slotAttrName(String::fromCString(PYSIDE_SLOT_LIST_ATTR));
+    PyObject *slotAttrName = PySide::PySideMagicName::slot_list_attr();
     // PYSIDE-315: Now take care of the rest.
     // Signals and slots should be separated, unless the types are modified, later.
     // We check for this using "is_sorted()". Sorting no longer happens at all.
     for (PyTypeObject *baseType : basesToCheck) {
-        PyObject *attrs = baseType->tp_dict;
+        AutoDecRef tpDict(PepType_GetDict(baseType));
+        PyObject *attrs = tpDict.object();
         PyObject *key = nullptr;
         PyObject *value = nullptr;
         Py_ssize_t pos = 0;
 
         while (PyDict_Next(attrs, &pos, &key, &value)) {
             if (Property::checkType(value)) {
-                const int index = m_baseObject->indexOfProperty(String::toCString(key));
+                const QByteArray name = String::toCString(key);
+                const int index = m_baseObject->indexOfProperty(name);
                 if (index == -1)
-                    addProperty(String::toCString(key), value);
-            } else if (Py_TYPE(value)->tp_call != nullptr) {
+                    addProperty(name, value);
+            } else if (PepType_GetSlot(Py_TYPE(value), Py_tp_call) != nullptr) {
                 // PYSIDE-198: PyFunction_Check does not work with Nuitka.
                 // Register slots.
                 if (PyObject_HasAttr(value, slotAttrName)) {
-                    PyObject *signatureList = PyObject_GetAttr(value, slotAttrName);
-                    for (Py_ssize_t i = 0, i_max = PyList_Size(signatureList); i < i_max; ++i) {
-                        PyObject *pySignature = PyList_GET_ITEM(signatureList, i);
-                        QByteArray signature(String::toCString(pySignature));
-                        // Split the slot type and its signature.
-                        QByteArray type;
-                        const int spacePos = signature.indexOf(' ');
-                        if (spacePos != -1) {
-                            type = signature.left(spacePos);
-                            signature.remove(0, spacePos + 1);
-                        }
-                        const int index = m_baseObject->indexOfSlot(signature);
-                        if (index == -1) {
-                            if (type.isEmpty() || type == "void")
-                                addSlot(signature);
-                            else
-                                addSlot(signature, type);
-                        }
+                    auto *capsule = PyObject_GetAttr(value, slotAttrName);
+                    const auto *entryList = PySide::Slot::dataListFromCapsule(capsule);
+                    for (const auto &e : *entryList) {
+                        if (m_baseObject->indexOfSlot(e.signature) == -1)
+                            addSlot(e.signature, e.resultType, e.tag);
                     }
                 }
             }
@@ -662,7 +660,7 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
         AutoDecRef items(PyMapping_Items(members));
         Py_ssize_t nr_items = PySequence_Length(items);
 
-        QList<QPair<QByteArray, int> > entries;
+        QList<std::pair<QByteArray, int> > entries;
         for (Py_ssize_t idx = 0; idx < nr_items; ++idx) {
             AutoDecRef item(PySequence_GetItem(items, idx));
             AutoDecRef key(PySequence_GetItem(item, 0));
@@ -670,8 +668,7 @@ void MetaObjectBuilderPrivate::parsePythonType(PyTypeObject *type)
             AutoDecRef value(PyObject_GetAttr(member, Shiboken::PyName::value()));
             auto ckey = String::toCString(key);
             auto ivalue = PyLong_AsSsize_t(value);
-            auto thing = QPair<QByteArray, int>(ckey, int(ivalue));
-            entries.push_back(thing);
+            entries.push_back(std::make_pair(ckey, int(ivalue)));
         }
         addEnumerator(name, isFlag, true, entries);
     }
diff --git a/sources/pyside6/libpyside/dynamicqmetaobject.h b/sources/pyside6/libpyside/dynamicqmetaobject.h
index 311c545f5..dd33f65f7 100644
--- a/sources/pyside6/libpyside/dynamicqmetaobject.h
+++ b/sources/pyside6/libpyside/dynamicqmetaobject.h
@@ -10,6 +10,8 @@
 #include <QtCore/QMetaObject>
 #include <QtCore/QMetaMethod>
 
+#include <utility>
+
 class MetaObjectBuilderPrivate;
 
 namespace PySide
@@ -17,9 +19,9 @@ namespace PySide
 
 class MetaObjectBuilder
 {
-    Q_DISABLE_COPY(MetaObjectBuilder)
+    Q_DISABLE_COPY_MOVE(MetaObjectBuilder)
 public:
-    using EnumValue = QPair<QByteArray, int>;
+    using EnumValue = std::pair<QByteArray, int>;
     using EnumValues = QList<EnumValue>;
 
     MetaObjectBuilder(const char *className, const QMetaObject *metaObject);
diff --git a/sources/pyside6/libpyside/feature_select.cpp b/sources/pyside6/libpyside/feature_select.cpp
index c12869777..cfd465267 100644
--- a/sources/pyside6/libpyside/feature_select.cpp
+++ b/sources/pyside6/libpyside/feature_select.cpp
@@ -89,11 +89,11 @@ This is everything that the following code does.
 *****************************************************************************/
 
 
-namespace PySide { namespace Feature {
+namespace PySide::Feature {
 
 using namespace Shiboken;
 
-typedef bool(*FeatureProc)(PyTypeObject *type, PyObject *prev_dict, int id);
+using FeatureProc = bool(*)(PyTypeObject *type, PyObject *prev_dict, int id);
 
 static FeatureProc *featurePointer = nullptr;
 
@@ -107,7 +107,7 @@ createDerivedDictType()
     PyObject *ChameleonDict = PepRun_GetResult(R"CPP(if True:
 
         class ChameleonDict(dict):
-            __slots__ = ("dict_ring", "select_id")
+            __slots__ = ("dict_ring", "select_id", "orig_dict")
 
         result = ChameleonDict
 
@@ -129,18 +129,18 @@ static void ensureNewDictType()
 static inline PyObject *nextInCircle(PyObject *dict)
 {
     // returns a borrowed ref
-    AutoDecRef next_dict(PyObject_GetAttr(dict, PyName::dict_ring()));
+    AutoDecRef next_dict(PyObject_GetAttr(dict, PySideName::dict_ring()));
     return next_dict;
 }
 
 static inline void setNextDict(PyObject *dict, PyObject *next_dict)
 {
-    PyObject_SetAttr(dict, PyName::dict_ring(), next_dict);
+    PyObject_SetAttr(dict, PySideName::dict_ring(), next_dict);
 }
 
 static inline void setSelectId(PyObject *dict, int select_id)
 {
-    PyObject_SetAttr(dict, PyName::select_id(), PyLong_FromLong(select_id));
+    PyObject_SetAttr(dict, PySideName::select_id(), PyLong_FromLong(select_id));
 }
 
 static inline int getSelectId(PyObject *dict)
@@ -162,7 +162,7 @@ static bool replaceClassDict(PyTypeObject *type)
      * This is mandatory for all type dicts when they are touched.
      */
     ensureNewDictType();
-    auto *dict = type->tp_dict;
+    AutoDecRef dict(PepType_GetDict(type));
     auto *ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
     auto *new_dict = PyObject_CallObject(ob_ndt, nullptr);
     if (new_dict == nullptr || PyDict_Update(new_dict, dict) < 0)
@@ -172,9 +172,9 @@ static bool replaceClassDict(PyTypeObject *type)
     // insert the dict into itself as ring
     setNextDict(new_dict, new_dict);
     // We have now an exact copy of the dict with a new type.
-    // Replace `__dict__` which usually has refcount 1 (but see cyclic_test.py)
-    Py_DECREF(type->tp_dict);
-    type->tp_dict = new_dict;
+    PepType_SetDict(type, new_dict);
+    // PYSIDE-2404: Retain the original dict for easy late init.
+    PyObject_SetAttr(new_dict, PySideName::orig_dict(), dict);
     return true;
 }
 
@@ -184,7 +184,8 @@ static bool addNewDict(PyTypeObject *type, int select_id)
      * Add a new dict to the ring and set it as `type->tp_dict`.
      * A 'false' return is fatal.
      */
-    auto *dict = type->tp_dict;
+    AutoDecRef dict(PepType_GetDict(type));
+    AutoDecRef orig_dict(PyObject_GetAttr(dict, PySideName::orig_dict()));
     auto *ob_ndt = reinterpret_cast<PyObject *>(new_dict_type);
     auto *new_dict = PyObject_CallObject(ob_ndt, nullptr);
     if (new_dict == nullptr)
@@ -194,7 +195,9 @@ static bool addNewDict(PyTypeObject *type, int select_id)
     auto next_dict = nextInCircle(dict);
     setNextDict(dict, new_dict);
     setNextDict(new_dict, next_dict);
-    type->tp_dict = new_dict;
+    PepType_SetDict(type, new_dict);
+    // PYSIDE-2404: Retain the original dict for easy late init.
+    PyObject_SetAttr(new_dict, PySideName::orig_dict(), orig_dict);
     return true;
 }
 
@@ -204,18 +207,19 @@ static inline bool moveToFeatureSet(PyTypeObject *type, int select_id)
      * Rotate the ring to the given `select_id` and return `true`.
      * If not found, stay at the current position and return `false`.
      */
-    auto *initial_dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *initial_dict = tpDict.object();
     auto *dict = initial_dict;
     do {
         int current_id = getSelectId(dict);
         // This works because small numbers are singleton objects.
         if (current_id == select_id) {
-            type->tp_dict = dict;
+            PepType_SetDict(type, dict);
             return true;
         }
         dict = nextInCircle(dict);
     } while (dict != initial_dict);
-    type->tp_dict = initial_dict;
+    PepType_SetDict(type, initial_dict);
     return false;
 }
 
@@ -234,8 +238,7 @@ static bool createNewFeatureSet(PyTypeObject *type, int select_id)
     Q_UNUSED(ok);
     assert(ok);
 
-    AutoDecRef prev_dict(type->tp_dict);
-    Py_INCREF(prev_dict);   // keep the first ref unchanged
+    AutoDecRef prev_dict(PepType_GetDict(type));
     if (!addNewDict(type, select_id))
         return false;
     int id = select_id;
@@ -245,13 +248,14 @@ static bool createNewFeatureSet(PyTypeObject *type, int select_id)
     for (int idx = id; *proc != nullptr; ++proc, idx >>= 1) {
         if (idx & 1) {
             // clear the tp_dict that will get new content
-            PyDict_Clear(type->tp_dict);
+            AutoDecRef tpDict(PepType_GetDict(type));
+            PyDict_Clear(tpDict);
             // let the proc re-fill the tp_dict
             if (!(*proc)(type, prev_dict, id))
                 return false;
             // if there is still a step, prepare `prev_dict`
             if (idx >> 1) {
-                prev_dict.reset(PyDict_Copy(type->tp_dict));
+                prev_dict.reset(PyDict_Copy(tpDict.object()));
                 if (prev_dict.isNull())
                     return false;
             }
@@ -266,7 +270,9 @@ static inline void SelectFeatureSetSubtype(PyTypeObject *type, int select_id)
      * This is the selector for one sublass. We need to call this for
      * every subclass until no more subclasses or reaching the wanted id.
      */
-    if (Py_TYPE(type->tp_dict) == Py_TYPE(PyType_Type.tp_dict)) {
+    static const auto *pyTypeType_tp_dict = PepType_GetDict(&PyType_Type);
+    AutoDecRef tpDict(PepType_GetDict(type));
+    if (Py_TYPE(tpDict.object()) == Py_TYPE(pyTypeType_tp_dict)) {
         // On first touch, we initialize the dynamic naming.
         // The dict type will be replaced after the first call.
         if (!replaceClassDict(type)) {
@@ -320,7 +326,9 @@ static inline void SelectFeatureSet(PyTypeObject *type)
      * Generated functions call this directly.
      * Shiboken will assign it via a public hook of `basewrapper.cpp`.
      */
-    if (Py_TYPE(type->tp_dict) == Py_TYPE(PyType_Type.tp_dict)) {
+    static const auto *pyTypeType_tp_dict = PepType_GetDict(&PyType_Type);
+    AutoDecRef tpDict(PepType_GetDict(type));
+    if (Py_TYPE(tpDict.object()) == Py_TYPE(pyTypeType_tp_dict)) {
         // We initialize the dynamic features by using our own dict type.
         if (!replaceClassDict(type)) {
             Py_FatalError("failed to replace class dict!");
@@ -388,12 +396,18 @@ static FeatureProc featureProcArray[] = {
 static bool patch_property_impl();
 static bool is_initialized = false;
 
+static void featureEnableCallback(bool enable)
+{
+    featurePointer = enable ? featureProcArray : nullptr;
+}
+
 void init()
 {
     // This function can be called multiple times.
     if (!is_initialized) {
         featurePointer = featureProcArray;
         initSelectableFeature(SelectFeatureSet);
+        setSelectableFeatureCallback(featureEnableCallback);
         patch_property_impl();
         is_initialized = true;
     }
@@ -454,7 +468,8 @@ static PyObject *methodWithNewName(PyTypeObject *type,
 static bool feature_01_addLowerNames(PyTypeObject *type, PyObject *prev_dict, int /* id */)
 {
     PyMethodDef *meth = type->tp_methods;
-    PyObject *lower_dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    PyObject *lower_dict = tpDict.object();
 
     // PYSIDE-1702: A user-defined class in Python has no internal method list.
     //              We are not going to change anything.
@@ -501,12 +516,12 @@ static bool feature_01_addLowerNames(PyTypeObject *type, PyObject *prev_dict, in
 // This is the Python 2 version for inspection of m_ml, only.
 // The actual Python 3 version is larget.
 
-typedef struct {
+struct PyCFunctionObject {
     PyObject_HEAD
     PyMethodDef *m_ml; /* Description of the C function to call */
     PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
     PyObject    *m_module; /* The __module__ attribute, can be anything */
-} PyCFunctionObject;
+};
 
 static PyObject *modifyStaticToClassMethod(PyTypeObject *type, PyObject *sm)
 {
@@ -585,7 +600,7 @@ PyObject *adjustPropertyName(PyObject *dict, PyObject *name)
             if (PyList_CheckExact(sig)) {
                 name_clash = true;
             } else {
-                Shiboken::AutoDecRef params(PyObject_GetAttr(sig, PyName::parameters()));
+                Shiboken::AutoDecRef params(PyObject_GetAttr(sig, PySideName::parameters()));
                 // Are there parameters except self or cls?
                 if (PyObject_Size(params.object()) > 1)
                     name_clash = true;
@@ -611,9 +626,9 @@ static QByteArrayList GetPropertyStringsMro(PyTypeObject *type)
     auto res = QByteArrayList();
 
     PyObject *mro = type->tp_mro;
-    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
     // We leave 'Shiboken.Object' and 'object' alone, therefore "n - 2".
-    for (idx = 0; idx < n - 2; idx++) {
+    for (Py_ssize_t idx = 0; idx < n - 2; idx++) {
         auto *subType = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
         auto props = SbkObjectType_GetPropertyStrings(subType);
         if (props != nullptr)
@@ -630,7 +645,8 @@ static bool feature_02_true_property(PyTypeObject *type, PyObject *prev_dict, in
      */
 
     PyMethodDef *meth = type->tp_methods;
-    PyObject *prop_dict = type->tp_dict;
+    AutoDecRef tpDict(PepType_GetDict(type));
+    PyObject *prop_dict = tpDict.object();
 
     // The empty `tp_dict` gets populated by the previous dict.
     if (PyDict_Update(prop_dict, prev_dict) < 0)
@@ -744,11 +760,11 @@ static bool patch_property_impl()
     // Turn `__doc__` into a computed attribute without changing writability.
     auto gsp = property_getset;
     auto *type = &PyProperty_Type;
-    auto *dict = type->tp_dict;
+    AutoDecRef dict(PepType_GetDict(type));
     AutoDecRef descr(PyDescr_NewGetSet(type, gsp));
     if (descr.isNull())
         return false;
-    if (PyDict_SetItemString(dict, gsp->name, descr) < 0)
+    if (PyDict_SetItemString(dict.object(), gsp->name, descr) < 0)
         return false;
     return true;
 }
@@ -763,7 +779,8 @@ static bool patch_property_impl()
 #define SIMILAR_FEATURE(xx)  \
 static bool feature_##xx##_addDummyNames(PyTypeObject *type, PyObject *prev_dict, int /* id */) \
 { \
-    PyObject *dict = type->tp_dict; \
+    AutoDecRef tpDict(PepType_GetDict(type)); \
+    PyObject *dict = tpDict.object(); \
     if (PyDict_Update(dict, prev_dict) < 0) \
         return false; \
     if (PyDict_SetItemString(dict, "fake_feature_" #xx, Py_None) < 0) \
@@ -778,5 +795,4 @@ SIMILAR_FEATURE(20)
 SIMILAR_FEATURE(40)
 SIMILAR_FEATURE(80)
 
-} // namespace PySide
-} // namespace Feature
+} // namespace PySide::Feature
diff --git a/sources/pyside6/libpyside/feature_select.h b/sources/pyside6/libpyside/feature_select.h
index af8f2c324..bf5a1b56b 100644
--- a/sources/pyside6/libpyside/feature_select.h
+++ b/sources/pyside6/libpyside/feature_select.h
@@ -7,15 +7,13 @@
 #include "pysidemacros.h"
 #include <sbkpython.h>
 
-namespace PySide {
-namespace Feature {
+namespace PySide::Feature {
 
 PYSIDE_API void init();
 PYSIDE_API void Select(PyObject *obj);
 PYSIDE_API void Select(PyTypeObject *type);
 PYSIDE_API void Enable(bool);
 
-} // namespace Feature
-} // namespace PySide
+} // namespace PySide::Feature
 
 #endif // FEATURE_SELECT_H
diff --git a/sources/pyside6/libpyside/globalreceiverv2.cpp b/sources/pyside6/libpyside/globalreceiverv2.cpp
index c843a40ac..2c75e39e1 100644
--- a/sources/pyside6/libpyside/globalreceiverv2.cpp
+++ b/sources/pyside6/libpyside/globalreceiverv2.cpp
@@ -9,35 +9,23 @@
 
 #include <autodecref.h>
 #include <gilstate.h>
+#include <pep384ext.h>
 
-#include <QtCore/qhashfunctions.h>
 #include <QtCore/QMetaMethod>
 #include <QtCore/QSet>
+#include <QtCore/QDebug>
 
 #include <cstring>
 
 #define RECEIVER_DESTROYED_SLOT_NAME "__receiverDestroyed__(QObject*)"
 
-namespace
-{
-    static int DESTROY_SIGNAL_ID = 0;
-    static int DESTROY_SLOT_ID = 0;
-}
 
 namespace PySide
 {
 
-size_t qHash(const GlobalReceiverKey &k, size_t seed)
-{
-    QtPrivate::QHashCombine hash;
-    seed = hash(seed, k.object);
-    seed = hash(seed, k.method);
-    return seed;
-}
-
 class DynamicSlotDataV2
 {
-    Q_DISABLE_COPY(DynamicSlotDataV2)
+    Q_DISABLE_COPY_MOVE(DynamicSlotDataV2)
     public:
         DynamicSlotDataV2(PyObject *callback, GlobalReceiverV2 *parent);
         ~DynamicSlotDataV2();
@@ -51,6 +39,8 @@ class DynamicSlotDataV2
         static void onCallbackDestroyed(void *data);
         static GlobalReceiverKey key(PyObject *callback);
 
+        void formatDebug(QDebug &debug) const;
+
     private:
         bool m_isMethod;
         PyObject *m_callback;
@@ -61,6 +51,32 @@ class DynamicSlotDataV2
         GlobalReceiverV2 *m_parent;
 };
 
+void DynamicSlotDataV2::formatDebug(QDebug &debug) const
+{
+    debug << "method=" << m_isMethod << ", m_callback=" << m_callback;
+    if (m_callback != nullptr)
+        debug << '/' << Py_TYPE(m_callback)->tp_name;
+    debug << ", self=" << m_pythonSelf;
+    if (m_pythonSelf != nullptr)
+        debug << '/' << Py_TYPE(m_pythonSelf)->tp_name;
+    debug << ", m_pyClass=" << m_pyClass;
+    if (m_pyClass != nullptr)
+        debug << '/' << Py_TYPE(m_pyClass)->tp_name;
+    debug << ", signatures=" << m_signatures.keys();
+}
+
+QDebug operator<<(QDebug debug, const DynamicSlotDataV2 *d)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "DynamicSlotDataV2(";
+    if (d)
+        d->formatDebug(debug);
+    else
+        debug << '0';
+    debug << ')';
+    return debug;
 }
 
 using namespace PySide;
@@ -83,10 +99,10 @@ DynamicSlotDataV2::DynamicSlotDataV2(PyObject *callback, GlobalReceiverV2 *paren
         // PYSIDE-1523: PyMethod_Check is not accepting compiled form, we just go by attributes.
         m_isMethod = true;
 
-        m_callback = PyObject_GetAttr(callback, PySide::PyName::im_func());
+        m_callback = PyObject_GetAttr(callback, PySide::PySideName::im_func());
         Py_DECREF(m_callback);
 
-        m_pythonSelf = PyObject_GetAttr(callback, PySide::PyName::im_self());
+        m_pythonSelf = PyObject_GetAttr(callback, PySide::PySideName::im_self());
         Py_DECREF(m_pythonSelf);
 
         //monitor class from method lifetime
@@ -107,8 +123,8 @@ GlobalReceiverKey DynamicSlotDataV2::key(PyObject *callback)
         return {PyMethod_GET_SELF(callback), PyMethod_GET_FUNCTION(callback)};
     } else if (PySide::isCompiledMethod(callback)) {
         // PYSIDE-1589: Fix for slots in compiled functions
-        Shiboken::AutoDecRef self(PyObject_GetAttr(callback, PySide::PyName::im_self()));
-        Shiboken::AutoDecRef func(PyObject_GetAttr(callback, PySide::PyName::im_func()));
+        Shiboken::AutoDecRef self(PyObject_GetAttr(callback, PySide::PySideName::im_self()));
+        Shiboken::AutoDecRef func(PyObject_GetAttr(callback, PySide::PySideName::im_func()));
         return {self, func};
     }
     return {nullptr, callback};
@@ -120,7 +136,7 @@ PyObject *DynamicSlotDataV2::callback()
 
     //create a callback based on method data
     if (m_isMethod)
-        callback = Py_TYPE(m_callback)->tp_descr_get(m_callback, m_pythonSelf, nullptr);
+        callback = PepExt_Type_CallDescrGet(m_callback, m_pythonSelf, nullptr);
     else
         Py_INCREF(callback);
 
@@ -146,7 +162,7 @@ void DynamicSlotDataV2::onCallbackDestroyed(void *data)
     auto self = reinterpret_cast<DynamicSlotDataV2 *>(data);
     self->m_weakRef = nullptr;
     Py_BEGIN_ALLOW_THREADS
-    delete self->m_parent;
+    SignalManager::instance().deleteGlobalReceiver(self->m_parent);
     Py_END_ALLOW_THREADS
 }
 
@@ -160,31 +176,20 @@ DynamicSlotDataV2::~DynamicSlotDataV2()
     Py_DECREF(m_callback);
 }
 
-GlobalReceiverV2::GlobalReceiverV2(PyObject *callback, GlobalReceiverV2MapPtr map) :
+const char *GlobalReceiverV2::senderDynamicProperty = "_q_pyside_sender";
+
+GlobalReceiverV2::GlobalReceiverV2(PyObject *callback, QObject *receiver) :
     QObject(nullptr),
     m_metaObject("__GlobalReceiver__", &QObject::staticMetaObject),
-    m_sharedMap(std::move(map))
+    m_receiver(receiver)
 {
     m_data = new DynamicSlotDataV2(callback, this);
-    m_metaObject.addSlot(RECEIVER_DESTROYED_SLOT_NAME);
-    m_metaObject.update();
-    m_refs.append(nullptr);
-
-
-    if (DESTROY_SIGNAL_ID == 0)
-        DESTROY_SIGNAL_ID = QObject::staticMetaObject.indexOfSignal("destroyed(QObject*)");
-
-    if (DESTROY_SLOT_ID == 0)
-        DESTROY_SLOT_ID = m_metaObject.indexOfMethod(QMetaMethod::Slot, RECEIVER_DESTROYED_SLOT_NAME);
-
-
 }
 
 GlobalReceiverV2::~GlobalReceiverV2()
 {
     m_refs.clear();
     // Remove itself from map.
-    m_sharedMap->remove(m_data->key());
     // Suppress handling of destroyed() for objects whose last reference is contained inside
     // the callback object that will now be deleted. The reference could be a default argument,
     // a callback local variable, etc.
@@ -193,7 +198,7 @@ GlobalReceiverV2::~GlobalReceiverV2()
     // leading to the object being deleted, which emits destroyed(), which would try to invoke
     // the already deleted callback, and also try to delete the object again.
     DynamicSlotDataV2 *data = m_data;
-    m_data = Q_NULLPTR;
+    m_data = nullptr;
     delete data;
 }
 
@@ -204,69 +209,34 @@ int GlobalReceiverV2::addSlot(const char *signature)
 
 void GlobalReceiverV2::incRef(const QObject *link)
 {
-    if (link) {
-        if (!m_refs.contains(link)) {
-            bool connected{};
-            Py_BEGIN_ALLOW_THREADS
-            connected = QMetaObject::connect(link, DESTROY_SIGNAL_ID, this, DESTROY_SLOT_ID);
-            Py_END_ALLOW_THREADS
-            if (connected)
-                m_refs.append(link);
-            else
-                Q_ASSERT(false);
-        } else {
-            m_refs.append(link);
-        }
-    } else {
-        m_refs.append(nullptr);
-    }
+    Q_ASSERT(link);
+    m_refs.append(link);
 }
 
 void GlobalReceiverV2::decRef(const QObject *link)
 {
-    if (m_refs.isEmpty())
-        return;
-
-
+    Q_ASSERT(link);
     m_refs.removeOne(link);
-    if (link) {
-        if (!m_refs.contains(link)) {
-            bool result{};
-            Py_BEGIN_ALLOW_THREADS
-            result = QMetaObject::disconnect(link, DESTROY_SIGNAL_ID, this, DESTROY_SLOT_ID);
-            Py_END_ALLOW_THREADS
-            Q_ASSERT(result);
-            if (!result)
-                return;
-        }
-    }
-
-    if (m_refs.isEmpty())
-        Py_BEGIN_ALLOW_THREADS
-        delete this;
-        Py_END_ALLOW_THREADS
+}
 
+void GlobalReceiverV2::notify()
+{
+    purgeDeletedSenders();
 }
 
-int GlobalReceiverV2::refCount(const QObject *link) const
+static bool isNull(const QPointer<const QObject> &p)
 {
-    if (link)
-        return m_refs.count(link);
+    return p.isNull();
+}
 
-    return m_refs.size();
+void GlobalReceiverV2::purgeDeletedSenders()
+{
+    m_refs.erase(std::remove_if(m_refs.begin(), m_refs.end(), isNull), m_refs.end());
 }
 
-void GlobalReceiverV2::notify()
+bool GlobalReceiverV2::isEmpty() const
 {
-    const QSet<const QObject *> objSet(m_refs.cbegin(), m_refs.cend());
-    Py_BEGIN_ALLOW_THREADS
-    for (const QObject *o : objSet) {
-        if (o) {
-            QMetaObject::disconnect(o, DESTROY_SIGNAL_ID, this, DESTROY_SLOT_ID);
-            QMetaObject::connect(o, DESTROY_SIGNAL_ID, this, DESTROY_SLOT_ID);
-        }
-    }
-    Py_END_ALLOW_THREADS
+    return std::all_of(m_refs.cbegin(), m_refs.cend(), isNull);
 }
 
 GlobalReceiverKey GlobalReceiverV2::key() const
@@ -294,26 +264,21 @@ int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void **args)
     Q_ASSERT(slot.methodType() == QMetaMethod::Slot);
 
     if (!m_data) {
-        if (id != DESTROY_SLOT_ID) {
-            const QByteArray message = "PySide6 Warning: Skipping callback call "
-                + slot.methodSignature() + " because the callback object is being destructed.";
-            PyErr_WarnEx(PyExc_RuntimeWarning, message.constData(), 0);
-        }
+        const QByteArray message = "PySide6 Warning: Skipping callback call "
+            + slot.methodSignature() + " because the callback object is being destructed.";
+        PyErr_WarnEx(PyExc_RuntimeWarning, message.constData(), 0);
         return -1;
     }
 
-    if (id == DESTROY_SLOT_ID) {
-        if (m_refs.isEmpty())
-            return -1;
-        auto obj = *reinterpret_cast<QObject **>(args[1]);
-        incRef(); //keep the object live (safe ref)
-        m_refs.removeAll(obj); // remove all refs to this object
-        decRef(); //remove the safe ref
-    } else {
-        const bool isShortCuit = std::strchr(slot.methodSignature(), '(') == nullptr;
-        Shiboken::AutoDecRef callback(m_data->callback());
-        SignalManager::callPythonMetaMethod(slot, args, callback, isShortCuit);
-    }
+    const bool setSenderDynamicProperty = !m_receiver.isNull();
+    if (setSenderDynamicProperty)
+        m_receiver->setProperty(senderDynamicProperty, QVariant::fromValue(sender()));
+
+    Shiboken::AutoDecRef callback(m_data->callback());
+    SignalManager::callPythonMetaMethod(slot, args, callback);
+
+    if (setSenderDynamicProperty)
+        m_receiver->setProperty(senderDynamicProperty, QVariant{});
 
     // SignalManager::callPythonMetaMethod might have failed, in that case we have to print the
     // error so it considered "handled".
@@ -330,3 +295,28 @@ int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void **args)
 
     return -1;
 }
+
+void GlobalReceiverV2::formatDebug(QDebug &debug) const
+{
+    debug << "receiver=" << m_receiver << ", slot=" << m_data;
+    if (isEmpty())
+        debug << ", empty";
+    else
+        debug << ", refs=" << m_refs;
+};
+
+QDebug operator<<(QDebug debug, const GlobalReceiverV2 *g)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "GlobalReceiverV2(";
+    if (g)
+        g->formatDebug(debug);
+    else
+        debug << '0';
+    debug << ')';
+    return debug;
+}
+
+} // namespace PySide
diff --git a/sources/pyside6/libpyside/globalreceiverv2.h b/sources/pyside6/libpyside/globalreceiverv2.h
index c4b621655..0e3bc562a 100644
--- a/sources/pyside6/libpyside/globalreceiverv2.h
+++ b/sources/pyside6/libpyside/globalreceiverv2.h
@@ -8,10 +8,16 @@
 
 #include "dynamicqmetaobject.h"
 
+#include <QtCore/QtCompare>
 #include <QtCore/QByteArray>
+#include <QtCore/QHashFunctions>
 #include <QtCore/QObject>
+#include <QtCore/QPointer>
 #include <QtCore/QMap>
-#include <QtCore/QSharedPointer>
+
+#include <memory>
+
+QT_FORWARD_DECLARE_CLASS(QDebug);
 
 namespace PySide
 {
@@ -23,110 +29,87 @@ struct GlobalReceiverKey
 {
     const PyObject *object;
     const PyObject *method;
-};
-
-inline bool operator==(const GlobalReceiverKey &k1, const GlobalReceiverKey &k2)
-{
-    return k1.object == k2.object && k1.method == k2.method;
-}
-
-inline bool operator!=(const GlobalReceiverKey &k1, const GlobalReceiverKey &k2)
-{
-    return k1.object != k2.object || k1.method != k2.method;
-}
-
-size_t qHash(const GlobalReceiverKey &k, size_t seed = 0);
-
-using GlobalReceiverV2Map = QHash<GlobalReceiverKey, GlobalReceiverV2 *>;
-using GlobalReceiverV2MapPtr = QSharedPointer<GlobalReceiverV2Map>;
 
-/**
- * A class used to make the link between the C++ Signal/Slot and Python callback
- * This class is used internally by SignalManager
- **/
+    friend constexpr size_t qHash(GlobalReceiverKey k, size_t seed = 0) noexcept
+    {
+        return qHashMulti(seed, k.object, k.method);
+    }
+    friend constexpr bool comparesEqual(const GlobalReceiverKey &lhs,
+                                        const GlobalReceiverKey &rhs) noexcept
+    {
+        return lhs.object == rhs.object && lhs.method == rhs.method;
+    }
+    Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(GlobalReceiverKey)
+};
 
+/// A class used to link C++ Signals to non C++ slots (Python callbacks) by
+/// providing fake slots for QObject::connect().
+/// It keeps a Python callback and the list of QObject senders. It is stored
+/// in SignalManager by a hash of the Python callback.
 class GlobalReceiverV2 : public QObject
 {
 public:
-    /**
-     * Create a GlobalReceiver object that will call 'callback' argumentent
-     *
-     * @param   callback    A Python callable object (can be a method or not)
-     * @param   ma          A SharedPointer used on Signal manager that contains all instaces of GlobalReceiver
-     **/
-    GlobalReceiverV2(PyObject *callback, GlobalReceiverV2MapPtr map);
-
-    /**
-     * Destructor
-     **/
+    Q_DISABLE_COPY_MOVE(GlobalReceiverV2)
+
+    /// Create a GlobalReceiver object that will call 'callback'
+    /// @param callback A Python callable object (can be a method or not)
+    explicit GlobalReceiverV2(PyObject *callback, QObject *receiver = nullptr);
+
     ~GlobalReceiverV2() override;
 
-    /**
-     * Reimplemented function from QObject
-     **/
+    /// Reimplemented function from QObject
     int qt_metacall(QMetaObject::Call call, int id, void **args) override;
     const QMetaObject *metaObject() const override;
 
-    /**
-     * Add a extra slot to this object
-     *
-     * @param   signature   The signature of the slot to be added
-     * @return  The index of this slot on metaobject
-     **/
+    /// Add a extra slot to this object
+    /// @param  signature The signature of the slot to be added
+    /// @return The index of this slot on metaobject
     int addSlot(const char *signature);
 
-    /**
-     * Notify to GlobalReceiver about when a new connection was made
-     **/
+    /// Notify to GlobalReceiver about when a new connection was made
     void notify();
 
-    /**
-     * Used to increment the reference of the GlobalReceiver object
-     *
-     * @param   link    This is a optional paramenter used to link the ref to some QObject life
-     **/
-    void incRef(const QObject *link = nullptr);
-
-    /**
-     * Used to decrement the reference of the GlobalReceiver object
-     *
-     * @param   link    This is a optional paramenter used to dismiss the link ref to some QObject
-     **/
-    void decRef(const QObject *link = nullptr);
-
-    /*
-     * Return the count of refs which the GlobalReceiver has
-     *
-     * @param   link    If any QObject was passed, the function return the number of references relative to this 'link' object
-     * @return  The number of references
-     **/
-    int refCount(const QObject *link) const;
-
-    /**
-     * Use to retrieve the unique hash of this GlobalReceiver object
-     *
-     * @return  a string with a unique id based on GlobalReceiver contents
-     **/
+    /// Used to increment the reference of the GlobalReceiver object
+    /// @param link This is a parameter used to link the ref to
+    ///             some QObject life.
+    void incRef(const QObject *link);
+
+    /// Used to decrement the reference of the GlobalReceiver object.
+    /// @param link This is a parameter used to dismiss the link
+    ///             ref to some QObject.
+    void decRef(const QObject *link);
+
+    /// Returns whether any senders are registered.
+    bool isEmpty() const;
+
+    /// Use to retrieve the unique hash of this GlobalReceiver object
+    /// @return hash key
     GlobalReceiverKey key() const;
 
-    /**
-     * Use to retrieve the unique hash of the PyObject based on GlobalReceiver rules
-     *
-     * @param   callback The Python callable object used to calculate the id
-     * @return  a string with a unique id based on GlobalReceiver contents
-     **/
+    /// Use to retrieve the unique hash of the PyObject based on GlobalReceiver rules
+    /// @param callback The Python callable object used to calculate the id
+    /// @return hash key
     static GlobalReceiverKey key(PyObject *callback);
 
     const MetaObjectBuilder &metaObjectBuilder() const { return m_metaObject; }
     MetaObjectBuilder &metaObjectBuilder() { return m_metaObject; }
 
+    static const char *senderDynamicProperty;
+
+    void formatDebug(QDebug &debug) const;
+
 private:
+    void purgeDeletedSenders();
+
     MetaObjectBuilder m_metaObject;
     DynamicSlotDataV2 *m_data;
-    QList<const QObject *> m_refs;
-    GlobalReceiverV2MapPtr m_sharedMap;
+    using QObjectPointer = QPointer<const QObject>;
+    QList<QObjectPointer> m_refs;
+    QPointer<QObject> m_receiver;
 };
 
+QDebug operator<<(QDebug debug, const GlobalReceiverV2 *g);
+
 }
 
 #endif
diff --git a/sources/pyside6/libpyside/pyside.cpp b/sources/pyside6/libpyside/pyside.cpp
index a832db28a..9e12e3cd7 100644
--- a/sources/pyside6/libpyside/pyside.cpp
+++ b/sources/pyside6/libpyside/pyside.cpp
@@ -32,21 +32,28 @@
 #include <sbkstring.h>
 #include <sbkstaticstrings.h>
 #include <sbkfeature_base.h>
+#include <sbkmodule.h>
 
 #include <QtCore/QByteArray>
 #include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
 #include <QtCore/QDir>
 #include <QtCore/QFileInfo>
+#include <QtCore/QMetaMethod>
 #include <QtCore/QMutex>
-#include <QtCore/QSharedPointer>
 #include <QtCore/QStack>
 #include <QtCore/QThread>
+#include <QtCore/private/qobject_p.h>
 
 #include <algorithm>
 #include <cstring>
 #include <cctype>
+#include <memory>
+#include <optional>
 #include <typeinfo>
 
+using namespace Qt::StringLiterals;
+
 static QStack<PySide::CleanupFunction> cleanupFunctionList;
 static void *qobjectNextAddr;
 
@@ -57,6 +64,20 @@ QT_END_NAMESPACE
 
 Q_LOGGING_CATEGORY(lcPySide, "qt.pyside.libpyside", QtCriticalMsg)
 
+static QObjectData *qt_object_private(const QObject *o)
+{
+    class FriendlyQObject : public QObject {
+    public:
+        using QObject::d_ptr;
+    };
+    return static_cast<const FriendlyQObject *>(o)->d_ptr.data();
+}
+
+static bool hasDynamicMetaObject(const QObject *o)
+{
+    return qt_object_private(o)->metaObject != nullptr;
+}
+
 namespace PySide
 {
 
@@ -198,6 +219,8 @@ static QByteArrayList _SbkType_LookupProperty(PyTypeObject *type,
     auto len = std::strlen(origName);
     for (Py_ssize_t idx = 0; idx < n; idx++) {
         PyTypeObject *base = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
+        if (!SbkObjectType_Check(base))
+            continue;
         auto props = SbkObjectType_GetPropertyStrings(base);
         if (props == nullptr || *props == nullptr)
             continue;
@@ -273,7 +296,7 @@ static bool _setProperty(PyObject *qObj, PyObject *name, PyObject *value, bool *
         static PyObject *magicGet = Shiboken::PyMagicName::get();
         if (found && prop_flag) {
             // the indirection of the setter descriptor in a true property
-            AutoDecRef descr(PyObject_GetAttr(look, PyName::fset()));
+            AutoDecRef descr(PyObject_GetAttr(look, PySideName::fset()));
             propSetter.reset(PyObject_CallMethodObjArgs(descr, magicGet, qObj, nullptr));
         } else {
             // look is already the descriptor
@@ -297,7 +320,23 @@ static bool _setProperty(PyObject *qObj, PyObject *name, PyObject *value, bool *
     return true;
 }
 
-bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds)
+// PYSIDE-2329: Search a signal by name (Note: QMetaObject::indexOfSignal()
+// searches by signature).
+static std::optional<QMetaMethod> findSignal(const QMetaObject *mo,
+                                             const QByteArray &name)
+{
+    const auto count = mo->methodCount();
+    for (int i = mo->methodOffset(); i < count; ++i) {
+        const auto method = mo->method(i);
+        if (method.methodType() == QMetaMethod::Signal && method.name() == name)
+            return method;
+    }
+    auto *base = mo->superClass();
+    return base != nullptr ? findSignal(base, name) : std::nullopt;
+}
+
+bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj,
+                      PyObject *kwds, bool allowErrors)
 {
 
     PyObject *key, *value;
@@ -306,7 +345,7 @@ bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds
     int snake_flag = flags & 0x01;
 
     while (PyDict_Next(kwds, &pos, &key, &value)) {
-        QByteArray propName(Shiboken::String::toCString(key));
+        const QByteArray propName = Shiboken::String::toCString(key);
         QByteArray unmangledName = _sigWithOrigName(propName, snake_flag);
         bool accept = false;
         // PYSIDE-1705: Make sure that un-mangled names are not recognized in snake_case mode.
@@ -315,11 +354,11 @@ bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds
                 if (!_setProperty(qObj, key, value, &accept))
                     return false;
             } else {
-                propName.append("()");
-                if (metaObj->indexOfSignal(propName) != -1) {
+                const auto methodO = findSignal(metaObj, propName);
+                if (methodO.has_value()) {
+                    const auto signature = "2"_ba + methodO->methodSignature();
                     accept = true;
-                    propName.prepend('2');
-                    if (!PySide::Signal::connect(qObj, propName, value))
+                    if (!PySide::Signal::connect(qObj, signature, value))
                         return false;
                 }
             }
@@ -329,6 +368,10 @@ bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds
                     return false;
             }
         }
+        if (allowErrors) {
+            PyErr_Clear();
+            continue;
+        }
         if (!accept) {
             PyErr_Format(PyExc_AttributeError, "'%s' is not a Qt property or a signal",
                          propName.constData());
@@ -419,6 +462,8 @@ void initDynamicMetaObject(PyTypeObject *type, const QMetaObject *base, std::siz
 
 TypeUserData *retrieveTypeUserData(PyTypeObject *pyTypeObj)
 {
+    if (!SbkObjectType_Check(pyTypeObj))
+        return nullptr;
     return reinterpret_cast<TypeUserData *>(Shiboken::ObjectType::getTypeUserData(pyTypeObj));
 }
 
@@ -445,7 +490,6 @@ const QMetaObject *retrieveMetaObject(PyObject *pyObj)
 void initQObjectSubType(PyTypeObject *type, PyObject *args, PyObject * /* kwds */)
 {
     PyTypeObject *qObjType = Shiboken::Conversions::getPythonTypeObject("QObject*");
-    QByteArray className(Shiboken::String::toCString(PyTuple_GET_ITEM(args, 0)));
 
     PyObject *bases = PyTuple_GET_ITEM(args, 1);
     int numBases = PyTuple_GET_SIZE(bases);
@@ -460,7 +504,9 @@ void initQObjectSubType(PyTypeObject *type, PyObject *args, PyObject * /* kwds *
         }
     }
     if (!userData) {
-        qWarning("Sub class of QObject not inheriting QObject!? Crash will happen when using %s.", className.constData());
+        const char *className = Shiboken::String::toCString(PyTuple_GET_ITEM(args, 0));
+        qWarning("Sub class of QObject not inheriting QObject!? Crash will happen when using %s.",
+                 className);
         return;
     }
     // PYSIDE-1463: Don't change feature selection durin subtype initialization.
@@ -490,8 +536,11 @@ void initQApp()
     setDestroyQApplication(destroyQCoreApplication);
 }
 
-PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name)
+PyObject *getHiddenDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name)
 {
+    using Shiboken::AutoDecRef;
+
+    // PYSIDE-68-bis: This getattr finds signals early by `signalDescrGet`.
     PyObject *attr = PyObject_GenericGetAttr(self, name);
     if (!Shiboken::Object::isValid(reinterpret_cast<SbkObject *>(self), false))
         return attr;
@@ -504,26 +553,51 @@ PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *nam
         attr = value;
     }
 
-    // Mutate native signals to signal instance type
-    if (attr && PyObject_TypeCheck(attr, PySideSignal_TypeF())) {
-        auto *inst = Signal::initialize(reinterpret_cast<PySideSignal *>(attr), name, self);
-        PyObject *signalInst = reinterpret_cast<PyObject *>(inst);
-        PyObject_SetAttr(self, name, signalInst);
-        return signalInst;
-    }
-
     // Search on metaobject (avoid internal attributes started with '__')
     if (!attr) {
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);     // This was omitted for a loong time.
 
-        const char *cname = Shiboken::String::toCString(name);
         int flags = currentSelectId(Py_TYPE(self));
         int snake_flag = flags & 0x01;
+        int propFlag = flags & 0x02;
+
+        if (propFlag) {
+            // PYSIDE-1889: If we have actually a Python property, return f(get|set|del).
+            //              Do not store this attribute in the instance dict, because this
+            //              would create confusion with overload.
+            // Note: before implementing this property handling, the meta function code
+            // below created meta functions which was quite wrong.
+            auto *subdict = _PepType_Lookup(Py_TYPE(self), PySideMagicName::property_methods());
+            PyObject *propName = PyDict_GetItem(subdict, name);
+            if (propName) {
+                // We really have a property name and need to fetch the fget or fset function.
+                static PyObject *const _fget = Shiboken::String::createStaticString("fget");
+                static PyObject *const _fset = Shiboken::String::createStaticString("fset");
+                static PyObject *const _fdel = Shiboken::String::createStaticString("fdel");
+                static PyObject *const arr[3] = {_fget, _fset, _fdel};
+                auto prop = _PepType_Lookup(Py_TYPE(self), propName);
+                for (int idx = 0; idx < 3; ++idx) {
+                    auto *trial = arr[idx];
+                    auto *res = PyObject_GetAttr(prop, trial);
+                    if (res) {
+                        AutoDecRef elemName(PyObject_GetAttr(res, PySideMagicName::name()));
+                        // Note: This comparison works because of interned strings.
+                        if (elemName == name)
+                            return res;
+                        Py_DECREF(res);
+                    }
+                    PyErr_Clear();
+                }
+            }
+        }
+
+        const char *cname = Shiboken::String::toCString(name);
         uint cnameLen = qstrlen(cname);
-        if (std::strncmp("__", cname, 2)) {
+        if (std::strncmp("__", cname, 2) != 0) {
             const QMetaObject *metaObject = cppSelf->metaObject();
             QList<QMetaMethod> signalList;
+            // Caution: This inserts a meta function or a signal into the instance dict.
             for (int i=0, imax = metaObject->methodCount(); i < imax; i++) {
                 QMetaMethod method = metaObject->method(i);
                 // PYSIDE-1753: Snake case names must be renamed here too, or they will be
@@ -590,17 +664,23 @@ void setNextQObjectMemoryAddr(void *addr)
 
 } // namespace PySide
 
-// A QSharedPointer is used with a deletion function to invalidate a pointer
+// A std::shared_ptr is used with a deletion function to invalidate a pointer
 // when the property value is cleared.  This should be a QSharedPointer with
 // a void *pointer, but that isn't allowed
-typedef char any_t;
-Q_DECLARE_METATYPE(QSharedPointer<any_t>);
+using any_t = char;
+Q_DECLARE_METATYPE(std::shared_ptr<any_t>);
+
 
 namespace PySide
 {
 
 static void invalidatePtr(any_t *object)
 {
+    // PYSIDE-2254: Guard against QObjects outliving Python, for example the
+    // adopted main thread as returned by QObjects::thread().
+    if (Py_IsInitialized() == 0)
+        return;
+
     Shiboken::GilState state;
 
     SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(object);
@@ -610,6 +690,32 @@ static void invalidatePtr(any_t *object)
 
 static const char invalidatePropertyName[] = "_PySideInvalidatePtr";
 
+// PYSIDE-2749: Skip over internal QML classes and classes
+// with dynamic meta objects when looking for the best matching
+// type to avoid unnessarily triggering the lazy load mechanism
+// for classes that do not have a binding from things like eventFilter().
+static inline bool isInternalObject(const char *name)
+{
+    return std::strstr(name, "QMLTYPE") != nullptr || std::strstr(name, "QQmlPrivate") != nullptr;
+}
+
+static const QMetaObject *metaObjectCandidate(const QObject *o)
+{
+    auto *metaObject = o->metaObject();
+    // Skip QML helper types and Python objects
+    if (hasDynamicMetaObject(o)) {
+        if (auto *super = metaObject->superClass())
+            metaObject = super;
+    }
+    for (auto *candidate = metaObject; candidate != nullptr; candidate = candidate->superClass()) {
+        if (!isInternalObject(candidate->className())) {
+            metaObject = candidate;
+            break;
+        }
+    }
+    return metaObject;
+}
+
 // PYSIDE-1214, when creating new wrappers for classes inheriting QObject but
 // not exposed to Python, try to find the best-matching (most-derived) Qt
 // class by walking up the meta objects.
@@ -617,7 +723,8 @@ static const char *typeName(const QObject *cppSelf)
 {
     const char *typeName = typeid(*cppSelf).name();
     if (!Shiboken::Conversions::getConverter(typeName)) {
-        for (auto metaObject = cppSelf->metaObject(); metaObject; metaObject = metaObject->superClass()) {
+        auto *metaObject = metaObjectCandidate(cppSelf);
+        for (; metaObject != nullptr; metaObject = metaObject->superClass()) {
             const char *name = metaObject->className();
             if (Shiboken::Conversions::getConverter(name)) {
                 typeName = name;
@@ -656,7 +763,7 @@ PyObject *getWrapperForQObject(QObject *cppSelf, PyTypeObject *sbk_type)
     QVariant existing = cppSelf->property(invalidatePropertyName);
     if (!existing.isValid()) {
         if (cppSelf->thread() == QThread::currentThread()) {
-            QSharedPointer<any_t> shared_with_del(reinterpret_cast<any_t *>(cppSelf), invalidatePtr);
+            std::shared_ptr<any_t> shared_with_del(reinterpret_cast<any_t *>(cppSelf), invalidatePtr);
             cppSelf->setProperty(invalidatePropertyName, QVariant::fromValue(shared_with_del));
         }
         pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppSelf));
@@ -666,7 +773,7 @@ PyObject *getWrapperForQObject(QObject *cppSelf, PyTypeObject *sbk_type)
         }
     }
 
-    pyOut = Shiboken::Object::newObject(sbk_type, cppSelf, false, false, typeName(cppSelf));
+    pyOut = Shiboken::Object::newObjectWithHeuristics(sbk_type, cppSelf, false, typeName(cppSelf));
 
     return pyOut;
 }
@@ -732,9 +839,9 @@ QString pyPathToQString(PyObject *path)
 
 bool isCompiledMethod(PyObject *callback)
 {
-    return PyObject_HasAttr(callback, PySide::PyName::im_func())
-           && PyObject_HasAttr(callback, PySide::PyName::im_self())
-           && PyObject_HasAttr(callback, PySide::PyMagicName::code());
+    return PyObject_HasAttr(callback, PySide::PySideName::im_func())
+           && PyObject_HasAttr(callback, PySide::PySideName::im_self())
+           && PyObject_HasAttr(callback, PySide::PySideMagicName::code());
 }
 
 static const unsigned char qt_resource_name[] = {
@@ -770,9 +877,9 @@ bool registerInternalQtConf()
 {
     // Guard to ensure single registration.
 #ifdef PYSIDE_QT_CONF_PREFIX
-        static bool registrationAttempted = false;
+    static bool registrationAttempted = false;
 #else
-        static bool registrationAttempted = true;
+    static bool registrationAttempted = true;
 #endif
     static bool isRegistered = false;
     if (registrationAttempted)
@@ -784,23 +891,32 @@ bool registerInternalQtConf()
     // This will disable the internal qt.conf which points to the PySide6 subdirectory (due to the
     // subdirectory not existing anymore).
 #ifndef PYPY_VERSION
-    QString executablePath =
-    QString::fromWCharArray(Py_GetProgramFullPath());
+    QString executablePath = QString::fromWCharArray(Py_GetProgramFullPath());
 #else
     // PYSIDE-535: FIXME: Add this function when available.
-    QString executablePath = QLatin1String("missing Py_GetProgramFullPath");
+    QString executablePath = QLatin1StringView("missing Py_GetProgramFullPath");
 #endif // PYPY_VERSION
+
     QString appDirPath = QFileInfo(executablePath).absolutePath();
-    QString maybeQtConfPath = QDir(appDirPath).filePath(QStringLiteral("qt.conf"));
-    bool executableQtConfAvailable = QFileInfo::exists(maybeQtConfPath);
+
+    QString maybeQtConfPath = QDir(appDirPath).filePath(u"qt.conf"_s);
     maybeQtConfPath = QDir::toNativeSeparators(maybeQtConfPath);
+    bool executableQtConfAvailable = QFileInfo::exists(maybeQtConfPath);
+
+    QString maybeQt6ConfPath = QDir(appDirPath).filePath(u"qt6.conf"_s);
+    maybeQt6ConfPath = QDir::toNativeSeparators(maybeQt6ConfPath);
+    bool executableQt6ConfAvailable = QFileInfo::exists(maybeQt6ConfPath);
 
     // Allow disabling the usage of the internal qt.conf. This is necessary for tests to work,
     // because tests are executed before the package is installed, and thus the Prefix specified
     // in qt.conf would point to a not yet existing location.
     bool disableInternalQtConf =
-            qEnvironmentVariableIntValue("PYSIDE_DISABLE_INTERNAL_QT_CONF") > 0;
-    if (disableInternalQtConf || executableQtConfAvailable) {
+        qEnvironmentVariableIntValue("PYSIDE_DISABLE_INTERNAL_QT_CONF") > 0;
+    bool runsInConda =
+        qEnvironmentVariableIsSet("CONDA_DEFAULT_ENV") || qEnvironmentVariableIsSet("CONDA_PREFIX");
+
+    if ((!runsInConda && (disableInternalQtConf || executableQtConfAvailable))
+        || (runsInConda && executableQt6ConfAvailable)) {
         registrationAttempted = true;
         return false;
     }
@@ -830,25 +946,17 @@ bool registerInternalQtConf()
 #ifdef PYSIDE_QT_CONF_PREFIX
     setupPrefix = QStringLiteral(PYSIDE_QT_CONF_PREFIX);
 #endif
-    const QString prefixPathStr = pysideDir.absoluteFilePath(setupPrefix);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-    const QByteArray prefixPath = prefixPathStr.toLocal8Bit();
-#else
-    // PYSIDE-972, QSettings used by QtCore uses Latin1
-    const QByteArray prefixPath = prefixPathStr.toLatin1();
-#endif
+    const QByteArray prefixPath = pysideDir.absoluteFilePath(setupPrefix).toUtf8();
 
     // rccData needs to be static, otherwise when it goes out of scope, the Qt resource system
     // will point to invalid memory.
-    static QByteArray rccData = QByteArrayLiteral("[Paths]\nPrefix = ") + prefixPath
+    static QByteArray rccData = QByteArrayLiteral("[Paths]\nPrefix = ") + prefixPath + "\n";
 #ifdef Q_OS_WIN
-            // LibraryExecutables needs to point to Prefix instead of ./bin because we don't
-            // currently conform to the Qt default directory layout on Windows. This is necessary
-            // for QtWebEngineCore to find the location of QtWebEngineProcess.exe.
-            + QByteArray("\nLibraryExecutables = ") + prefixPath
+    // LibraryExecutables needs to point to Prefix instead of ./bin because we don't
+    // currently conform to the Qt default directory layout on Windows. This is necessary
+    // for QtWebEngineCore to find the location of QtWebEngineProcess.exe.
+    rccData += QByteArrayLiteral("LibraryExecutables = ") + prefixPath + "\n";
 #endif
-            ;
-    rccData.append('\n');
 
     // The RCC data structure expects a 4-byte size value representing the actual data.
     qsizetype size = rccData.size();
@@ -918,5 +1026,190 @@ QMetaType qMetaTypeFromPyType(PyTypeObject *pyType)
     return QMetaType::fromName(pyType->tp_name);
 }
 
-} //namespace PySide
+debugPyTypeObject::debugPyTypeObject(const PyTypeObject *o) noexcept
+    : m_object(o)
+{
+}
+
+QDebug operator<<(QDebug debug, const debugPyTypeObject &o)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "PyTypeObject(";
+    if (o.m_object)
+        debug << '"' << o.m_object->tp_name << '"';
+    else
+        debug << '0';
+    debug << ')';
+    return debug;
+}
+
+static void formatPyObject(PyObject *obj, QDebug &debug);
+
+static void formatPySequence(PyObject *obj, QDebug &debug)
+{
+    const Py_ssize_t size = PySequence_Size(obj);
+    debug << size << " [";
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        if (i)
+            debug << ", ";
+        Shiboken::AutoDecRef item(PySequence_GetItem(obj, i));
+        formatPyObject(item.object(), debug);
+    }
+    debug << ']';
+}
+
+static void formatPyDict(PyObject *obj, QDebug &debug)
+{
+    PyObject *key;
+    PyObject *value;
+    Py_ssize_t pos = 0;
+    bool first = true;
+    debug << '{';
+    while (PyDict_Next(obj, &pos, &key, &value) != 0) {
+        if (first)
+            first = false;
+        else
+            debug << ", ";
+        formatPyObject(key, debug);
+        debug << '=';
+        formatPyObject(value, debug);
+    }
+    debug << '}';
+}
+
+static inline const char *pyTypeName(PyObject *obj)
+{
+    return Py_TYPE(obj)->tp_name;
+}
+
+static QString getQualName(PyObject *obj)
+{
+    Shiboken::AutoDecRef result(PyObject_GetAttr(obj, Shiboken::PyMagicName::qualname()));
+    return result.object() != nullptr
+        ? pyStringToQString(result.object()) : QString{};
+}
+
+static void formatPyFunction(PyObject *obj, QDebug &debug)
+{
+    debug << '"' << getQualName(obj) << "()\"";
+}
+
+static void formatPyMethod(PyObject *obj, QDebug &debug)
+{
+    if (auto *func = PyMethod_Function(obj))
+        formatPyFunction(func, debug);
+    debug << ", instance=" << PyMethod_Self(obj);
+}
+
+static void formatPyObjectValue(PyObject *obj, QDebug &debug)
+{
+    if (PyType_Check(obj) != 0)
+        debug << "type: \"" << pyTypeName(obj) << '"';
+    else if (PyLong_Check(obj) != 0) {
+        const auto llv = PyLong_AsLongLong(obj);
+        if (PyErr_Occurred() != PyExc_OverflowError) {
+            debug << llv;
+        } else {
+            PyErr_Clear();
+            debug << "0x" << Qt::hex << PyLong_AsUnsignedLongLong(obj) << Qt::dec;
+        }
+    } else if (PyFloat_Check(obj) != 0)
+        debug << PyFloat_AsDouble(obj);
+    else if (PyUnicode_Check(obj) != 0)
+        debug << '"' << pyStringToQString(obj) << '"';
+    else if (PyFunction_Check(obj) != 0)
+        formatPyFunction(obj, debug);
+    else if (PyMethod_Check(obj) != 0)
+        formatPyMethod(obj, debug);
+    else if (PySequence_Check(obj) != 0)
+        formatPySequence(obj, debug);
+    else if (PyDict_Check(obj) != 0)
+        formatPyDict(obj, debug);
+    else
+        debug << obj;
+}
 
+static void formatPyObject(PyObject *obj, QDebug &debug)
+{
+    if (obj == nullptr) {
+        debug << '0';
+        return;
+    }
+    if (obj == Py_None) {
+        debug << "None";
+        return;
+    }
+    if (obj == Py_True) {
+        debug << "True";
+        return;
+    }
+    if (obj == Py_False) {
+        debug << "False";
+        return;
+    }
+    if (PyType_Check(obj) == 0)
+        debug << pyTypeName(obj) << ": ";
+    formatPyObjectValue(obj, debug);
+}
+
+debugPyObject::debugPyObject(PyObject *o) noexcept : m_object(o)
+{
+}
+
+QDebug operator<<(QDebug debug, const debugPyObject &o)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "PyObject(";
+    formatPyObject(o.m_object, debug);
+    debug << ')';
+    return debug;
+}
+
+debugPyBuffer::debugPyBuffer(Py_buffer *b) noexcept : m_buffer(b)
+{
+}
+
+static void formatPy_ssizeArray(QDebug &debug, const char *name, const Py_ssize_t *array, int len)
+{
+    debug << ", " << name << '=';
+    if (array != nullptr) {
+        debug << '[';
+        for (int i = 0; i < len; ++i)
+            debug << array[i] << ' ';
+        debug << ']';
+    } else {
+        debug << '0';
+    }
+}
+
+PYSIDE_API QDebug operator<<(QDebug debug, const debugPyBuffer &b)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    debug << "Py_buffer(";
+    if (b.m_buffer != nullptr) {
+        debug << "obj=" << b.m_buffer->obj
+              << ", buf=" << b.m_buffer->buf << ", len=" << b.m_buffer->len
+              << ", readonly=" <<  b.m_buffer->readonly
+              << ", itemsize=" <<  b.m_buffer->itemsize << ", format=";
+        if (b.m_buffer->format != nullptr)
+            debug << '"' << b.m_buffer->format << '"';
+        else
+            debug << '0';
+        debug << ", ndim=" << b.m_buffer->ndim;
+        formatPy_ssizeArray(debug, "shape", b.m_buffer->shape, b.m_buffer->ndim);
+        formatPy_ssizeArray(debug, "strides", b.m_buffer->strides, b.m_buffer->ndim);
+        formatPy_ssizeArray(debug, "suboffsets", b.m_buffer->suboffsets, b.m_buffer->ndim);
+    } else {
+        debug << '0';
+    }
+    debug << ')';
+    return debug;
+}
+
+} // namespace PySide
diff --git a/sources/pyside6/libpyside/pyside_numpy.cpp b/sources/pyside6/libpyside/pyside_numpy.cpp
index a6634fc56..5f43cc5ce 100644
--- a/sources/pyside6/libpyside/pyside_numpy.cpp
+++ b/sources/pyside6/libpyside/pyside_numpy.cpp
@@ -45,10 +45,18 @@ QList<QPointF> xyDataToQPointFList(PyObject *pyXIn, PyObject *pyYIn)
     if (size == 0)
         return {};
     switch (xv.type) {
+    case Shiboken::Numpy::View::Int16:
+        return xyDataToQPointHelper<int16_t, QPointF>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Unsigned16:
+        return xyDataToQPointHelper<uint16_t, QPointF>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Int:
         return xyDataToQPointHelper<int, QPointF>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Unsigned:
         return xyDataToQPointHelper<unsigned, QPointF>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Int64:
+        return xyDataToQPointHelper<int64_t, QPointF>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Unsigned64:
+        return xyDataToQPointHelper<uint64_t, QPointF>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Float:
         return xyDataToQPointHelper<float, QPointF>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Double:
@@ -67,10 +75,18 @@ QList<QPoint> xyDataToQPointList(PyObject *pyXIn, PyObject *pyYIn)
     if (size == 0)
         return {};
     switch (xv.type) {
+    case Shiboken::Numpy::View::Int16:
+        return xyDataToQPointHelper<int16_t, QPoint>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Unsigned16:
+        return xyDataToQPointHelper<uint16_t, QPoint>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Int:
         return xyDataToQPointHelper<int, QPoint>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Unsigned:
         return xyDataToQPointHelper<unsigned, QPoint>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Int64:
+        return xyDataToQPointHelper<int64_t, QPoint>(xv.data, yv.data, size);
+    case Shiboken::Numpy::View::Unsigned64:
+        return xyDataToQPointHelper<uint64_t, QPoint>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Float:
         return xyFloatDataToQPointHelper<float>(xv.data, yv.data, size);
     case Shiboken::Numpy::View::Double:
diff --git a/sources/pyside6/libpyside/pysideclassdecorator.cpp b/sources/pyside6/libpyside/pysideclassdecorator.cpp
index 1085153d9..ec69c5fe7 100644
--- a/sources/pyside6/libpyside/pysideclassdecorator.cpp
+++ b/sources/pyside6/libpyside/pysideclassdecorator.cpp
@@ -7,10 +7,11 @@
 #include "pysideqobject.h"
 
 #include <basewrapper.h>
-#include <sbkcppstring.h>
+#include <sbkstring.h>
 
 namespace PySide::ClassDecorator {
 
+DecoratorPrivate::DecoratorPrivate() noexcept = default;
 DecoratorPrivate::~DecoratorPrivate() = default;
 
 DecoratorPrivate *DecoratorPrivate::getPrivate(PyObject *o)
@@ -62,7 +63,7 @@ int StringDecoratorPrivate::convertToString(PyObject *self, PyObject *args)
         if (PyUnicode_Check(arg)) {
             auto *pData = DecoratorPrivate::get<StringDecoratorPrivate>(self);
             result = 0;
-            Shiboken::String::toCppString(arg, &(pData->m_string));
+            pData->m_string.assign(Shiboken::String::toCString(arg));
         }
     }
     return result;
diff --git a/sources/pyside6/libpyside/pysideclassdecorator_p.h b/sources/pyside6/libpyside/pysideclassdecorator_p.h
index 9a1dfc8a2..6068f6a2e 100644
--- a/sources/pyside6/libpyside/pysideclassdecorator_p.h
+++ b/sources/pyside6/libpyside/pysideclassdecorator_p.h
@@ -7,6 +7,9 @@
 #include <pysidemacros.h>
 
 #include <sbkpython.h>
+#include <pep384ext.h>
+
+#include <QtCore/QByteArray>
 
 #include <array>
 #include <string>
@@ -18,6 +21,8 @@ namespace PySide::ClassDecorator {
 class PYSIDE_API DecoratorPrivate
 {
 public:
+     Q_DISABLE_COPY_MOVE(DecoratorPrivate)
+
     virtual ~DecoratorPrivate();
 
     /// Virtual function which is passed the decorated class type
@@ -41,6 +46,7 @@ protected:
     /// Check mode for the arguments of the call operator
     enum class CheckMode { None, WrappedType, QObjectType };
 
+    DecoratorPrivate() noexcept;
     static DecoratorPrivate *getPrivate(PyObject *o);
 
     /// Helper for checking the arguments of the call operator
@@ -59,7 +65,7 @@ public:
     /// Init function that retrieves the string parameter using convertToString()
     int tp_init(PyObject *self, PyObject *args, PyObject *kwds) override;
 
-    const std::string &string() const { return m_string; }
+    QByteArray string() const { return m_string; }
 
 protected:
     /// Helper function that retrieves the string parameter
@@ -69,7 +75,7 @@ protected:
     int convertToString(PyObject *self, PyObject *args);
 
 private:
-    std::string m_string;
+    QByteArray m_string;
 };
 
 /// Base class for private objects of class decorator with a type parameter
@@ -114,7 +120,7 @@ struct Methods
 {
     static PyObject *tp_new(PyTypeObject *subtype)
     {
-        auto *result = reinterpret_cast<PySideClassDecorator *>(subtype->tp_alloc(subtype, 0));
+        auto *result = PepExt_TypeCallAlloc<PySideClassDecorator>(subtype, 0);
         result->d = new DecoratorPrivate;
         return reinterpret_cast<PyObject *>(result);
     }
@@ -124,7 +130,7 @@ struct Methods
         auto pySelf = reinterpret_cast<PyObject *>(self);
         auto decorator = reinterpret_cast<PySideClassDecorator *>(self);
         delete decorator->d;
-        Py_TYPE(pySelf)->tp_base->tp_free(self);
+        PepExt_TypeCallFree(Py_TYPE(pySelf)->tp_base, self);
     }
 
     static PyObject *tp_call(PyObject *self, PyObject *args, PyObject *kwds)
diff --git a/sources/pyside6/libpyside/pysideclassinfo.cpp b/sources/pyside6/libpyside/pysideclassinfo.cpp
index 60413be20..698cb1c76 100644
--- a/sources/pyside6/libpyside/pysideclassinfo.cpp
+++ b/sources/pyside6/libpyside/pysideclassinfo.cpp
@@ -14,7 +14,7 @@
 extern "C"
 {
 
-static PyTypeObject *createClassInfoType(void)
+static PyTypeObject *createClassInfoType()
 {
     auto typeSlots =
         PySide::ClassDecorator::Methods<PySide::ClassInfo::ClassInfoPrivate>::typeSlots();
@@ -36,7 +36,7 @@ PyTypeObject *PySideClassInfo_TypeF(void)
 
 }  // extern "C"
 
-namespace PySide { namespace ClassInfo {
+namespace PySide::ClassInfo {
 
 const char *ClassInfoPrivate::name() const
 {
@@ -51,25 +51,14 @@ PyObject *ClassInfoPrivate::tp_call(PyObject *self, PyObject *args, PyObject * /
 
     auto *pData = DecoratorPrivate::get<ClassInfoPrivate>(self);
 
-    if (pData->m_alreadyWrapped) {
-        PyErr_SetString(PyExc_TypeError, "This instance of ClassInfo() was already used to wrap an object");
-        return nullptr;
-    }
-
-    bool validClass = false;
+    if (pData->m_alreadyWrapped)
+        return PyErr_Format(PyExc_TypeError, "This instance of ClassInfo() was already used to wrap an object");
 
     PyTypeObject *klassType = reinterpret_cast<PyTypeObject *>(klass);
-    if (auto userData = PySide::retrieveTypeUserData(klassType)) {
-        PySide::MetaObjectBuilder &mo = userData->mo;
-        mo.addInfo(pData->m_data);
-        pData->m_alreadyWrapped = true;
-        validClass = true;
-    }
+    if (!PySide::ClassInfo::setClassInfo(klassType, pData->m_data))
+        return PyErr_Format(PyExc_TypeError, "This decorator can only be used on classes that are subclasses of QObject");
 
-    if (!validClass) {
-        PyErr_SetString(PyExc_TypeError, "This decorator can only be used on classes that are subclasses of QObject");
-        return nullptr;
-    }
+    pData->m_alreadyWrapped = true;
 
     Py_INCREF(klass);
     return klass;
@@ -79,7 +68,7 @@ int ClassInfoPrivate::tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
     PyObject *infoDict = nullptr;
     auto size = PyTuple_Size(args);
-    if (size == 1 && !kwds) {
+    if (size == 1 && kwds == nullptr) {
         PyObject *tmp = PyTuple_GET_ITEM(args, 0);
         if (PyDict_Check(tmp))
             infoDict = tmp;
@@ -87,7 +76,7 @@ int ClassInfoPrivate::tp_init(PyObject *self, PyObject *args, PyObject *kwds)
         infoDict = kwds;
     }
 
-    if (!infoDict) {
+    if (infoDict == nullptr) {
         PyErr_Format(PyExc_TypeError, "ClassInfo() takes either keyword argument(s) or "
                                       "a single dictionary argument");
         return -1;
@@ -95,15 +84,17 @@ int ClassInfoPrivate::tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 
     auto *pData = DecoratorPrivate::get<ClassInfoPrivate>(self);
 
-    PyObject *key;
-    PyObject *value;
+    PyObject *key{};
+    PyObject *value{};
     Py_ssize_t pos = 0;
 
     // PyDict_Next causes a segfault if kwds is empty
     if (PyDict_Size(infoDict) > 0) {
         while (PyDict_Next(infoDict, &pos, &key, &value)) {
             if (Shiboken::String::check(key) && Shiboken::String::check(value)) {
-                pData->m_data[Shiboken::String::toCString(key)] = Shiboken::String::toCString(value);
+                ClassInfo info{Shiboken::String::toCString(key),
+                               Shiboken::String::toCString(value)};
+                pData->m_data.append(info);
             } else {
                 PyErr_SetString(PyExc_TypeError, "All keys and values provided to ClassInfo() "
                                                  "must be strings");
@@ -112,7 +103,7 @@ int ClassInfoPrivate::tp_init(PyObject *self, PyObject *args, PyObject *kwds)
         }
     }
 
-    return PyErr_Occurred() ? -1 : 0;
+    return PyErr_Occurred() != nullptr ? -1 : 0;
 }
 
 static const char *ClassInfo_SignatureStrings[] = {
@@ -130,16 +121,38 @@ void init(PyObject *module)
 
 bool checkType(PyObject *pyObj)
 {
-    if (pyObj)
-        return PyType_IsSubtype(Py_TYPE(pyObj), PySideClassInfo_TypeF());
-    return false;
+    return pyObj != nullptr
+        && PyType_IsSubtype(Py_TYPE(pyObj), PySideClassInfo_TypeF()) != 0;
 }
 
-QMap<QByteArray, QByteArray> getMap(PyObject *obj)
+ClassInfoList getClassInfoList(PyObject *decorator)
 {
-    auto *pData = PySide::ClassDecorator::DecoratorPrivate::get<ClassInfoPrivate>(obj);
+    auto *pData = PySide::ClassDecorator::DecoratorPrivate::get<ClassInfoPrivate>(decorator);
     return pData->m_data;
 }
 
-} //namespace Property
-} //namespace PySide
+bool setClassInfo(PyTypeObject *type, const QByteArray &key,
+                  const QByteArray &value)
+{
+    auto *userData = PySide::retrieveTypeUserData(type);
+    const bool result = userData != nullptr;
+    if (result) {
+        PySide::MetaObjectBuilder &mo = userData->mo;
+        mo.addInfo(key, value);
+    }
+    return result;
+}
+
+bool setClassInfo(PyTypeObject *type, const ClassInfoList &list)
+{
+    auto *userData = PySide::retrieveTypeUserData(type);
+    const bool result = userData != nullptr;
+    if (result) {
+        PySide::MetaObjectBuilder &mo = userData->mo;
+        for (const auto &info : list)
+            mo.addInfo(info.key.constData(), info.value.constData());
+    }
+    return result;
+}
+
+} //namespace PySide::ClassInfo
diff --git a/sources/pyside6/libpyside/pysideclassinfo.h b/sources/pyside6/libpyside/pysideclassinfo.h
index ecc2affbb..e04865829 100644
--- a/sources/pyside6/libpyside/pysideclassinfo.h
+++ b/sources/pyside6/libpyside/pysideclassinfo.h
@@ -8,15 +8,26 @@
 
 #include <sbkpython.h>
 
-#include <QtCore/QMap>
 #include <QtCore/QByteArray>
+#include <QtCore/QList>
 
-namespace PySide { namespace ClassInfo {
+namespace PySide::ClassInfo {
+
+struct ClassInfo
+{
+    QByteArray key;
+    QByteArray value;
+};
+
+using ClassInfoList = QList<ClassInfo>;
 
 PYSIDE_API bool checkType(PyObject* pyObj);
-PYSIDE_API QMap<QByteArray, QByteArray> getMap(PyObject *obj);
+PYSIDE_API ClassInfoList getClassInfoList(PyObject *decorator);
+
+PYSIDE_API bool setClassInfo(PyTypeObject *type, const QByteArray &key,
+                             const QByteArray &value);
+PYSIDE_API bool setClassInfo(PyTypeObject *type, const ClassInfoList &list);
 
-} //namespace ClassInfo
-} //namespace PySide
+} // namespace PySide::ClassInfo
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideclassinfo_p.h b/sources/pyside6/libpyside/pysideclassinfo_p.h
index 7d59e4be8..4ef456f76 100644
--- a/sources/pyside6/libpyside/pysideclassinfo_p.h
+++ b/sources/pyside6/libpyside/pysideclassinfo_p.h
@@ -8,7 +8,6 @@
 
 #include "pysideclassdecorator_p.h"
 #include "pysideclassinfo.h"
-#include "pysideclassinfo.h"
 
 #include <QtCore/QMetaObject>
 
@@ -20,7 +19,7 @@ extern PYSIDE_API PyTypeObject *PySideClassInfo_TypeF(void);
 
 } // extern "C"
 
-namespace PySide { namespace ClassInfo {
+namespace PySide::ClassInfo {
 
 class ClassInfoPrivate : public PySide::ClassDecorator::DecoratorPrivate
 {
@@ -29,7 +28,7 @@ public:
     int tp_init(PyObject *self, PyObject *args, PyObject *kwds) override;
     const char *name() const override;
 
-    QMap<QByteArray, QByteArray> m_data;
+    ClassInfoList m_data;
     bool m_alreadyWrapped = false;
 };
 
@@ -39,7 +38,6 @@ public:
 void init(PyObject* module);
 
 
-} // namespace ClassInfo
-} // namespace PySide
+} // namespace PySide::ClassInfo
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideinit.h b/sources/pyside6/libpyside/pysideinit.h
index 3a8f20158..c623a0d27 100644
--- a/sources/pyside6/libpyside/pysideinit.h
+++ b/sources/pyside6/libpyside/pysideinit.h
@@ -17,6 +17,9 @@ PYSIDE_API void init(PyObject *module);
 ///
 /// This is used in a standalone build, to inform QLibraryInfo of the Qt prefix
 /// (where Qt libraries are installed) so that plugins can be successfully loaded.
+///
+/// This is also used if PySide runs from inside a conda environment to solve
+/// conflicts with the qt.conf installed by Anaconda Qt packages.
 PYSIDE_API bool registerInternalQtConf();
 
 } //namespace PySide
diff --git a/sources/pyside6/libpyside/pysidemetafunction.cpp b/sources/pyside6/libpyside/pysidemetafunction.cpp
index eb2943ecf..e8173b97d 100644
--- a/sources/pyside6/libpyside/pysidemetafunction.cpp
+++ b/sources/pyside6/libpyside/pysidemetafunction.cpp
@@ -22,25 +22,30 @@ struct PySideMetaFunctionPrivate
 static void functionFree(void *);
 static PyObject *functionCall(PyObject *, PyObject *, PyObject *);
 
-static PyType_Slot PySideMetaFunctionType_slots[] = {
-    {Py_tp_call, reinterpret_cast<void *>(functionCall)},
-    {Py_tp_new, reinterpret_cast<void *>(PyType_GenericNew)},
-    {Py_tp_free, reinterpret_cast<void *>(functionFree)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideMetaFunctionType_spec = {
-    "2:PySide6.QtCore.MetaFunction",
-    sizeof(PySideMetaFunction),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideMetaFunctionType_slots,
-};
-
+static PyTypeObject *createMetaFunctionType()
+{
+    PyType_Slot PySideMetaFunctionType_slots[] = {
+        {Py_tp_call, reinterpret_cast<void *>(functionCall)},
+        {Py_tp_new, reinterpret_cast<void *>(PyType_GenericNew)},
+        {Py_tp_free, reinterpret_cast<void *>(functionFree)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PySideMetaFunctionType_spec = {
+        "2:PySide6.QtCore.MetaFunction",
+        sizeof(PySideMetaFunction),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideMetaFunctionType_slots,
+    };
+
+    return SbkType_FromSpec(&PySideMetaFunctionType_spec);
+}
 
 PyTypeObject *PySideMetaFunction_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&PySideMetaFunctionType_spec);
+    static auto *type = createMetaFunctionType();
     return type;
 }
 
diff --git a/sources/pyside6/libpyside/pysidemetafunction.h b/sources/pyside6/libpyside/pysidemetafunction.h
index 659a14161..26a2cfd68 100644
--- a/sources/pyside6/libpyside/pysidemetafunction.h
+++ b/sources/pyside6/libpyside/pysidemetafunction.h
@@ -22,7 +22,7 @@ extern "C"
     };
 }; //extern "C"
 
-namespace PySide { namespace MetaFunction {
+namespace PySide::MetaFunction {
 
 /**
  * This function creates a MetaFunction object
@@ -33,7 +33,6 @@ namespace PySide { namespace MetaFunction {
  **/
 PYSIDE_API PySideMetaFunction *newObject(QObject *obj, int methodIndex);
 
-} //namespace MetaFunction
-} //namespace PySide
+} //namespace PySide::MetaFunction
 
 #endif
diff --git a/sources/pyside6/libpyside/pysidemetafunction_p.h b/sources/pyside6/libpyside/pysidemetafunction_p.h
index db4aaa403..0207ec3a2 100644
--- a/sources/pyside6/libpyside/pysidemetafunction_p.h
+++ b/sources/pyside6/libpyside/pysidemetafunction_p.h
@@ -6,13 +6,13 @@
 
 #include <sbkpython.h>
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtconfigmacros.h>
 
 QT_BEGIN_NAMESPACE
 class QObject;
 QT_END_NAMESPACE
 
-namespace PySide { namespace MetaFunction {
+namespace PySide::MetaFunction {
 
     void init(PyObject *module);
     /**
@@ -20,7 +20,6 @@ namespace PySide { namespace MetaFunction {
      */
     bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal = nullptr);
 
-} //namespace MetaFunction
-} //namespace PySide
+} //namespace PySide::MetaFunction
 
 #endif
diff --git a/sources/pyside6/libpyside/pysidemetatype.h b/sources/pyside6/libpyside/pysidemetatype.h
index b7c531570..85e70f7c9 100644
--- a/sources/pyside6/libpyside/pysidemetatype.h
+++ b/sources/pyside6/libpyside/pysidemetatype.h
@@ -8,7 +8,7 @@
 
 #include <pysidemacros.h>
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtconfigmacros.h>
 
 QT_FORWARD_DECLARE_CLASS(QMetaType)
 
diff --git a/sources/pyside6/libpyside/pysideproperty.cpp b/sources/pyside6/libpyside/pysideproperty.cpp
index a4f90b8fd..3720815db 100644
--- a/sources/pyside6/libpyside/pysideproperty.cpp
+++ b/sources/pyside6/libpyside/pysideproperty.cpp
@@ -8,6 +8,7 @@
 #include "pysidesignal_p.h"
 
 #include <shiboken.h>
+#include <pep384ext.h>
 #include <signature.h>
 
 using namespace Shiboken;
@@ -58,34 +59,39 @@ static PyGetSetDef PySidePropertyType_getset[] = {
     {nullptr, nullptr, nullptr, nullptr, nullptr}
 };
 
-static PyType_Slot PySidePropertyType_slots[] = {
-    {Py_tp_dealloc, reinterpret_cast<void *>(qpropertyDeAlloc)},
-    {Py_tp_call, reinterpret_cast<void *>(qPropertyCall)},
-    {Py_tp_traverse, reinterpret_cast<void *>(qpropertyTraverse)},
-    {Py_tp_clear, reinterpret_cast<void *>(qpropertyClear)},
-    {Py_tp_methods, reinterpret_cast<void *>(PySidePropertyMethods)},
-    {Py_tp_init, reinterpret_cast<void *>(qpropertyTpInit)},
-    {Py_tp_new, reinterpret_cast<void *>(qpropertyTpNew)},
-    {Py_tp_getset, PySidePropertyType_getset},
-    {Py_tp_del, reinterpret_cast<void *>(PyObject_GC_Del)},
-    {0, nullptr}
-};
+static PyTypeObject *createPropertyType()
+{
+    PyType_Slot PySidePropertyType_slots[] = {
+        {Py_tp_dealloc, reinterpret_cast<void *>(qpropertyDeAlloc)},
+        {Py_tp_call, reinterpret_cast<void *>(qPropertyCall)},
+        {Py_tp_traverse, reinterpret_cast<void *>(qpropertyTraverse)},
+        {Py_tp_clear, reinterpret_cast<void *>(qpropertyClear)},
+        {Py_tp_methods, reinterpret_cast<void *>(PySidePropertyMethods)},
+        {Py_tp_init, reinterpret_cast<void *>(qpropertyTpInit)},
+        {Py_tp_new, reinterpret_cast<void *>(qpropertyTpNew)},
+        {Py_tp_getset, PySidePropertyType_getset},
+        {Py_tp_del, reinterpret_cast<void *>(PyObject_GC_Del)},
+        {0, nullptr}
+    };
 
-static PyType_Spec PySidePropertyType_spec = {
-    "2:PySide6.QtCore.Property",
-    sizeof(PySideProperty),
-    0,
-    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_BASETYPE,
-    PySidePropertyType_slots,
-};
+    PyType_Spec PySidePropertyType_spec = {
+        "2:PySide6.QtCore.Property",
+        sizeof(PySideProperty),
+        0,
+        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_BASETYPE,
+        PySidePropertyType_slots,
+    };
 
+    return SbkType_FromSpec(&PySidePropertyType_spec);
+}
 
 PyTypeObject *PySideProperty_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&PySidePropertyType_spec);
+    static auto *type = createPropertyType();
     return type;
 }
 
+PySidePropertyPrivate::PySidePropertyPrivate() noexcept = default;
 PySidePropertyPrivate::~PySidePropertyPrivate() = default;
 
 PyObject *PySidePropertyPrivate::getValue(PyObject *source)
@@ -137,20 +143,29 @@ void PySidePropertyPrivate::metaCall(PyObject *source, QMetaObject::Call call, v
 {
     switch (call) {
     case QMetaObject::ReadProperty: {
-        Shiboken::Conversions::SpecificConverter converter(typeName);
-        Q_ASSERT(converter);
-        if (PyObject *value = getValue(source)) {
-            converter.toCpp(value, args[0]);
-            Py_DECREF(value);
+        AutoDecRef value(getValue(source));
+        auto *obValue = value.object();
+        if (obValue) {
+            Conversions::SpecificConverter converter(typeName);
+            if (converter) {
+                converter.toCpp(obValue, args[0]);
+            } else {
+                // PYSIDE-2160: Report an unknown type name to the caller `qtPropertyMetacall`.
+                PyErr_SetObject(PyExc_StopIteration, obValue);
+            }
         }
     }
         break;
 
     case QMetaObject::WriteProperty: {
-        Shiboken::Conversions::SpecificConverter converter(typeName);
-        Q_ASSERT(converter);
-        Shiboken::AutoDecRef value(converter.toPython(args[0]));
-        setValue(source, value);
+        Conversions::SpecificConverter converter(typeName);
+        if (converter) {
+            AutoDecRef value(converter.toPython(args[0]));
+            setValue(source, value);
+        } else {
+            // PYSIDE-2160: Report an unknown type name to the caller `qtPropertyMetacall`.
+            PyErr_SetNone(PyExc_StopIteration);
+        }
     }
         break;
 
@@ -165,14 +180,14 @@ void PySidePropertyPrivate::metaCall(PyObject *source, QMetaObject::Call call, v
 
 static PyObject *qpropertyTpNew(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */)
 {
-    PySideProperty *me = reinterpret_cast<PySideProperty *>(subtype->tp_alloc(subtype, 0));
+    auto *me = PepExt_TypeCallAlloc<PySideProperty>(subtype, 0);
     me->d = new PySidePropertyPrivate;
     return reinterpret_cast<PyObject *>(me);
 }
 
 static int qpropertyTpInit(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    PyObject *type = nullptr;
+    PyObject *type{};
     auto data = reinterpret_cast<PySideProperty *>(self);
     PySidePropertyPrivate *pData = data->d;
 
@@ -181,6 +196,13 @@ static int qpropertyTpInit(PyObject *self, PyObject *args, PyObject *kwds)
                                    "user", "constant", "final", nullptr};
     char *doc{};
 
+    Py_CLEAR(pData->pyTypeObject);
+    Py_CLEAR(pData->fget);
+    Py_CLEAR(pData->fset);
+    Py_CLEAR(pData->freset);
+    Py_CLEAR(pData->fdel);
+    Py_CLEAR(pData->notify);
+
     if (!PyArg_ParseTupleAndKeywords(args, kwds,
                                      "O|OOOOsObbbbbb:QtCore.Property",
                                      const_cast<char **>(kwlist),
@@ -237,7 +259,7 @@ static void qpropertyDeAlloc(PyObject *self)
         Py_DECREF(Py_TYPE(self));
     }
     PyObject_GC_UnTrack(self);
-    Py_TYPE(self)->tp_free(self);
+    PepExt_TypeCallFree(self);
 }
 
 // Create a copy of the property to prevent the @property.setter from modifying
@@ -246,7 +268,7 @@ static void qpropertyDeAlloc(PyObject *self)
 static PyObject *
 _property_copy(PyObject *old, PyObject *get, PyObject *set, PyObject *reset, PyObject *del)
 {
-    PySideProperty *pold = reinterpret_cast<PySideProperty *>(old);
+    auto *pold = reinterpret_cast<PySideProperty *>(old);
     PySidePropertyPrivate *pData = pold->d;
 
     AutoDecRef type(PyObject_Type(old));
@@ -400,6 +422,7 @@ static int qpropertyTraverse(PyObject *self, visitproc visit, void *arg)
     Py_VISIT(data->freset);
     Py_VISIT(data->fdel);
     Py_VISIT(data->notify);
+    Py_VISIT(data->pyTypeObject);
     return 0;
 }
 
@@ -414,7 +437,7 @@ static int qpropertyClear(PyObject *self)
     Py_CLEAR(data->freset);
     Py_CLEAR(data->fdel);
     Py_CLEAR(data->notify);
-    Py_XDECREF(data->pyTypeObject);
+    Py_CLEAR(data->pyTypeObject);
 
     delete data;
     reinterpret_cast<PySideProperty *>(self)->d = nullptr;
@@ -423,16 +446,14 @@ static int qpropertyClear(PyObject *self)
 
 } // extern "C"
 
-namespace {
-
 static PyObject *getFromType(PyTypeObject *type, PyObject *name)
 {
-    PyObject *attr = nullptr;
-    attr = PyDict_GetItem(type->tp_dict, name);
+    AutoDecRef tpDict(PepType_GetDict(type));
+    auto *attr = PyDict_GetItem(tpDict.object(), name);
     if (!attr) {
         PyObject *bases = type->tp_bases;
-        int size = PyTuple_GET_SIZE(bases);
-        for(int i=0; i < size; i++) {
+        const Py_ssize_t size = PyTuple_GET_SIZE(bases);
+        for (Py_ssize_t i = 0; i < size; ++i) {
             PyObject *base = PyTuple_GET_ITEM(bases, i);
             attr = getFromType(reinterpret_cast<PyTypeObject *>(base), name);
             if (attr)
@@ -442,10 +463,7 @@ static PyObject *getFromType(PyTypeObject *type, PyObject *name)
     return attr;
 }
 
-} //namespace
-
-
-namespace PySide { namespace Property {
+namespace PySide::Property {
 
 static const char *Property_SignatureStrings[] = {
     "PySide6.QtCore.Property(self,type:type,fget:typing.Callable=None,fset:typing.Callable=None,"
@@ -457,6 +475,7 @@ static const char *Property_SignatureStrings[] = {
     "PySide6.QtCore.Property.read(self,fget:typing.Callable)->PySide6.QtCore.Property",
     "PySide6.QtCore.Property.setter(self,fset:typing.Callable)->PySide6.QtCore.Property",
     "PySide6.QtCore.Property.write(self,fset:typing.Callable)->PySide6.QtCore.Property",
+    "PySide6.QtCore.Property.__call__(self, func:typing.Callable)->PySide6.QtCore.Property",
     nullptr}; // Sentinel
 
 void init(PyObject *module)
@@ -560,9 +579,8 @@ bool isFinal(const PySideProperty *self)
 const char *getNotifyName(PySideProperty *self)
 {
     if (self->d->notifySignature.isEmpty()) {
-        PyObject *str = PyObject_Str(self->d->notify);
+        AutoDecRef str(PyObject_Str(self->d->notify));
         self->d->notifySignature = Shiboken::String::toCString(str);
-        Py_DECREF(str);
     }
 
     return self->d->notifySignature.isEmpty()
@@ -579,5 +597,4 @@ PyObject *getTypeObject(const PySideProperty *self)
     return self->d->pyTypeObject;
 }
 
-} //namespace Property
-} //namespace PySide
+} //namespace PySide::Property
diff --git a/sources/pyside6/libpyside/pysideproperty.h b/sources/pyside6/libpyside/pysideproperty.h
index 5e4e89fcf..a572efe45 100644
--- a/sources/pyside6/libpyside/pysideproperty.h
+++ b/sources/pyside6/libpyside/pysideproperty.h
@@ -23,7 +23,7 @@ extern "C"
     };
 };
 
-namespace PySide { namespace Property {
+namespace PySide::Property {
 
 PYSIDE_API bool checkType(PyObject *pyObj);
 
@@ -68,7 +68,6 @@ PYSIDE_API PySideProperty *getObject(PyObject *source, PyObject *name);
 
 PYSIDE_API void setTypeName(PySideProperty *self, const char *typeName);
 
-} //namespace Property
-} //namespace PySide
+} //namespace PySide::Property
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideproperty_p.h b/sources/pyside6/libpyside/pysideproperty_p.h
index 95c716ca5..10cb3ce87 100644
--- a/sources/pyside6/libpyside/pysideproperty_p.h
+++ b/sources/pyside6/libpyside/pysideproperty_p.h
@@ -10,6 +10,7 @@
 #include <pysidemacros.h>
 
 #include <QtCore/QByteArray>
+#include <QtCore/qtclasshelpermacros.h>
 #include <QtCore/QMetaObject>
 
 struct PySideProperty;
@@ -17,6 +18,10 @@ struct PySideProperty;
 class PYSIDE_API PySidePropertyPrivate
 {
 public:
+
+    Q_DISABLE_COPY_MOVE(PySidePropertyPrivate)
+
+    PySidePropertyPrivate() noexcept;
     virtual ~PySidePropertyPrivate();
 
     virtual void metaCall(PyObject *source, QMetaObject::Call call, void **args);
@@ -45,7 +50,7 @@ public:
     bool final = false;
 };
 
-namespace PySide { namespace Property {
+namespace PySide::Property {
 
 /**
  * Init PySide QProperty support system
@@ -159,7 +164,6 @@ bool isFinal(const PySideProperty* self);
 /// @return type object
 PyObject *getTypeObject(const PySideProperty* self);
 
-} // namespace Property
-} // namespace PySide
+} // namespace PySide::Property
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideqenum.cpp b/sources/pyside6/libpyside/pysideqenum.cpp
index 3f374b702..c0479160f 100644
--- a/sources/pyside6/libpyside/pysideqenum.cpp
+++ b/sources/pyside6/libpyside/pysideqenum.cpp
@@ -97,7 +97,7 @@ static bool is_module_code()
 
 } // extern "C"
 
-namespace PySide { namespace QEnum {
+namespace PySide::QEnum {
 
 static std::map<int, PyObject *> enumCollector;
 
@@ -191,8 +191,7 @@ std::vector<PyObject *> resolveDelayedQEnums(PyTypeObject *containerType)
     return result;
 }
 
-} // namespace Enum
-} // namespace Shiboken
+} // namespace Shiboken::Enum
 
 //
 ///////////////////////////////////////////////////////////////
diff --git a/sources/pyside6/libpyside/pysideqenum.h b/sources/pyside6/libpyside/pysideqenum.h
index 459c2b1f0..c3483e63e 100644
--- a/sources/pyside6/libpyside/pysideqenum.h
+++ b/sources/pyside6/libpyside/pysideqenum.h
@@ -7,7 +7,7 @@
 #include <pysidemacros.h>
 #include <vector>
 
-namespace PySide { namespace QEnum {
+namespace PySide::QEnum {
 
 // PYSIDE-957: Support the QEnum macro
 PYSIDE_API PyObject *QEnumMacro(PyObject *, bool);
@@ -15,7 +15,6 @@ PYSIDE_API int isFlag(PyObject *);
 PYSIDE_API std::vector<PyObject *> resolveDelayedQEnums(PyTypeObject *);
 PYSIDE_API void init();
 
-} // namespace QEnum
-} // namespace PySide
+} // namespace PySide::QEnum
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideqflags.cpp b/sources/pyside6/libpyside/pysideqflags.cpp
deleted file mode 100644
index 965d843c1..000000000
--- a/sources/pyside6/libpyside/pysideqflags.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright (C) 2016 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-
-#include "pysideqflags.h"
-
-#include <autodecref.h>
-#include <sbkenum.h>
-#include <sbkenum_p.h>
-
-extern "C" {
-    struct SbkConverter;
-
-    struct PySideQFlagsTypePrivate
-    {
-        SbkConverter *converter;
-        // PYSIDE-1735: These fields are just there for comatibility with the enumstructure.
-        //              We need to switch between flags and enum at runtine.
-        //              This will vanish completely when we no longer support two implementations.
-        const char *_cppName;
-        PyTypeObject *_replacementType;
-    };
-    /**
-     * Type of all QFlags
-     */
-    struct PySideQFlagsType
-    {
-        PyTypeObject type;
-    };
-
-    #define PYSIDE_QFLAGS(X) reinterpret_cast<PySideQFlagsObject *>(X)
-
-    PyObject *PySideQFlags_tp_new(PyTypeObject *type, PyObject *args, PyObject * /* kwds */)
-    {
-        long val = 0;
-        if (PyTuple_GET_SIZE(args)) {
-            PyObject *arg = PyTuple_GET_ITEM(args, 0);
-            if (Shiboken::isShibokenEnum(arg)) {// faster call
-                val = Shiboken::Enum::getValue(arg);
-            } else if (PyNumber_Check(arg)) {
-                Shiboken::AutoDecRef number(PyNumber_Long(arg));
-                val = PyLong_AsLong(number);
-            } else {
-                PyErr_SetString(PyExc_TypeError,"QFlags must be created using enums or numbers.");
-                return nullptr;
-            }
-        }
-        PySideQFlagsObject *self = PyObject_New(PySideQFlagsObject, type);
-        self->ob_value = val;
-        return reinterpret_cast<PyObject *>(self);
-    }
-
-    static long getNumberValue(PyObject *v)
-    {
-        Shiboken::AutoDecRef number(PyNumber_Long(v));
-        return PyLong_AsLong(number);
-    }
-
-    static PyObject *qflag_nb_int(PyObject *self)
-    {
-        return PyLong_FromLong(reinterpret_cast<PySideQFlagsObject*>(self)->ob_value);
-    }
-
-    PyObject *PySideQFlags_tp_richcompare(PyObject *self, PyObject *other, int op)
-    {
-        int result = 0;
-        if (!PyNumber_Check(other)) {
-            switch (op) {
-            case Py_EQ:
-                Py_RETURN_FALSE;
-            case Py_NE:
-                Py_RETURN_TRUE;
-            default:
-                Py_RETURN_NOTIMPLEMENTED;
-            }
-        }
-
-        if (self == other) {
-            switch (op) {
-            case Py_EQ:
-            case Py_LE:
-            case Py_GE:
-                result = 1;
-                break;
-            }
-        } else  {
-            const long valA = PYSIDE_QFLAGS(self)->ob_value;
-            const long valB = getNumberValue(other);
-            switch (op) {
-            case Py_EQ:
-                result = (valA == valB);
-                break;
-            case Py_NE:
-                result = (valA != valB);
-                break;
-            case Py_LE:
-                result = (valA <= valB);
-                break;
-            case Py_GE:
-                result = (valA >= valB);
-                break;
-            case Py_LT:
-                result = (valA < valB);
-                break;
-            case Py_GT:
-                result = (valA > valB);
-                break;
-            default:
-                PyErr_BadArgument();
-                return nullptr;
-            }
-        }
-        if (result)
-            Py_RETURN_TRUE;
-        Py_RETURN_FALSE;
-    }
-
-    static void PySideQFlags_tp_dealloc(PyObject *self)
-    {
-        auto *flagsType = reinterpret_cast<PySideQFlagsType *>(self);
-        PepType_PFTP_delete(flagsType);
-        Sbk_object_dealloc(self);
-    }
-
-    /// PYSIDE-1735: Support for redirection to the new Python enum.Flag .
-    static PyTypeObject *getEnumMeta()
-    {
-        static auto *mod = PyImport_ImportModule("enum");
-        if (mod) {
-            static auto *EnumMeta = PyObject_GetAttrString(mod, "EnumMeta");
-            if (EnumMeta)
-                return reinterpret_cast<PyTypeObject *>(EnumMeta);
-        }
-        Py_FatalError("Python module 'enum' not found");
-        return nullptr;
-    }
-}
-
-namespace PySide
-{
-namespace QFlags
-{
-    static PyType_Slot SbkNewQFlagsType_slots[] = {
-        {Py_nb_bool, nullptr},
-        {Py_nb_invert, nullptr},
-        {Py_nb_and, nullptr},
-        {Py_nb_xor, nullptr},
-        {Py_nb_or, nullptr},
-        {Py_nb_int, reinterpret_cast<void*>(qflag_nb_int)},
-        {Py_nb_index, reinterpret_cast<void*>(qflag_nb_int)},   // same as nb_int
-        {Py_tp_new, reinterpret_cast<void *>(PySideQFlags_tp_new)},
-        {Py_tp_richcompare, reinterpret_cast<void *>(PySideQFlags_tp_richcompare)},
-        {Py_tp_dealloc, reinterpret_cast<void *>(PySideQFlags_tp_dealloc)},
-        {0, nullptr}
-    };
-    static PyType_Spec SbkNewQFlagsType_spec = {
-        "missing QFlags name", // to be inserted later
-        sizeof(PySideQFlagsObject),
-        0,
-        Py_TPFLAGS_DEFAULT,
-        SbkNewQFlagsType_slots,
-    };
-
-    PyTypeObject *create(const char *name, PyType_Slot numberMethods[])
-    {
-        char qualname[200];
-        // PYSIDE-747: Here we insert now the full class name.
-        strcpy(qualname, name);
-        // Careful: SbkType_FromSpec does not allocate the string.
-        PyType_Spec newspec;
-        newspec.name = strdup(qualname);
-        newspec.basicsize = SbkNewQFlagsType_spec.basicsize;
-        newspec.itemsize = SbkNewQFlagsType_spec.itemsize;
-        newspec.flags = SbkNewQFlagsType_spec.flags;
-        int idx = -1;
-        while (numberMethods[++idx].slot) {
-            assert(SbkNewQFlagsType_slots[idx].slot == numberMethods[idx].slot);
-            SbkNewQFlagsType_slots[idx].pfunc = numberMethods[idx].pfunc;
-        }
-        newspec.slots = SbkNewQFlagsType_spec.slots;
-        return SbkType_FromSpec(&newspec);
-    }
-
-    PySideQFlagsObject *newObject(long value, PyTypeObject *type)
-    {
-        // PYSIDE-1735: In case of a new Python enum, we must redirect to the
-        //              enum.Flag implementation.
-        static PyTypeObject *enumMeta = getEnumMeta();
-        if (Py_TYPE(type) == enumMeta) {
-            // We are cheating: This is an enum type.
-            auto *flag_enum = PyObject_CallFunction(reinterpret_cast<PyObject *>(type), "i", value);
-            return reinterpret_cast<PySideQFlagsObject *>(flag_enum);
-        }
-        PySideQFlagsObject *qflags = PyObject_New(PySideQFlagsObject, type);
-        qflags->ob_value = value;
-        return qflags;
-    }
-
-    long getValue(PySideQFlagsObject *self)
-    {
-        return self->ob_value;
-    }
-}
-}
diff --git a/sources/pyside6/libpyside/pysideqflags.h b/sources/pyside6/libpyside/pysideqflags.h
deleted file mode 100644
index aca823edd..000000000
--- a/sources/pyside6/libpyside/pysideqflags.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (C) 2016 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-
-#ifndef PYSIDE_QFLAGS_H
-#define PYSIDE_QFLAGS_H
-
-#include <sbkpython.h>
-#include "pysidemacros.h"
-
-
-extern "C"
-{
-    struct PYSIDE_API PySideQFlagsObject {
-        PyObject_HEAD
-        long ob_value;
-    };
-
-    PYSIDE_API PyObject* PySideQFlags_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
-    PYSIDE_API PyObject* PySideQFlags_tp_richcompare(PyObject *self, PyObject *other, int op);
-}
-
-
-namespace PySide
-{
-namespace QFlags
-{
-    /**
-     * Creates a new QFlags type.
-     */
-    PYSIDE_API PyTypeObject *create(const char* name, PyType_Slot *numberMethods);
-    /**
-     * Creates a new QFlags instance of type \p type and value \p value.
-     */
-    PYSIDE_API PySideQFlagsObject* newObject(long value, PyTypeObject* type);
-    /**
-     * Returns the value held by a QFlag.
-     */
-    PYSIDE_API long getValue(PySideQFlagsObject* self);
-}
-}
-
-#endif
-
diff --git a/sources/pyside6/libpyside/pysideqhash.h b/sources/pyside6/libpyside/pysideqhash.h
index e6e1392a9..ae2d295f6 100644
--- a/sources/pyside6/libpyside/pysideqhash.h
+++ b/sources/pyside6/libpyside/pysideqhash.h
@@ -14,7 +14,7 @@ namespace PySide
 /// Hash function used to enable hash on objects not supported by the native Qt
 /// library which have a toString() function.
 template<class T>
-inline Py_ssize_t hash(const T& value)
+[[deprecated]] inline Py_ssize_t hash(const T& value)
 {
     return qHash(value.toString());
 }
diff --git a/sources/pyside6/libpyside/pysideqobject.h b/sources/pyside6/libpyside/pysideqobject.h
index 96834635d..f81c50399 100644
--- a/sources/pyside6/libpyside/pysideqobject.h
+++ b/sources/pyside6/libpyside/pysideqobject.h
@@ -8,7 +8,9 @@
 
 #include <pysidemacros.h>
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtclasshelpermacros.h>
+
+#include <cstddef>
 
 QT_FORWARD_DECLARE_CLASS(QObject)
 QT_FORWARD_DECLARE_STRUCT(QMetaObject)
@@ -22,7 +24,8 @@ namespace PySide
 /// \param metaObj QMetaObject of \p qObj.
 /// \param kwds key->value dictonary.
 /// \return True if everything goes well, false with a Python error set otherwise.
-PYSIDE_API bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds);
+PYSIDE_API bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj,
+                                 PyObject *kwds, bool allowErrors);
 
 PYSIDE_API void initDynamicMetaObject(PyTypeObject *type, const QMetaObject *base,
                                       std::size_t cppObjSize);
@@ -40,13 +43,14 @@ PYSIDE_API bool isQObjectDerived(PyTypeObject *pyType, bool raiseError);
 /// Convenience to convert a PyObject to QObject
 PYSIDE_API QObject *convertToQObject(PyObject *object, bool raiseError);
 
-/// Check for properties and signals registered on MetaObject and return these
+/// Check for properties and signals registered on MetaObject and return these.
+/// Also handle Python properties when true_property was selected.
 /// \param cppSelf Is the QObject which contains the metaobject
 /// \param self Python object of cppSelf
 /// \param name Name of the argument which the function will try retrieve from MetaData
 /// \return The Python object which contains the Data obtained in metaObject or the Python
-/// attribute related with name
-PYSIDE_API PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name);
+/// method pulled out of a Python property.
+PYSIDE_API PyObject *getHiddenDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name);
 
 /// Mutex for accessing QObject memory helpers from multiple threads
 PYSIDE_API QMutex &nextQObjectMemoryAddrMutex();
diff --git a/sources/pyside6/libpyside/pysideqslotobject_p.cpp b/sources/pyside6/libpyside/pysideqslotobject_p.cpp
new file mode 100644
index 000000000..914be898a
--- /dev/null
+++ b/sources/pyside6/libpyside/pysideqslotobject_p.cpp
@@ -0,0 +1,36 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "pysideqslotobject_p.h"
+
+#include <autodecref.h>
+#include <gilstate.h>
+
+namespace PySide
+{
+
+void PySideQSlotObject::impl(int which, QSlotObjectBase *this_, QObject *receiver,
+                             void **args, bool *ret)
+{
+    auto self = static_cast<PySideQSlotObject *>(this_);
+    switch (which) {
+    case Destroy:
+        delete self;
+        break;
+    case Call:
+        {
+            Shiboken::GilState state;
+            Shiboken::AutoDecRef arglist(PyTuple_New(0));
+            Shiboken::AutoDecRef ret(PyObject_CallObject(self->callable, arglist));
+            break;
+        }
+    case Compare:
+    case NumOperations:
+        Q_UNUSED(receiver);
+        Q_UNUSED(args);
+        Q_UNUSED(ret);
+        break;
+    }
+}
+
+} // namespace PySide
diff --git a/sources/pyside6/libpyside/pysideqslotobject_p.h b/sources/pyside6/libpyside/pysideqslotobject_p.h
new file mode 100644
index 000000000..d7d258505
--- /dev/null
+++ b/sources/pyside6/libpyside/pysideqslotobject_p.h
@@ -0,0 +1,39 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef PYSIDEQSLOTOBJECT_P_H
+#define PYSIDEQSLOTOBJECT_P_H
+
+#include "pysidemacros.h"
+#include <sbkpython.h>
+
+#include <QtCore/QObject>
+#include <QtCore/qobjectdefs.h>
+
+namespace PySide
+{
+
+class PySideQSlotObject : public QtPrivate::QSlotObjectBase
+{
+    PyObject *callable;
+
+    static void impl(int which, QSlotObjectBase *this_, QObject *receiver, void **args, bool *ret);
+
+public:
+    PySideQSlotObject(PyObject *callable) : QtPrivate::QSlotObjectBase(&impl), callable(callable)
+    {
+        Py_INCREF(callable);
+    }
+
+    ~PySideQSlotObject()
+    {
+        auto gstate = PyGILState_Ensure();
+        Py_DECREF(callable);
+        PyGILState_Release(gstate);
+    }
+};
+
+
+} // namespace PySide
+
+#endif // PYSIDEQSLOTOBJECT_P_H
diff --git a/sources/pyside6/libpyside/pysidesignal.cpp b/sources/pyside6/libpyside/pysidesignal.cpp
index d7d38d081..35a6e7ef9 100644
--- a/sources/pyside6/libpyside/pysidesignal.cpp
+++ b/sources/pyside6/libpyside/pysidesignal.cpp
@@ -4,8 +4,10 @@
 #include <sbkpython.h>
 #include "pysidesignal.h"
 #include "pysidesignal_p.h"
+#include "pysideqobject.h"
 #include "pysideutils.h"
 #include "pysidestaticstrings.h"
+#include "pysideweakref.h"
 #include "signalmanager.h"
 
 #include <shiboken.h>
@@ -16,14 +18,18 @@
 #include <QtCore/QObject>
 #include <QtCore/QMetaMethod>
 #include <QtCore/QMetaObject>
+#include <pep384ext.h>
 #include <signature.h>
 
 #include <algorithm>
+#include <optional>
 #include <utility>
 #include <cstring>
 
 #define QT_SIGNAL_SENTINEL '2'
 
+using namespace Qt::StringLiterals;
+
 QDebug operator<<(QDebug debug, const PySideSignalData::Signature &s)
 {
     QDebugStateSaver saver(debug);
@@ -43,8 +49,8 @@ QDebug operator<<(QDebug debug, const PySideSignalData &d)
     debug.nospace();
     debug << "PySideSignalData(\"" << d.signalName << "\", "
           << d.signatures;
-    if (d.signalArguments)
-        debug << ", signalArguments=\"" << *d.signalArguments << '"';
+    if (!d.signalArguments.isEmpty())
+        debug << ", signalArguments=" << d.signalArguments;
     debug << ')';
     return debug;
 }
@@ -74,29 +80,35 @@ static bool connection_Check(PyObject *o)
     return std::strcmp(o->ob_type->tp_name, typeName.constData()) == 0;
 }
 
-namespace PySide {
-namespace Signal {
-    //aux
-    class SignalSignature {
-    public:
-        SignalSignature() = default;
-        explicit SignalSignature(QByteArray parameterTypes) :
-            m_parameterTypes(std::move(parameterTypes)) {}
-        explicit SignalSignature(QByteArray parameterTypes, QMetaMethod::Attributes attributes) :
-            m_parameterTypes(std::move(parameterTypes)),
-            m_attributes(attributes) {}
-
-        QByteArray m_parameterTypes;
-        QMetaMethod::Attributes m_attributes = QMetaMethod::Compatibility;
-    };
+static std::optional<QByteArrayList> parseArgumentNames(PyObject *argArguments)
+{
+    QByteArrayList result;
+    if (argArguments == nullptr)
+        return result;
+    // Prevent a string from being split into a sequence of characters
+    if (PySequence_Check(argArguments) == 0 || PyUnicode_Check(argArguments) != 0)
+        return std::nullopt;
+    const Py_ssize_t argumentSize = PySequence_Size(argArguments);
+    result.reserve(argumentSize);
+    for (Py_ssize_t i = 0; i < argumentSize; ++i) {
+        Shiboken::AutoDecRef item(PySequence_GetItem(argArguments, i));
+        if (PyUnicode_Check(item.object()) == 0)
+            return std::nullopt;
+        Shiboken::AutoDecRef strObj(PyUnicode_AsUTF8String(item));
+        const char *s = PyBytes_AsString(strObj);
+        if (s == nullptr)
+            return std::nullopt;
+        result.append(QByteArray(s));
+    }
+    return result;
+}
 
+namespace PySide::Signal {
     static QByteArray buildSignature(const QByteArray &, const QByteArray &);
-    static void appendSignature(PySideSignal *, const SignalSignature &);
     static void instanceInitialize(PySideSignalInstance *, PyObject *, PySideSignal *, PyObject *, int);
-    static QByteArray parseSignature(PyObject *);
+    static PySideSignalData::Signature parseSignature(PyObject *);
     static PyObject *buildQtCompatible(const QByteArray &);
-}
-}
+} // PySide::Signal
 
 extern "C"
 {
@@ -128,54 +140,64 @@ static PyMethodDef MetaSignal_tp_methods[] = {
     {nullptr, nullptr, 0, nullptr}
 };
 
-static PyType_Slot PySideMetaSignalType_slots[] = {
-    {Py_tp_methods, reinterpret_cast<void *>(MetaSignal_tp_methods)},
-    {Py_tp_base,    reinterpret_cast<void *>(&PyType_Type)},
-    {Py_tp_free,    reinterpret_cast<void *>(PyObject_GC_Del)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideMetaSignalType_spec = {
-    "2:PySide6.QtCore.MetaSignal",
-    0,
-    // sizeof(PyHeapTypeObject) is filled in by SbkType_FromSpec
-    // which calls PyType_Ready which calls inherit_special.
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideMetaSignalType_slots,
-};
+static PyTypeObject *createMetaSignalType()
+{
+    PyType_Slot PySideMetaSignalType_slots[] = {
+        {Py_tp_methods, reinterpret_cast<void *>(MetaSignal_tp_methods)},
+        {Py_tp_base,    reinterpret_cast<void *>(&PyType_Type)},
+        {Py_tp_free,    reinterpret_cast<void *>(PyObject_GC_Del)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PySideMetaSignalType_spec = {
+        "2:PySide6.QtCore.MetaSignal",
+        0,
+        // sizeof(PyHeapTypeObject) is filled in by SbkType_FromSpec
+        // which calls PyType_Ready which calls inherit_special.
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideMetaSignalType_slots,
+    };
 
+    return SbkType_FromSpec(&PySideMetaSignalType_spec);
+}
 
 static PyTypeObject *PySideMetaSignal_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&PySideMetaSignalType_spec);
+    static auto *type = createMetaSignalType();
     return type;
 }
 
-static PyType_Slot PySideSignalType_slots[] = {
-    {Py_mp_subscript,   reinterpret_cast<void *>(signalGetItem)},
-    {Py_tp_getattro,    reinterpret_cast<void *>(signalGetAttr)},
-    {Py_tp_descr_get,   reinterpret_cast<void *>(signalDescrGet)},
-    {Py_tp_call,        reinterpret_cast<void *>(signalCall)},
-    {Py_tp_str,         reinterpret_cast<void *>(signalToString)},
-    {Py_tp_init,        reinterpret_cast<void *>(signalTpInit)},
-    {Py_tp_new,         reinterpret_cast<void *>(PyType_GenericNew)},
-    {Py_tp_free,        reinterpret_cast<void *>(signalFree)},
-    {Py_tp_dealloc,     reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideSignalType_spec = {
-    "2:PySide6.QtCore.Signal",
-    sizeof(PySideSignal),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideSignalType_slots,
-};
+static PyTypeObject *createSignalType()
+{
+    PyType_Slot PySideSignalType_slots[] = {
+        {Py_mp_subscript,   reinterpret_cast<void *>(signalGetItem)},
+        {Py_tp_getattro,    reinterpret_cast<void *>(signalGetAttr)},
+        {Py_tp_descr_get,   reinterpret_cast<void *>(signalDescrGet)},
+        {Py_tp_call,        reinterpret_cast<void *>(signalCall)},
+        {Py_tp_str,         reinterpret_cast<void *>(signalToString)},
+        {Py_tp_init,        reinterpret_cast<void *>(signalTpInit)},
+        {Py_tp_new,         reinterpret_cast<void *>(PyType_GenericNew)},
+        {Py_tp_free,        reinterpret_cast<void *>(signalFree)},
+        {Py_tp_dealloc,     reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PySideSignalType_spec = {
+        "2:PySide6.QtCore.Signal",
+        sizeof(PySideSignal),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideSignalType_slots,
+    };
 
+    return SbkType_FromSpecWithMeta(&PySideSignalType_spec, PySideMetaSignal_TypeF());
+}
 
 PyTypeObject *PySideSignal_TypeF(void)
 {
-    static auto *type = SbkType_FromSpecWithMeta(&PySideSignalType_spec, PySideMetaSignal_TypeF());
+    static auto *type = createSignalType();
     return type;
 }
 
@@ -184,7 +206,8 @@ static PyObject *signalInstanceRepr(PyObject *obSelf)
     auto *self = reinterpret_cast<PySideSignalInstance *>(obSelf);
     auto *typeName = Py_TYPE(obSelf)->tp_name;
     return Shiboken::String::fromFormat("<%s %s at %p>", typeName,
-                                        self->d->signature.constData(), obSelf);
+                                        self->d ? self->d->signature.constData()
+                                                : "(no signature)", obSelf);
 }
 
 static PyMethodDef SignalInstance_methods[] = {
@@ -195,28 +218,33 @@ static PyMethodDef SignalInstance_methods[] = {
     {nullptr, nullptr, 0, nullptr}  /* Sentinel */
 };
 
-static PyType_Slot PySideSignalInstanceType_slots[] = {
-    {Py_mp_subscript,   reinterpret_cast<void *>(signalInstanceGetItem)},
-    {Py_tp_call,        reinterpret_cast<void *>(signalInstanceCall)},
-    {Py_tp_methods,     reinterpret_cast<void *>(SignalInstance_methods)},
-    {Py_tp_repr,        reinterpret_cast<void *>(signalInstanceRepr)},
-    {Py_tp_new,         reinterpret_cast<void *>(PyType_GenericNew)},
-    {Py_tp_free,        reinterpret_cast<void *>(signalInstanceFree)},
-    {Py_tp_dealloc,     reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideSignalInstanceType_spec = {
-    "2:PySide6.QtCore.SignalInstance",
-    sizeof(PySideSignalInstance),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideSignalInstanceType_slots,
-};
+static PyTypeObject *createSignalInstanceType()
+{
+    PyType_Slot PySideSignalInstanceType_slots[] = {
+        {Py_mp_subscript,   reinterpret_cast<void *>(signalInstanceGetItem)},
+        {Py_tp_call,        reinterpret_cast<void *>(signalInstanceCall)},
+        {Py_tp_methods,     reinterpret_cast<void *>(SignalInstance_methods)},
+        {Py_tp_repr,        reinterpret_cast<void *>(signalInstanceRepr)},
+        {Py_tp_new,         reinterpret_cast<void *>(PyType_GenericNew)},
+        {Py_tp_free,        reinterpret_cast<void *>(signalInstanceFree)},
+        {Py_tp_dealloc,     reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
 
+    PyType_Spec PySideSignalInstanceType_spec = {
+        "2:PySide6.QtCore.SignalInstance",
+        sizeof(PySideSignalInstance),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideSignalInstanceType_slots,
+    };
+
+    return SbkType_FromSpec(&PySideSignalInstanceType_spec);
+}
 
 PyTypeObject *PySideSignalInstance_TypeF(void)
 {
-    static auto *type = SbkType_FromSpec(&PySideSignalInstanceType_spec);
+    static auto *type = createSignalInstanceType();
     return type;
 }
 
@@ -239,37 +267,23 @@ static int signalTpInit(PyObject *obSelf, PyObject *args, PyObject *kwds)
     if (argName)
         self->data->signalName = argName;
 
-    const Py_ssize_t argument_size =
-        argArguments != nullptr && PySequence_Check(argArguments)
-        ? PySequence_Size(argArguments) : 0;
-    if (argument_size > 0) {
-        self->data->signalArguments = new QByteArrayList();
-        self->data->signalArguments->reserve(argument_size);
-        for (Py_ssize_t i = 0; i < argument_size; ++i) {
-            Shiboken::AutoDecRef item(PySequence_GetItem(argArguments, i));
-            Shiboken::AutoDecRef strObj(PyUnicode_AsUTF8String(item));
-            if (char *s = PyBytes_AsString(strObj))
-                self->data->signalArguments->append(QByteArray(s));
-        }
+    auto argumentNamesOpt = parseArgumentNames(argArguments);
+    if (!argumentNamesOpt.has_value()) {
+        PyErr_SetString(PyExc_TypeError, "'arguments' must be a sequence of strings.");
+        return -1;
     }
+    self->data->signalArguments = argumentNamesOpt.value();
 
     for (Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
         PyObject *arg = PyTuple_GET_ITEM(args, i);
         if (PySequence_Check(arg) && !Shiboken::String::check(arg) && !PyEnumMeta_Check(arg)) {
             tupledArgs = true;
-            const auto sig = PySide::Signal::parseSignature(arg);
-            PySide::Signal::appendSignature(
-                        self,
-                        PySide::Signal::SignalSignature(sig));
+            self->data->signatures.append(PySide::Signal::parseSignature(arg));
         }
     }
 
-    if (!tupledArgs) {
-        const auto sig = PySide::Signal::parseSignature(args);
-        PySide::Signal::appendSignature(
-                    self,
-                    PySide::Signal::SignalSignature(sig));
-    }
+    if (!tupledArgs)
+        self->data->signatures.append(PySide::Signal::parseSignature(args));
 
     return 0;
 }
@@ -279,14 +293,13 @@ static void signalFree(void *vself)
     auto pySelf = reinterpret_cast<PyObject *>(vself);
     auto self = reinterpret_cast<PySideSignal *>(vself);
     if (self->data) {
-        delete self->data->signalArguments;
         delete self->data;
         self->data = nullptr;
     }
     Py_XDECREF(self->homonymousMethod);
     self->homonymousMethod = nullptr;
 
-    Py_TYPE(pySelf)->tp_base->tp_free(self);
+    PepExt_TypeCallFree(Py_TYPE(pySelf)->tp_base, self);
 }
 
 static PyObject *signalGetItem(PyObject *obSelf, PyObject *key)
@@ -294,7 +307,7 @@ static PyObject *signalGetItem(PyObject *obSelf, PyObject *key)
     auto self = reinterpret_cast<PySideSignal *>(obSelf);
     QByteArray sigKey;
     if (key) {
-        sigKey = PySide::Signal::parseSignature(key);
+        sigKey = PySide::Signal::parseSignature(key).signature;
     } else {
         sigKey = self->data == nullptr || self->data->signatures.isEmpty()
             ? PySide::Signal::voidType() : self->data->signatures.constFirst().signature;
@@ -303,9 +316,21 @@ static PyObject *signalGetItem(PyObject *obSelf, PyObject *key)
     return Shiboken::String::fromCString(sig.constData());
 }
 
-static PyObject *signalToString(PyObject *self)
+static PyObject *signalToString(PyObject *obSelf)
 {
-    return signalGetItem(self, nullptr);
+    auto self = reinterpret_cast<PySideSignal *>(obSelf);
+    QByteArray result;
+    if (self->data == nullptr || self->data->signatures.isEmpty()) {
+        result = "<invalid>"_ba;
+    } else {
+        for (const auto &signature : std::as_const(self->data->signatures)) {
+            if (!result.isEmpty())
+                result += "; "_ba;
+            result += PySide::Signal::buildSignature(self->data->signalName,
+                                                     signature.signature);
+        }
+    }
+    return Shiboken::String::fromCString(result.constData());
 }
 
 static PyObject *signalGetAttr(PyObject *obSelf, PyObject *name)
@@ -333,93 +358,119 @@ static void signalInstanceFree(void *vself)
     auto self = reinterpret_cast<PySideSignalInstance *>(vself);
 
     PySideSignalInstancePrivate *dataPvt = self->d;
+    if (dataPvt) {
+        Py_XDECREF(dataPvt->homonymousMethod);
 
-    Py_XDECREF(dataPvt->homonymousMethod);
-
-    if (dataPvt->next) {
-        Py_DECREF(dataPvt->next);
-        dataPvt->next = nullptr;
+        if (dataPvt->next) {
+            Py_DECREF(dataPvt->next);
+            dataPvt->next = nullptr;
+        }
+        delete dataPvt;
+        self->d = nullptr;
     }
-    delete dataPvt;
-    self->d = nullptr;
-    Py_TYPE(pySelf)->tp_base->tp_free(self);
+    self->deleted = true;
+    PepExt_TypeCallFree(Py_TYPE(pySelf)->tp_base, self);
 }
 
 // PYSIDE-1523: PyFunction_Check is not accepting compiled functions and
 // PyMethod_Check is not allowing compiled methods, therefore also lookup
 // "im_func" and "__code__" attributes, we allow for that with a dedicated
 // function handling both.
-static void extractFunctionArgumentsFromSlot(PyObject *slot,
-                                             PyObject *& function,
-                                             PepCodeObject *& objCode,
-                                             bool &isMethod,
-                                             QByteArray *functionName)
+
+struct FunctionArgumentsResult
 {
-    isMethod = PyMethod_Check(slot);
-    bool isFunction = PyFunction_Check(slot);
+    PyObject *function = nullptr;
+    PepCodeObject *objCode = nullptr;
+    PyObject *functionName = nullptr;
+    bool isMethod = false;
+};
 
-    function = nullptr;
-    objCode = nullptr;
+static FunctionArgumentsResult extractFunctionArgumentsFromSlot(PyObject *slot)
+{
+    FunctionArgumentsResult ret;
+    ret.isMethod = PyMethod_Check(slot);
+    const bool isFunction = PyFunction_Check(slot);
 
-    if (isMethod || isFunction) {
-        function = isMethod ? PyMethod_GET_FUNCTION(slot) : slot;
-        objCode = reinterpret_cast<PepCodeObject *>(PyFunction_GET_CODE(function));
+    if (ret.isMethod || isFunction) {
+        ret.function = ret.isMethod ? PyMethod_GET_FUNCTION(slot) : slot;
+        ret.objCode = reinterpret_cast<PepCodeObject *>(PyFunction_GET_CODE(ret.function));
+        ret.functionName = PepFunction_GetName(ret.function);
 
-        if (functionName != nullptr) {
-            *functionName = Shiboken::String::toCString(PepFunction_GetName(function));
-        }
     } else if (PySide::isCompiledMethod(slot)) {
         // PYSIDE-1523: PyFunction_Check and PyMethod_Check are not accepting compiled forms, we
         // just go by attributes.
-        isMethod = true;
-
-        function = PyObject_GetAttr(slot, PySide::PyName::im_func());
+        ret.isMethod = true;
 
+        ret.function = PyObject_GetAttr(slot, PySide::PySideName::im_func());
         // Not retaining a reference inline with what PyMethod_GET_FUNCTION does.
-        Py_DECREF(function);
+        Py_DECREF(ret.function);
 
-        if (functionName != nullptr) {
-            PyObject *name = PyObject_GetAttr(function, PySide::PyMagicName::name());
-            *functionName = Shiboken::String::toCString(name);
-            // Not retaining a reference inline with what PepFunction_GetName does.
-            Py_DECREF(name);
-        }
+        ret.functionName = PyObject_GetAttr(ret.function, PySide::PySideMagicName::name());
+        // Not retaining a reference inline with what PepFunction_GetName does.
+        Py_DECREF(ret.functionName);
 
-        objCode = reinterpret_cast<PepCodeObject *>(
-                    PyObject_GetAttr(function, PySide::PyMagicName::code()));
+        ret.objCode = reinterpret_cast<PepCodeObject *>(
+                    PyObject_GetAttr(ret.function, PySide::PySideMagicName::code()));
         // Not retaining a reference inline with what PyFunction_GET_CODE does.
-        Py_XDECREF(objCode);
+        Py_XDECREF(ret.objCode);
 
-        if (objCode == nullptr) {
-            // Should not happen, but lets handle it gracefully, maybe Nuitka one day
-            // makes these optional, or somebody defined a type named like it without
-            // it being actually being that.
-            function = nullptr;
-        }
+        // Should not happen, but lets handle it gracefully, maybe Nuitka one day
+        // makes these optional, or somebody defined a type named like it without
+        // it being actually being that.
+        if (ret.objCode == nullptr)
+            ret.function = nullptr;
     } else if (strcmp(Py_TYPE(slot)->tp_name, "compiled_function") == 0) {
-        isMethod = false;
-        function = slot;
-
-        if (functionName != nullptr) {
-            PyObject *name = PyObject_GetAttr(function, PySide::PyMagicName::name());
-            *functionName = Shiboken::String::toCString(name);
-            // Not retaining a reference inline with what PepFunction_GetName does.
-            Py_DECREF(name);
-        }
+        ret.isMethod = false;
+        ret.function = slot;
 
-        objCode = reinterpret_cast<PepCodeObject *>(
-                    PyObject_GetAttr(function, PySide::PyMagicName::code()));
+        ret.functionName = PyObject_GetAttr(ret.function, PySide::PySideMagicName::name());
+        // Not retaining a reference inline with what PepFunction_GetName does.
+        Py_DECREF(ret.functionName);
+
+        ret.objCode = reinterpret_cast<PepCodeObject *>(
+                    PyObject_GetAttr(ret.function, PySide::PySideMagicName::code()));
         // Not retaining a reference inline with what PyFunction_GET_CODE does.
-        Py_XDECREF(objCode);
+        Py_XDECREF(ret.objCode);
 
-        if (objCode == nullptr) {
-            // Should not happen, but lets handle it gracefully, maybe Nuitka one day
-            // makes these optional, or somebody defined a type named like it without
-            // it being actually being that.
-            function = nullptr;
-        }
+        // Should not happen, but lets handle it gracefully, maybe Nuitka one day
+        // makes these optional, or somebody defined a type named like it without
+        // it being actually being that.
+        if (ret.objCode == nullptr)
+            ret.function = nullptr;
     }
     // any other callback
+    return ret;
+}
+
+struct ArgCount
+{
+    int min;
+    int max;
+};
+
+// Return a pair of minimum / arg count "foo(p1, p2=0)" -> {1, 2}
+ArgCount argCount(const FunctionArgumentsResult &args)
+{
+    Q_ASSERT(args.objCode);
+    ArgCount result{-1, -1};
+    if ((PepCode_GET_FLAGS(args.objCode) & CO_VARARGS) == 0) {
+        result.min = result.max = PepCode_GET_ARGCOUNT(args.objCode);
+        if (args.function != nullptr) {
+            if (auto *defaultArgs = PepFunction_GetDefaults(args.function))
+                result.min -= PyTuple_Size(defaultArgs);
+        }
+    }
+    return result;
+}
+
+// Find Signal Instance for argument count.
+static PySideSignalInstance *findSignalInstance(PySideSignalInstance *source, int argCount)
+{
+    for (auto *si = source; si != nullptr; si = si->d->next) {
+        if (si->d->argCount == argCount)
+            return si;
+    }
+    return nullptr;
 }
 
 static PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject *kwds)
@@ -433,6 +484,11 @@ static PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject
         return nullptr;
 
     PySideSignalInstance *source = reinterpret_cast<PySideSignalInstance *>(self);
+    if (!source->d)
+        return PyErr_Format(PyExc_RuntimeError, "cannot connect uninitialized SignalInstance");
+    if (source->deleted)
+        return PyErr_Format(PyExc_RuntimeError, "Signal source has been deleted");
+
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
 
     bool match = false;
@@ -461,54 +517,32 @@ static PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject
         }
     } else {
         // Check signature of the slot (method or function) to match signal
-        int slotArgs = -1;
-        bool matchedSlot = false;
-
-        PySideSignalInstance *it = source;
-
-        PyObject *function = nullptr;
-        PepCodeObject *objCode = nullptr;
-        bool useSelf = false;
-
-        extractFunctionArgumentsFromSlot(slot, function, objCode, useSelf, nullptr);
-
-        if (function != nullptr) {
-            slotArgs = PepCode_GET_FLAGS(objCode) & CO_VARARGS ? -1 : PepCode_GET_ARGCOUNT(objCode);
-            if (useSelf)
-                slotArgs -= 1;
+        const auto args = extractFunctionArgumentsFromSlot(slot);
+        PySideSignalInstance *matchedSlot = nullptr;
+
+        if (args.function != nullptr) {
+            auto slotArgRange = argCount(args);
+            if (args.isMethod) {
+                slotArgRange.min -= 1;
+                slotArgRange.max -= 1;
+            }
 
             // Get signature args
-            bool isShortCircuit = false;
-            int signatureArgs = 0;
-            QStringList argsSignature;
-
-            argsSignature = PySide::Signal::getArgsFromSignature(it->d->signature,
-                &isShortCircuit);
-            signatureArgs = argsSignature.length();
-
             // Iterate the possible types of connection for this signal and compare
             // it with slot arguments
-            if (signatureArgs != slotArgs) {
-                while (it->d->next != nullptr) {
-                    it = it->d->next;
-                    argsSignature = PySide::Signal::getArgsFromSignature(it->d->signature,
-                        &isShortCircuit);
-                    signatureArgs = argsSignature.length();
-                    if (signatureArgs == slotArgs) {
-                        matchedSlot = true;
-                        break;
-                    }
-                }
+            for (int slotArgs = slotArgRange.max;
+                 slotArgs >= slotArgRange.min && matchedSlot == nullptr; --slotArgs) {
+                 matchedSlot = findSignalInstance(source, slotArgs);
             }
         }
 
         // Adding references to pyArgs
         PyList_Append(pyArgs, source->d->source);
 
-        if (matchedSlot) {
+        if (matchedSlot != nullptr) {
             // If a slot matching the same number of arguments was found,
             // include signature to the pyArgs
-            Shiboken::AutoDecRef signature(PySide::Signal::buildQtCompatible(it->d->signature));
+            Shiboken::AutoDecRef signature(PySide::Signal::buildQtCompatible(matchedSlot->d->signature));
             PyList_Append(pyArgs, signature);
         } else {
             // Try the first by default if the slot was not found
@@ -525,11 +559,9 @@ static PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject
     if (match) {
         Shiboken::AutoDecRef tupleArgs(PyList_AsTuple(pyArgs));
         Shiboken::AutoDecRef pyMethod(PyObject_GetAttr(source->d->source,
-                                                       PySide::PyName::qtConnect()));
-        if (pyMethod.isNull()) { // PYSIDE-79: check if pyMethod exists.
-            PyErr_SetString(PyExc_RuntimeError, "method 'connect' vanished!");
-            return nullptr;
-        }
+                                                       PySide::PySideName::qtConnect()));
+        if (pyMethod.isNull())  // PYSIDE-79: check if pyMethod exists.
+            return PyErr_Format(PyExc_RuntimeError, "method 'connect' vanished!");
         PyObject *result = PyObject_CallObject(pyMethod, tupleArgs);
         if (connection_Check(result))
             return result;
@@ -549,6 +581,13 @@ static int argCountInSignature(const char *signature)
 static PyObject *signalInstanceEmit(PyObject *self, PyObject *args)
 {
     PySideSignalInstance *source = reinterpret_cast<PySideSignalInstance *>(self);
+    if (!source->d)
+        return PyErr_Format(PyExc_RuntimeError, "cannot emit uninitialized SignalInstance");
+
+    // PYSIDE-2201: Check if the object has vanished meanwhile.
+    //              Tried to revive it without exception, but this gives problems.
+    if (source->deleted)
+        return PyErr_Format(PyExc_RuntimeError, "The SignalInstance object was already deleted");
 
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
     int numArgsGiven = PySequence_Fast_GET_SIZE(args);
@@ -579,7 +618,7 @@ static PyObject *signalInstanceEmit(PyObject *self, PyObject *args)
         PyList_Append(pyArgs, PyTuple_GetItem(args, i));
 
     Shiboken::AutoDecRef pyMethod(PyObject_GetAttr(source->d->source,
-                                                   PySide::PyName::qtEmit()));
+                                                   PySide::PySideName::qtEmit()));
 
     Shiboken::AutoDecRef tupleArgs(PyList_AsTuple(pyArgs));
     return PyObject_CallObject(pyMethod.object(), tupleArgs);
@@ -589,7 +628,7 @@ static PyObject *signalInstanceGetItem(PyObject *self, PyObject *key)
 {
     auto *firstSignal = reinterpret_cast<PySideSignalInstance *>(self);
     const auto &sigName = firstSignal->d->signalName;
-    const auto sigKey = PySide::Signal::parseSignature(key);
+    const auto sigKey = PySide::Signal::parseSignature(key).signature;
     const auto sig = PySide::Signal::buildSignature(sigName, sigKey);
     for (auto *data = firstSignal; data != nullptr; data = data->d->next) {
         if (data->d->signature == sig) {
@@ -608,13 +647,26 @@ static PyObject *signalInstanceGetItem(PyObject *self, PyObject *key)
         message += '"' + data->d->signature + '"';
     }
 
-    PyErr_SetString(PyExc_IndexError, message.constData());
-    return nullptr;
+    return PyErr_Format(PyExc_IndexError, message.constData());
+}
+
+static inline void warnDisconnectFailed(PyObject *aSlot, const QByteArray &signature)
+{
+    if (PyErr_Occurred() != nullptr) { // avoid "%S" invoking str() when an error is set.
+        PyErr_WarnFormat(PyExc_RuntimeWarning, 0, "Failed to disconnect (%s) from signal \"%s\".",
+                         Py_TYPE(aSlot)->tp_name, signature.constData());
+    } else {
+        PyErr_WarnFormat(PyExc_RuntimeWarning, 0, "Failed to disconnect (%S) from signal \"%s\".",
+                         aSlot, signature.constData());
+    }
 }
 
 static PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args)
 {
     auto source = reinterpret_cast<PySideSignalInstance *>(self);
+    if (!source->d)
+        return PyErr_Format(PyExc_RuntimeError, "cannot disconnect uninitialized SignalInstance");
+
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
 
     PyObject *slot = Py_None;
@@ -653,16 +705,15 @@ static PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args)
     if (match) {
         Shiboken::AutoDecRef tupleArgs(PyList_AsTuple(pyArgs));
         Shiboken::AutoDecRef pyMethod(PyObject_GetAttr(source->d->source,
-                                                       PySide::PyName::qtDisconnect()));
+                                                       PySide::PySideName::qtDisconnect()));
         PyObject *result = PyObject_CallObject(pyMethod, tupleArgs);
-        if (!result || result == Py_True)
-            return result;
-        Py_DECREF(result);
+        if (result != Py_True)
+            warnDisconnectFailed(slot, source->d->signature);
+        return result;
     }
 
-    PyErr_Format(PyExc_RuntimeError, "Failed to disconnect signal %s.",
-                 source->d->signature.constData());
-    return nullptr;
+    warnDisconnectFailed(slot, source->d->signature);
+    Py_RETURN_FALSE;
 }
 
 // PYSIDE-68: Supply the missing __get__ function
@@ -670,12 +721,23 @@ static PyObject *signalDescrGet(PyObject *self, PyObject *obj, PyObject * /*type
 {
     auto signal = reinterpret_cast<PySideSignal *>(self);
     // Return the unbound signal if there is nothing to bind it to.
-    if (obj == nullptr || obj == Py_None) {
+    if (obj == nullptr || obj == Py_None
+        || !PySide::isQObjectDerived(Py_TYPE(obj), true)) {
         Py_INCREF(self);
         return self;
     }
+
+    // PYSIDE-68-bis: It is important to respect the already cached instance.
     Shiboken::AutoDecRef name(Py_BuildValue("s", signal->data->signalName.data()));
-    return reinterpret_cast<PyObject *>(PySide::Signal::initialize(signal, name, obj));
+    auto *dict = SbkObject_GetDict_NoRef(obj);
+    auto *inst = PyDict_GetItem(dict, name);
+    if (inst) {
+        Py_INCREF(inst);
+        return inst;
+    }
+    inst = reinterpret_cast<PyObject *>(PySide::Signal::initialize(signal, name, obj));
+    PyObject_SetAttr(obj, name, inst);
+    return inst;
 }
 
 static PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw)
@@ -686,23 +748,19 @@ static PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw)
     // The only way calling a signal can succeed (the Python equivalent of C++'s operator() )
     // is when a method with the same name as the signal is attached to an object.
     // An example is QProcess::error() (don't check the docs, but the source code of qprocess.h).
-    if (!signal->homonymousMethod) {
-        PyErr_SetString(PyExc_TypeError, "native Qt signal is not callable");
-        return nullptr;
-    }
-
-    descrgetfunc getDescriptor = Py_TYPE(signal->homonymousMethod)->tp_descr_get;
+    if (!signal->homonymousMethod)
+        return PyErr_Format(PyExc_TypeError, "native Qt signal is not callable");
 
     // Check if there exists a method with the same name as the signal, which is also a static
     // method in C++ land.
-    Shiboken::AutoDecRef homonymousMethod(getDescriptor(signal->homonymousMethod,
-                                                        nullptr, nullptr));
+    Shiboken::AutoDecRef homonymousMethod(PepExt_Type_CallDescrGet(signal->homonymousMethod,
+                                                                   nullptr, nullptr));
     if (PyCFunction_Check(homonymousMethod.object())
             && (PyCFunction_GET_FLAGS(homonymousMethod.object()) & METH_STATIC))
         return PyObject_Call(homonymousMethod, args, kw);
 
     // Assumes homonymousMethod is not a static method.
-    ternaryfunc callFunc = Py_TYPE(signal->homonymousMethod)->tp_call;
+    ternaryfunc callFunc = PepExt_Type_GetCallSlot(Py_TYPE(signal->homonymousMethod));
     return callFunc(homonymousMethod, args, kw);
 }
 
@@ -736,11 +794,12 @@ static PyObject *_getHomonymousMethod(PySideSignalInstance *inst)
     auto signalName = inst->d->signalName;
     Shiboken::AutoDecRef name(Shiboken::String::fromCString(signalName));
     auto *mro = Py_TYPE(inst->d->source)->tp_mro;
-    Py_ssize_t idx, n = PyTuple_GET_SIZE(mro);
+    const Py_ssize_t n = PyTuple_GET_SIZE(mro);
 
-    for (idx = 0; idx < n; idx++) {
+    for (Py_ssize_t idx = 0; idx < n; idx++) {
         auto *sub_type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, idx));
-        auto *hom = PyDict_GetItem(sub_type->tp_dict, name);
+        Shiboken::AutoDecRef tpDict(PepType_GetDict(sub_type));
+        auto *hom = PyDict_GetItem(tpDict, name);
         PyObject *realFunc{};
         if (hom && PyCallable_Check(hom) && (realFunc = _getRealCallable(hom)))
             return realFunc;
@@ -758,8 +817,8 @@ static PyObject *signalInstanceCall(PyObject *self, PyObject *args, PyObject *kw
         return nullptr;
     }
 
-    descrgetfunc getDescriptor = Py_TYPE(hom)->tp_descr_get;
-    Shiboken::AutoDecRef homonymousMethod(getDescriptor(hom, PySideSignal->d->source, nullptr));
+    Shiboken::AutoDecRef homonymousMethod(PepExt_Type_CallDescrGet(hom, PySideSignal->d->source,
+                                                                   nullptr));
     return PyObject_Call(homonymousMethod, args, kw);
 }
 
@@ -772,15 +831,14 @@ static PyObject *metaSignalCheck(PyObject * /* klass */, PyObject *arg)
 
 } // extern "C"
 
-namespace PySide {
-namespace Signal {
+namespace PySide::Signal {
 
 static const char *MetaSignal_SignatureStrings[] = {
     "PySide6.QtCore.MetaSignal.__instancecheck__(self,object:object)->bool",
     nullptr}; // Sentinel
 
 static const char *Signal_SignatureStrings[] = {
-    "PySide6.QtCore.Signal(self,*types:type,name:str=nullptr,arguments:str=nullptr)",
+    "PySide6.QtCore.Signal(self,*types:type,name:str=nullptr,arguments:typing.List[str]=nullptr)",
     "1:PySide6.QtCore.Signal.__get__(self,instance:None,owner:Optional[typing.Any])->"
         "PySide6.QtCore.Signal",
     "0:PySide6.QtCore.Signal.__get__(self,instance:PySide6.QtCore.QObject,"
@@ -788,8 +846,10 @@ static const char *Signal_SignatureStrings[] = {
     nullptr}; // Sentinel
 
 static const char *SignalInstance_SignatureStrings[] = {
-    "PySide6.QtCore.SignalInstance.connect(self,slot:object,type:type=nullptr)",
-    "PySide6.QtCore.SignalInstance.disconnect(self,slot:object=nullptr)",
+    "PySide6.QtCore.SignalInstance.connect(self,slot:object,"
+        "type:PySide6.QtCore.Qt.ConnectionType=PySide6.QtCore.Qt.ConnectionType.AutoConnection)"
+        "->PySide6.QtCore.QMetaObject.Connection",
+    "PySide6.QtCore.SignalInstance.disconnect(self,slot:object=nullptr)->bool",
     "PySide6.QtCore.SignalInstance.emit(self,*args:typing.Any)",
     nullptr}; // Sentinel
 
@@ -848,8 +908,8 @@ void updateSourceObject(PyObject *source)
         Py_ssize_t pos = 0;
         PyObject *key, *value;
         auto *type = reinterpret_cast<PyTypeObject *>(mroItem.object());
-
-        while (PyDict_Next(type->tp_dict, &pos, &key, &value)) {
+        Shiboken::AutoDecRef tpDict(PepType_GetDict(type));
+        while (PyDict_Next(tpDict, &pos, &key, &value)) {
             if (PyObject_TypeCheck(value, PySideSignal_TypeF())) {
                 // PYSIDE-1751: We only insert an instance into the instance dict, if a signal
                 //              of the same name is in the mro. This is the equivalent action
@@ -857,8 +917,9 @@ void updateSourceObject(PyObject *source)
                 if (!PyDict_GetItem(dict, key)) {
                     auto *inst = PyObject_New(PySideSignalInstance, PySideSignalInstance_TypeF());
                     Shiboken::AutoDecRef signalInstance(reinterpret_cast<PyObject *>(inst));
-                    instanceInitialize(signalInstance.cast<PySideSignalInstance *>(),
-                                       key, reinterpret_cast<PySideSignal *>(value), source, 0);
+                    auto *si = reinterpret_cast<PySideSignalInstance *>(signalInstance.object());
+                    instanceInitialize(si, key, reinterpret_cast<PySideSignal *>(value),
+                                       source, 0);
                     if (PyDict_SetItem(dict, key, signalInstance) == -1)
                         return;     // An error occurred while setting the attribute
                 }
@@ -889,8 +950,6 @@ QByteArray getTypeName(PyObject *obType)
             return QByteArrayLiteral("QVariantList");
         if (type == &PyDict_Type)
             return QByteArrayLiteral("QVariantMap");
-        if (Py_TYPE(type) == SbkEnumType_TypeF())
-            return Shiboken::Enum::getCppName(type);
         return QByteArrayLiteral("PyObject");
     }
     if (obType == Py_None) // Must be checked before as Shiboken::String::check accepts Py_None
@@ -909,32 +968,38 @@ static QByteArray buildSignature(const QByteArray &name, const QByteArray &signa
     return QMetaObject::normalizedSignature(name + '(' + signature + ')');
 }
 
-static QByteArray parseSignature(PyObject *args)
+static PySideSignalData::Signature parseSignature(PyObject *args)
 {
-    if (args && (Shiboken::String::check(args) || !PyTuple_Check(args)))
-        return getTypeName(args);
+    PySideSignalData::Signature result{{}, QMetaMethod::Compatibility, 0};
+    if (args && (Shiboken::String::check(args) || !PyTuple_Check(args))) {
+        result.signature = getTypeName(args);
+        result.argCount = 1;
+        return result;
+    }
 
-    QByteArray signature;
     for (Py_ssize_t i = 0, i_max = PySequence_Size(args); i < i_max; i++) {
         Shiboken::AutoDecRef arg(PySequence_GetItem(args, i));
         const auto typeName = getTypeName(arg);
         if (!typeName.isEmpty()) {
-            if (!signature.isEmpty())
-                signature += ',';
-            signature += typeName;
+            if (!result.signature.isEmpty())
+                result.signature += ',';
+            result.signature += typeName;
+            ++result.argCount;
         }
     }
-    return signature;
+    return result;
 }
 
-static void appendSignature(PySideSignal *self, const SignalSignature &signature)
+static void sourceGone(void *data)
 {
-    self->data->signatures.append({signature.m_parameterTypes, signature.m_attributes});
+    auto *self = reinterpret_cast<PySideSignalInstance *>(data);
+    self->deleted = true;
 }
 
 static void instanceInitialize(PySideSignalInstance *self, PyObject *name, PySideSignal *signal, PyObject *source, int index)
 {
     self->d = new PySideSignalInstancePrivate;
+    self->deleted = false;
     PySideSignalInstancePrivate *selfPvt = self->d;
     selfPvt->next = nullptr;
     if (signal->data->signalName.isEmpty())
@@ -944,12 +1009,17 @@ static void instanceInitialize(PySideSignalInstance *self, PyObject *name, PySid
     selfPvt->source = source;
     const auto &signature = signal->data->signatures.at(index);
     selfPvt->signature = buildSignature(self->d->signalName, signature.signature);
+    selfPvt->argCount = signature.argCount;
     selfPvt->attributes = signature.attributes;
     selfPvt->homonymousMethod = nullptr;
     if (signal->homonymousMethod) {
         selfPvt->homonymousMethod = signal->homonymousMethod;
         Py_INCREF(selfPvt->homonymousMethod);
     }
+    // PYSIDE-2201: We have no reference to source. Let's take a weakref to get
+    //              notified when source gets deleted.
+    PySide::WeakRef::create(source, sourceGone, self);
+
     index++;
 
     if (index < signal->data->signatures.size()) {
@@ -981,7 +1051,7 @@ PySideSignalInstance *initialize(PySideSignal *self, PyObject *name, PyObject *o
 bool connect(PyObject *source, const char *signal, PyObject *callback)
 {
     Shiboken::AutoDecRef pyMethod(PyObject_GetAttr(source,
-                                                   PySide::PyName::qtConnect()));
+                                                   PySide::PySideName::qtConnect()));
     if (pyMethod.isNull())
         return false;
 
@@ -1009,14 +1079,15 @@ PySideSignalInstance *newObjectFromMethod(PyObject *source, const QList<QMetaMet
             previous->d->next = item;
 
         item->d = new PySideSignalInstancePrivate;
+        item->deleted = false;
         PySideSignalInstancePrivate *selfPvt = item->d;
         selfPvt->source = source;
-        Py_INCREF(selfPvt->source); // PYSIDE-79: an INCREF is missing.
         QByteArray cppName(m.methodSignature());
         cppName.truncate(cppName.indexOf('('));
-        // separe SignalName
+        // separate SignalName
         selfPvt->signalName = cppName;
         selfPvt->signature = m.methodSignature();
+        selfPvt->argCount = int(m.parameterCount());
         selfPvt->attributes = m.attributes();
         selfPvt->homonymousMethod = nullptr;
         selfPvt->next = nullptr;
@@ -1024,29 +1095,10 @@ PySideSignalInstance *newObjectFromMethod(PyObject *source, const QList<QMetaMet
     return root;
 }
 
-template<typename T>
-static typename T::value_type join(T t, const char *sep)
-{
-    typename T::value_type res;
-    if (t.isEmpty())
-        return res;
-
-    typename T::const_iterator it = t.begin();
-    typename T::const_iterator end = t.end();
-    res += *it;
-    ++it;
-
-    while (it != end) {
-        res += sep;
-        res += *it;
-        ++it;
-    }
-    return res;
-}
-
 static void _addSignalToWrapper(PyTypeObject *wrapperType, const char *signalName, PySideSignal *signal)
 {
-    auto typeDict = wrapperType->tp_dict;
+    Shiboken::AutoDecRef tpDict(PepType_GetDict(wrapperType));
+    auto typeDict = tpDict.object();
     PyObject *homonymousMethod;
     if ((homonymousMethod = PyDict_GetItemString(typeDict, signalName))) {
         Py_INCREF(homonymousMethod);
@@ -1056,9 +1108,10 @@ static void _addSignalToWrapper(PyTypeObject *wrapperType, const char *signalNam
 }
 
 // This function is used by qStableSort to promote empty signatures
-static bool compareSignals(const SignalSignature &sig1, const SignalSignature &)
+static bool compareSignals(const PySideSignalData::Signature &sig1,
+                           const PySideSignalData::Signature &sig2)
 {
-    return sig1.m_parameterTypes.isEmpty();
+    return sig1.signature.isEmpty() && !sig2.signature.isEmpty();
 }
 
 static PyObject *buildQtCompatible(const QByteArray &signature)
@@ -1069,39 +1122,46 @@ static PyObject *buildQtCompatible(const QByteArray &signature)
 
 void registerSignals(PyTypeObject *pyObj, const QMetaObject *metaObject)
 {
-    using SignalSigMap = QHash<QByteArray, QList<SignalSignature> >;
-    SignalSigMap signalsFound;
+    using Signature = PySideSignalData::Signature;
+    struct MetaSignal
+    {
+        QByteArray methodName;
+        QList<Signature> signatures;
+    };
+
+    QList<MetaSignal> signalsFound;
     for (int i = metaObject->methodOffset(), max = metaObject->methodCount(); i < max; ++i) {
         QMetaMethod method = metaObject->method(i);
 
         if (method.methodType() == QMetaMethod::Signal) {
             QByteArray methodName(method.methodSignature());
-            methodName.chop(methodName.size() - methodName.indexOf('('));
-            SignalSignature signature;
-            signature.m_parameterTypes = join(method.parameterTypes(), ",");
+            methodName.truncate(methodName.indexOf('('));
+            Signature signature{method.parameterTypes().join(','), {},
+                                short(method.parameterCount())};
             if (method.attributes() & QMetaMethod::Cloned)
-                signature.m_attributes = QMetaMethod::Cloned;
-            signalsFound[methodName] << signature;
+                signature.attributes = QMetaMethod::Cloned;
+            auto it = std::find_if(signalsFound.begin(), signalsFound.end(),
+                                   [methodName](const MetaSignal &ms)
+                                   { return ms.methodName == methodName; });
+            if (it != signalsFound.end())
+                it->signatures << signature;
+            else
+                signalsFound.append(MetaSignal{methodName, {signature}});
         }
     }
 
-    SignalSigMap::Iterator it = signalsFound.begin();
-    SignalSigMap::Iterator end = signalsFound.end();
-    for (; it != end; ++it) {
+    for (const auto &metaSignal : std::as_const(signalsFound)) {
         PySideSignal *self = PyObject_New(PySideSignal, PySideSignal_TypeF());
         self->data = new PySideSignalData;
-        self->data->signalName = it.key();
+        self->data->signalName = metaSignal.methodName;
         self->homonymousMethod = nullptr;
 
         // Empty signatures comes first! So they will be the default signal signature
-        std::stable_sort(it.value().begin(), it.value().end(), &compareSignals);
-        const auto endJ = it.value().cend();
-        for (auto j = it.value().cbegin(); j != endJ; ++j) {
-            const SignalSignature &sig = *j;
-            appendSignature(self, sig);
-        }
+        self->data->signatures = metaSignal.signatures;
+        std::stable_sort(self->data->signatures.begin(),
+                         self->data->signatures.end(), &compareSignals);
 
-        _addSignalToWrapper(pyObj, it.key(), self);
+        _addSignalToWrapper(pyObj, metaSignal.methodName, self);
         Py_DECREF(reinterpret_cast<PyObject *>(self));
     }
 }
@@ -1116,41 +1176,48 @@ const char *getSignature(PySideSignalInstance *signal)
     return signal->d->signature;
 }
 
-QStringList getArgsFromSignature(const char *signature, bool *isShortCircuit)
+EmitterData getEmitterData(PySideSignalInstance *signal)
 {
-    QString qsignature = QString::fromLatin1(signature).trimmed();
-    QStringList result;
+    EmitterData result;
+    result.emitter = PySide::convertToQObject(getObject(signal), false);
+    if (result.emitter != nullptr) {
+        auto *mo = result.emitter->metaObject();
+        result.methodIndex = mo->indexOfMethod(getSignature(signal));
+    }
+    return result;
+}
 
-    if (isShortCircuit)
-        *isShortCircuit = !qsignature.contains(u'(');
-    if (qsignature.contains(u"()") || qsignature.contains(u"(void)"))
+QByteArrayList getArgsFromSignature(const char *signature)
+{
+    QByteArray qsignature = QByteArray(signature).trimmed();
+    QByteArrayList result;
+
+    if (qsignature.contains("()") || qsignature.contains("(void)"))
         return result;
-    if (qsignature.endsWith(u')')) {
-        const int paren = qsignature.indexOf(u'(');
+    if (qsignature.endsWith(')')) {
+        const auto paren = qsignature.indexOf('(');
         if (paren >= 0) {
             qsignature.chop(1);
             qsignature.remove(0, paren + 1);
             result = qsignature.split(u',');
-            for (QString &type : result)
+            for (auto &type : result)
                 type = type.trimmed();
         }
     }
     return result;
 }
 
-QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *callback, bool encodeName)
+QByteArray getCallbackSignature(const char *signal, QObject *receiver,
+                                PyObject *callback, bool encodeName)
 {
     QByteArray functionName;
     qsizetype numArgs = -1;
 
-    PyObject *function = nullptr;
-    PepCodeObject *objCode = nullptr;
-    bool useSelf = false;
-
-    extractFunctionArgumentsFromSlot(callback, function, objCode, useSelf, &functionName);
+    const auto slotArgs = extractFunctionArgumentsFromSlot(callback);
+    qsizetype useSelf = slotArgs.isMethod ? 1 : 0;
 
-    if (function != nullptr) {
-        numArgs = PepCode_GET_FLAGS(objCode) & CO_VARARGS ? -1 : PepCode_GET_ARGCOUNT(objCode);
+    if (slotArgs.function != nullptr) {
+        numArgs = argCount(slotArgs).max;
 #ifdef PYPY_VERSION
     } else if (Py_TYPE(callback) == PepBuiltinMethod_TypePtr) {
         // PYSIDE-535: PyPy has a special builtin method that acts almost like PyCFunction.
@@ -1176,7 +1243,7 @@ QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *ca
     } else if (PyCFunction_Check(callback)) {
         const PyCFunctionObject *funcObj = reinterpret_cast<const PyCFunctionObject *>(callback);
         functionName = PepCFunction_GET_NAMESTR(funcObj);
-        useSelf = PyCFunction_GET_SELF(funcObj);
+        useSelf = PyCFunction_GET_SELF(funcObj) != nullptr ? 1 : 0;
         const int flags = PyCFunction_GET_FLAGS(funcObj);
 
         if (receiver) {
@@ -1184,7 +1251,7 @@ QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *ca
             const QMetaObject *mo = receiver->metaObject();
             QByteArray prefix(functionName);
             prefix += '(';
-            for (int i = 0; i < mo->methodCount(); i++) {
+            for (int i = 0, count = mo->methodCount(); i < count; ++i) {
                 QMetaMethod me = mo->method(i);
                 if ((strncmp(me.methodSignature(), prefix, prefix.size()) == 0) &&
                     QMetaObject::checkConnectArgs(signal, me.methodSignature())) {
@@ -1201,26 +1268,28 @@ QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *ca
                 numArgs = 0;
         }
     } else if (PyCallable_Check(callback)) {
-        functionName = "__callback" + QByteArray::number((qlonglong)callback);
+        functionName = "__callback" + QByteArray::number(quintptr(callback));
     }
 
+    if (functionName.isEmpty() && slotArgs.functionName != nullptr)
+        functionName = Shiboken::String::toCString(slotArgs.functionName);
     Q_ASSERT(!functionName.isEmpty());
 
-    bool isShortCircuit = false;
-
-    const QString functionNameS = QLatin1String(functionName);
-    QString signature = encodeName ? codeCallbackName(callback, functionNameS) : functionNameS;
-    QStringList args = getArgsFromSignature(signal, &isShortCircuit);
+    if (functionName.startsWith('<') && functionName.endsWith('>')) { // fix "<lambda>"
+        functionName[0] = '_';
+        functionName[functionName.size() - 1] = '_';
+    }
+    QByteArray signature = encodeName ? codeCallbackName(callback, functionName) : functionName;
+    QByteArrayList args = getArgsFromSignature(signal);
 
-    if (!isShortCircuit) {
-        signature.append(u'(');
-        if (numArgs == -1)
-            numArgs = std::numeric_limits<qsizetype>::max();
+    signature.append(u'(');
+    if (numArgs != -1) {
         while (!args.isEmpty() && (args.size() > (numArgs - useSelf)))
             args.removeLast();
-        signature.append(args.join(u','));
-        signature.append(u')');
     }
+    signature.append(args.join(','));
+    signature.append(')');
+
     return signature;
 }
 
@@ -1238,21 +1307,21 @@ bool checkQtSignal(const char *signal)
     return true;
 }
 
-QString codeCallbackName(PyObject *callback, const QString &funcName)
+QByteArray codeCallbackName(PyObject *callback, const QByteArray &funcName)
 {
     if (PyMethod_Check(callback)) {
         PyObject *self = PyMethod_GET_SELF(callback);
         PyObject *func = PyMethod_GET_FUNCTION(callback);
-        return funcName + QString::number(quint64(self), 16) + QString::number(quint64(func), 16);
+        return funcName + QByteArray::number(quint64(self), 16) + QByteArray::number(quint64(func), 16);
     }
     // PYSIDE-1523: Handle the compiled case.
     if (PySide::isCompiledMethod(callback)) {
         // Not retaining references inline with what PyMethod_GET_(SELF|FUNC) does.
-        Shiboken::AutoDecRef self(PyObject_GetAttr(callback, PySide::PyName::im_self()));
-        Shiboken::AutoDecRef func(PyObject_GetAttr(callback, PySide::PyName::im_func()));
-        return funcName + QString::number(quint64(self), 16) + QString::number(quint64(func), 16);
+        Shiboken::AutoDecRef self(PyObject_GetAttr(callback, PySide::PySideName::im_self()));
+        Shiboken::AutoDecRef func(PyObject_GetAttr(callback, PySide::PySideName::im_func()));
+        return funcName + QByteArray::number(quint64(self), 16) + QByteArray::number(quint64(func), 16);
     }
-    return funcName + QString::number(quint64(callback), 16);
+    return funcName + QByteArray::number(quint64(callback), 16);
 }
 
 QByteArray voidType()
@@ -1260,6 +1329,4 @@ QByteArray voidType()
     return QByteArrayLiteral("void");
 }
 
-} //namespace Signal
-} //namespace PySide
-
+} //namespace PySide::Signal
diff --git a/sources/pyside6/libpyside/pysidesignal.h b/sources/pyside6/libpyside/pysidesignal.h
index c38371d81..7493f94b5 100644
--- a/sources/pyside6/libpyside/pysidesignal.h
+++ b/sources/pyside6/libpyside/pysidesignal.h
@@ -30,11 +30,11 @@ extern "C"
     {
         PyObject_HEAD
         PySideSignalInstancePrivate *d;
+        bool deleted;
     };
 }; // extern "C"
 
-namespace PySide {
-namespace Signal {
+namespace PySide::Signal {
 
 /**
  * This function checks for the PySideSignal type.
@@ -92,6 +92,18 @@ PYSIDE_API PyObject *getObject(PySideSignalInstance *signal);
  **/
 PYSIDE_API const char *getSignature(PySideSignalInstance *signal);
 
+struct EmitterData
+{
+    QObject *emitter = nullptr;
+    int methodIndex = -1;
+};
+
+/// A convenience to retrieve the emitter data from a signal instance
+///
+/// @param   signal The Signal object
+/// @return  Data structure
+PYSIDE_API EmitterData getEmitterData(PySideSignalInstance *signal);
+
 /**
  * This function is used to retrieve the signal signature
  *
@@ -123,20 +135,18 @@ PYSIDE_API bool checkQtSignal(const char *signature);
  * @param   encodeName  Used to specify if the returned signature will be encoded with Qt signal/slot style
  * @return  Return the callback signature
  **/
-PYSIDE_API QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *callback, bool encodeName);
+PYSIDE_API QByteArray getCallbackSignature(const char *signal, QObject *receiver,
+                                           PyObject *callback, bool encodeName);
 
 /**
  * This function parses the signature and then returns a list of argument types.
  *
  * @param   signature       The signal signature
- * @param   isShortCircuit  If this is a shortCircuit(python<->python) signal
  * @return  Return true if this is a Qt Signal, otherwise return false
  * @todo    replace return type by QList<QByteArray>
  **/
-QStringList getArgsFromSignature(const char *signature,
-                                 bool *isShortCircuit = nullptr);
+QByteArrayList getArgsFromSignature(const char *signature);
 
-} // namespace Signal
-} // namespace PySide
+} // namespace PySide::Signal
 
 #endif
diff --git a/sources/pyside6/libpyside/pysidesignal_p.h b/sources/pyside6/libpyside/pysidesignal_p.h
index 432f6b5a0..55a9a7a70 100644
--- a/sources/pyside6/libpyside/pysidesignal_p.h
+++ b/sources/pyside6/libpyside/pysidesignal_p.h
@@ -13,13 +13,14 @@ struct PySideSignalData
 {
     struct Signature
     {
-        QByteArray signature;
-        int attributes;
+        QByteArray signature; // ','-separated list of parameter types
+        unsigned short attributes;
+        short argCount;
     };
 
     QByteArray signalName;
     QList<Signature> signatures;
-    QByteArrayList *signalArguments = nullptr;
+    QByteArrayList signalArguments;
 };
 
 extern "C"
@@ -39,20 +40,21 @@ struct PySideSignalInstancePrivate
 {
     QByteArray signalName;
     QByteArray signature;
-    int attributes = 0;
     PyObject *source = nullptr;
     PyObject *homonymousMethod = nullptr;
     PySideSignalInstance *next = nullptr;
+    unsigned short attributes = 0;
+    short argCount = 0;
 };
 
-namespace PySide { namespace Signal {
+namespace PySide::Signal {
 
     void            init(PyObject *module);
     bool            connect(PyObject *source, const char *signal, PyObject *callback);
     QByteArray      getTypeName(PyObject *);
-    QString         codeCallbackName(PyObject *callback, const QString &funcName);
+    QByteArray      codeCallbackName(PyObject *callback, const QByteArray &funcName);
     QByteArray      voidType();
 
-}} //namespace PySide
+} // namespace PySide::Signal
 
 #endif
diff --git a/sources/pyside6/libpyside/pysideslot.cpp b/sources/pyside6/libpyside/pysideslot.cpp
index 9fdfe489d..fa7e89f42 100644
--- a/sources/pyside6/libpyside/pysideslot.cpp
+++ b/sources/pyside6/libpyside/pysideslot.cpp
@@ -3,6 +3,7 @@
 
 #include "pysidesignal_p.h"
 #include "pysideslot_p.h"
+#include "pysidestaticstrings.h"
 
 #include <shiboken.h>
 
@@ -17,55 +18,69 @@ struct SlotData
     QByteArray name;
     QByteArray args;
     QByteArray resultType;
+    QByteArray tag; // QMetaMethod::tag()
 };
 
-typedef struct
+struct PySideSlot
 {
     PyObject_HEAD
     SlotData *slotData;
-} PySideSlot;
+};
 
 extern "C"
 {
 
+static void slotDataListDestructor(PyObject *o)
+{
+    delete PySide::Slot::dataListFromCapsule(o);
+}
+
 static int slotTpInit(PyObject *, PyObject *, PyObject *);
 static PyObject *slotCall(PyObject *, PyObject *, PyObject *);
 
 // Class Definition -----------------------------------------------
-static PyType_Slot PySideSlotType_slots[] = {
-    {Py_tp_call, reinterpret_cast<void *>(slotCall)},
-    {Py_tp_init, reinterpret_cast<void *>(slotTpInit)},
-    {Py_tp_new, reinterpret_cast<void *>(PyType_GenericNew)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideSlotType_spec = {
-    "2:PySide6.QtCore.Slot",
-    sizeof(PySideSlot),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideSlotType_slots,
-};
 
+static PyTypeObject *createSlotType()
+{
+    PyType_Slot PySideSlotType_slots[] = {
+        {Py_tp_call, reinterpret_cast<void *>(slotCall)},
+        {Py_tp_init, reinterpret_cast<void *>(slotTpInit)},
+        {Py_tp_new, reinterpret_cast<void *>(PyType_GenericNew)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PySideSlotType_spec = {
+        "2:PySide6.QtCore.Slot",
+        sizeof(PySideSlot),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideSlotType_slots,
+    };
+
+    return SbkType_FromSpec(&PySideSlotType_spec);
+}
 
 static PyTypeObject *PySideSlot_TypeF()
 {
-    static auto *type = SbkType_FromSpec(&PySideSlotType_spec);
+    static auto *type = createSlotType();
     return type;
 }
 
 int slotTpInit(PyObject *self, PyObject *args, PyObject *kw)
 {
     static PyObject *emptyTuple = nullptr;
-    static const char *kwlist[] = {"name", "result", nullptr};
+    static const char *kwlist[] = {"name", "result", "tag", nullptr};
     char *argName = nullptr;
     PyObject *argResult = nullptr;
+    char *tag = nullptr;
 
     if (emptyTuple == nullptr)
         emptyTuple = PyTuple_New(0);
 
-    if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sO:QtCore.Slot",
-                                     const_cast<char **>(kwlist), &argName, &argResult)) {
+    if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sOs:QtCore.Slot",
+                                     const_cast<char **>(kwlist),
+                                     &argName, &argResult, &tag)) {
         return -1;
     }
 
@@ -87,6 +102,9 @@ int slotTpInit(PyObject *self, PyObject *args, PyObject *kw)
     if (argName)
         data->slotData->name = argName;
 
+    if (tag)
+        data->slotData->tag = tag;
+
     data->slotData->resultType = argResult
         ? PySide::Signal::getTypeName(argResult) : PySide::Signal::voidType();
 
@@ -95,7 +113,6 @@ int slotTpInit(PyObject *self, PyObject *args, PyObject *kw)
 
 PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
 {
-    static PyObject *pySlotName = nullptr;
     PyObject *callback = nullptr;
 
     if (!PyArg_UnpackTuple(args, "Slot.__call__", 1, 1, &callback))
@@ -114,24 +131,20 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
             data->slotData->name = funcName.isNull() ? "<no name>" : String::toCString(funcName);
         }
         const QByteArray returnType = QMetaObject::normalizedType(data->slotData->resultType);
-        const QByteArray signature =
-            returnType + ' ' + data->slotData->name + '(' + data->slotData->args + ')';
-
-        if (!pySlotName)
-            pySlotName = String::fromCString(PYSIDE_SLOT_LIST_ATTR);
+        const QByteArray signature = data->slotData->name + '(' + data->slotData->args + ')';
 
-        PyObject *pySignature = String::fromCString(signature);
-        PyObject *signatureList = nullptr;
+        PyObject *pySlotName = PySide::PySideMagicName::slot_list_attr();
+        PySide::Slot::DataList *entryList = nullptr;
         if (PyObject_HasAttr(callback, pySlotName)) {
-            signatureList = PyObject_GetAttr(callback, pySlotName);
+            auto *capsule = PyObject_GetAttr(callback, pySlotName);
+            entryList = PySide::Slot::dataListFromCapsule(capsule);
         } else {
-            signatureList = PyList_New(0);
-            PyObject_SetAttr(callback, pySlotName, signatureList);
-            Py_DECREF(signatureList);
+            entryList = new PySide::Slot::DataList{};
+            auto *capsule = PyCapsule_New(entryList, nullptr /* name */, slotDataListDestructor);
+            Py_INCREF(capsule);
+            PyObject_SetAttr(callback, pySlotName, capsule);
         }
-
-        PyList_Append(signatureList, pySignature);
-        Py_DECREF(pySignature);
+        entryList->append({signature, returnType, data->slotData->tag});
 
         //clear data
         delete data->slotData;
@@ -144,8 +157,17 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */)
 
 namespace PySide::Slot {
 
+DataList *dataListFromCapsule(PyObject *capsule)
+{
+    if (capsule != nullptr && PyCapsule_CheckExact(capsule) != 0) {
+        if (void *v = PyCapsule_GetPointer(capsule, nullptr))
+            return reinterpret_cast<DataList *>(v);
+    }
+    return nullptr;
+}
+
 static const char *Slot_SignatureStrings[] = {
-    "PySide6.QtCore.Slot(self,*types:type,name:str=nullptr,result:str=nullptr)",
+    "PySide6.QtCore.Slot(self,*types:type,name:str=nullptr,result:type=nullptr)",
     "PySide6.QtCore.Slot.__call__(self,function:typing.Callable)->typing.Any",
     nullptr}; // Sentinel
 
diff --git a/sources/pyside6/libpyside/pysideslot_p.h b/sources/pyside6/libpyside/pysideslot_p.h
index 695b7935c..9852301ee 100644
--- a/sources/pyside6/libpyside/pysideslot_p.h
+++ b/sources/pyside6/libpyside/pysideslot_p.h
@@ -4,10 +4,25 @@
 #define PYSIDE_SLOT_P_H
 
 #include <sbkpython.h>
-#define PYSIDE_SLOT_LIST_ATTR "_slots"
 
-namespace PySide { namespace Slot {
-    void init(PyObject* module);
-}}
+#include <QtCore/qbytearray.h>
+#include <QtCore/qlist.h>
 
-#endif
+namespace PySide::Slot {
+
+struct Data {
+    QByteArray signature;
+    QByteArray resultType;
+    QByteArray tag; // QMetaMethod::tag()
+};
+
+// This list is set as an attribute named PySide::PySideMagicName::slot_list_attr()
+// by the decorator for usage by MetaObjectBuilder.
+using DataList = QList<Data>;
+
+DataList *dataListFromCapsule(PyObject *capsule);
+
+void init(PyObject* module);
+} // namespace PySide::Slot
+
+#endif // PYSIDE_SLOT_P_H
diff --git a/sources/pyside6/libpyside/pysidestaticstrings.cpp b/sources/pyside6/libpyside/pysidestaticstrings.cpp
index 637e184be..3bddc84c2 100644
--- a/sources/pyside6/libpyside/pysidestaticstrings.cpp
+++ b/sources/pyside6/libpyside/pysidestaticstrings.cpp
@@ -13,7 +13,7 @@ PyObject *funcName() \
 
 namespace PySide
 {
-namespace PyName
+namespace PySideName
 {
 STATIC_STRING_IMPL(qtConnect, "connect")
 STATIC_STRING_IMPL(qtDisconnect, "disconnect")
@@ -23,16 +23,18 @@ STATIC_STRING_IMPL(fset, "fset")
 STATIC_STRING_IMPL(im_func, "im_func")
 STATIC_STRING_IMPL(im_self, "im_self")
 STATIC_STRING_IMPL(name, "name")
+STATIC_STRING_IMPL(orig_dict, "orig_dict")
 STATIC_STRING_IMPL(parameters, "parameters")
 STATIC_STRING_IMPL(property, "property")
 STATIC_STRING_IMPL(select_id, "select_id")
 } // namespace PyName
-namespace PyMagicName
+namespace PySideMagicName
 {
 STATIC_STRING_IMPL(code, "__code__")
 STATIC_STRING_IMPL(doc, "__doc__")
 STATIC_STRING_IMPL(func, "__func__")
 STATIC_STRING_IMPL(name, "__name__")
 STATIC_STRING_IMPL(property_methods, "__property_methods__")
+STATIC_STRING_IMPL(slot_list_attr, "_slots")
 } // namespace PyMagicName
 } // namespace PySide
diff --git a/sources/pyside6/libpyside/pysidestaticstrings.h b/sources/pyside6/libpyside/pysidestaticstrings.h
index eea0813a7..b4bc61800 100644
--- a/sources/pyside6/libpyside/pysidestaticstrings.h
+++ b/sources/pyside6/libpyside/pysidestaticstrings.h
@@ -9,7 +9,7 @@
 
 namespace PySide
 {
-namespace PyName
+namespace PySideName
 {
 PYSIDE_API PyObject *qtConnect();
 PYSIDE_API PyObject *qtDisconnect();
@@ -19,17 +19,19 @@ PYSIDE_API PyObject *fset();
 PYSIDE_API PyObject *im_func();
 PYSIDE_API PyObject *im_self();
 PYSIDE_API PyObject *name();
+PYSIDE_API PyObject *orig_dict();
 PYSIDE_API PyObject *parameters();
 PYSIDE_API PyObject *property();
 PYSIDE_API PyObject *select_id();
 } // namespace PyName
-namespace PyMagicName
+namespace PySideMagicName
 {
 PYSIDE_API PyObject *code();
 PYSIDE_API PyObject *doc();
 PYSIDE_API PyObject *func();
 PYSIDE_API PyObject *name();
 PYSIDE_API PyObject *property_methods();
+PYSIDE_API PyObject *slot_list_attr();
 } // namespace PyMagicName
 } // namespace PySide
 
diff --git a/sources/pyside6/libpyside/pysideutils.h b/sources/pyside6/libpyside/pysideutils.h
index 4a4062bfc..47c2f2c1b 100644
--- a/sources/pyside6/libpyside/pysideutils.h
+++ b/sources/pyside6/libpyside/pysideutils.h
@@ -8,8 +8,9 @@
 
 #include <pysidemacros.h>
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtclasshelpermacros.h>
 
+QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QString)
 QT_FORWARD_DECLARE_CLASS(QStringView)
 
@@ -36,6 +37,33 @@ PYSIDE_API QString pyPathToQString(PyObject *path);
 
 PYSIDE_API bool isCompiledMethod(PyObject *callback);
 
+struct debugPyTypeObject
+{
+    PYSIDE_API explicit debugPyTypeObject(const PyTypeObject *o) noexcept;
+
+    const PyTypeObject *m_object;
+};
+
+PYSIDE_API QDebug operator<<(QDebug debug, const debugPyTypeObject &o);
+
+struct debugPyObject
+{
+    PYSIDE_API explicit debugPyObject(PyObject *o) noexcept;
+
+    PyObject *m_object;
+};
+
+PYSIDE_API QDebug operator<<(QDebug debug, const debugPyObject &o);
+
+struct debugPyBuffer
+{
+    PYSIDE_API explicit debugPyBuffer(Py_buffer *b) noexcept;
+
+    Py_buffer *m_buffer;
+};
+
+PYSIDE_API QDebug operator<<(QDebug debug, const debugPyBuffer &b);
+
 } //namespace PySide
 
 #endif // PYSIDESTRING_H
diff --git a/sources/pyside6/libpyside/pysideweakref.cpp b/sources/pyside6/libpyside/pysideweakref.cpp
index 79a19fec8..5f3ca59e4 100644
--- a/sources/pyside6/libpyside/pysideweakref.cpp
+++ b/sources/pyside6/libpyside/pysideweakref.cpp
@@ -6,32 +6,37 @@
 #include <sbkpython.h>
 #include <shiboken.h>
 
-typedef struct {
+struct PySideCallableObject {
     PyObject_HEAD
     /* Type-specific fields go here. */
     PySideWeakRefFunction weakref_func;
     void *user_data;
-} PySideCallableObject;
+};
 
 static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args, PyObject *kw);
 
-static PyType_Slot PySideCallableObjectType_slots[] = {
-    {Py_tp_call, reinterpret_cast<void *>(CallableObject_call)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
-    {0, nullptr}
-};
-static PyType_Spec PySideCallableObjectType_spec = {
-    "1:PySide.Callable",
-    sizeof(PySideCallableObject),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PySideCallableObjectType_slots,
-};
-
+static PyTypeObject *createCallableObjectType()
+{
+    PyType_Slot PySideCallableObjectType_slots[] = {
+        {Py_tp_call, reinterpret_cast<void *>(CallableObject_call)},
+        {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PySideCallableObjectType_spec = {
+        "1:PySide.Callable",
+        sizeof(PySideCallableObject),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PySideCallableObjectType_slots,
+    };
+
+    return SbkType_FromSpec(&PySideCallableObjectType_spec);
+}
 
 static PyTypeObject *PySideCallableObject_TypeF()
 {
-    static auto *type = SbkType_FromSpec(&PySideCallableObjectType_spec);
+    static auto *type = createCallableObjectType();
     return type;
 }
 
@@ -44,7 +49,7 @@ static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args,
     Py_RETURN_NONE;
 }
 
-namespace PySide { namespace WeakRef {
+namespace PySide::WeakRef {
 
 PyObject *create(PyObject *obj, PySideWeakRefFunction func, void *userData)
 {
@@ -74,5 +79,4 @@ PyObject *create(PyObject *obj, PySideWeakRefFunction func, void *userData)
     return reinterpret_cast<PyObject *>(weak);
 }
 
-} }  //namespace
-
+} // namespace PySide::WeakRef
diff --git a/sources/pyside6/libpyside/pysideweakref.h b/sources/pyside6/libpyside/pysideweakref.h
index 71386903f..e29c73455 100644
--- a/sources/pyside6/libpyside/pysideweakref.h
+++ b/sources/pyside6/libpyside/pysideweakref.h
@@ -7,14 +7,12 @@
 #include <pysidemacros.h>
 #include <sbkpython.h>
 
-typedef void (*PySideWeakRefFunction)(void* userData);
+using PySideWeakRefFunction = void (*)(void *userData);
 
-namespace PySide { namespace WeakRef {
+namespace PySide::WeakRef {
 
 PYSIDE_API PyObject* create(PyObject* ob, PySideWeakRefFunction func, void* userData);
 
-} //PySide
-} //WeakRef
-
+} // namespace PySide::WeakRef
 
 #endif
diff --git a/sources/pyside6/libpyside/qobjectconnect.cpp b/sources/pyside6/libpyside/qobjectconnect.cpp
index 2d97a68d1..3c5b75953 100644
--- a/sources/pyside6/libpyside/qobjectconnect.cpp
+++ b/sources/pyside6/libpyside/qobjectconnect.cpp
@@ -3,6 +3,7 @@
 
 #include "qobjectconnect.h"
 #include "pysideqobject.h"
+#include "pysideqslotobject_p.h"
 #include "pysidesignal.h"
 #include "pysideutils.h"
 #include "signalmanager.h"
@@ -15,6 +16,10 @@
 #include <QtCore/QMetaMethod>
 #include <QtCore/QObject>
 
+#include <QtCore/private/qobject_p.h>
+
+#include <string_view>
+
 static bool isMethodDecorator(PyObject *method, bool is_pymethod, PyObject *self)
 {
     Shiboken::AutoDecRef methodName(PyObject_GetAttr(method, Shiboken::PyMagicName::name()));
@@ -29,6 +34,8 @@ static bool isMethodDecorator(PyObject *method, bool is_pymethod, PyObject *self
         function1 = PyMethod_GET_FUNCTION(otherMethod.object());
     } else {
         function1 = PyObject_GetAttr(otherMethod.object(), Shiboken::PyName::im_func());
+        if (function1 == nullptr)
+            return false;
         Py_DECREF(function1);
         // Not retaining a reference in line with what PyMethod_GET_FUNCTION does.
     }
@@ -61,12 +68,31 @@ QDebug operator<<(QDebug d, const GetReceiverResult &r)
     d.noquote();
     d.nospace();
     d << "GetReceiverResult(receiver=" << r.receiver << ", self=" << r.self
-      << ", sig=" << r.callbackSig << "slotIndex=" << r.slotIndex
+      << ", sig=\"" << r.callbackSig << "\", slotIndex=" << r.slotIndex
       << ", usingGlobalReceiver=" << r.usingGlobalReceiver << ')';
     return d;
 }
 #endif // QT_NO_DEBUG_STREAM
 
+static const char *getQualifiedName(PyObject *ob)
+{
+    Shiboken::AutoDecRef qualNameP(PyObject_GetAttr(ob, Shiboken::PyMagicName::qualname()));
+    return qualNameP.isNull()
+                ? nullptr : Shiboken::String::toCString(qualNameP.object());
+}
+
+// Determine whether a method is declared in a class using qualified name lookup.
+static bool isDeclaredIn(PyObject *method, const char *className)
+{
+    bool result = false;
+    if (auto *qualifiedNameC = getQualifiedName(PyMethod_Function(method))) {
+        std::string_view qualifiedName(qualifiedNameC);
+        if (const auto dot = qualifiedName.rfind('.'); dot != std::string::npos)
+            result = qualifiedName.substr(0, dot) == className;
+    }
+    return result;
+}
+
 static GetReceiverResult getReceiver(QObject *source, const char *signal,
                                      PyObject *callback)
 {
@@ -99,31 +125,40 @@ static GetReceiverResult getReceiver(QObject *source, const char *signal,
 
     result.usingGlobalReceiver = !result.receiver || forceGlobalReceiver;
 
-    // Check if this callback is a overwrite of a non-virtual Qt slot.
+    // Check if this callback is a overwrite of a non-virtual Qt slot (pre-Jira bug 1019).
+    // Make it possible to connect to a MyWidget.show() although QWidget.show()
+    // is a non-virtual slot which would be found by QMetaObject search.
+    // FIXME PYSIDE7: This is arguably a bit of a misguided "feature", remove?
     if (!result.usingGlobalReceiver && result.receiver && result.self) {
         result.callbackSig =
             PySide::Signal::getCallbackSignature(signal, result.receiver, callback,
-                                                 result.usingGlobalReceiver).toLatin1();
+                                                 result.usingGlobalReceiver);
         const QMetaObject *metaObject = result.receiver->metaObject();
         result.slotIndex = metaObject->indexOfSlot(result.callbackSig.constData());
-        if (result.slotIndex != -1 && result.slotIndex < metaObject->methodOffset()
-            && PyMethod_Check(callback)) {
-            result.usingGlobalReceiver = true;
-        }
+        if (PyMethod_Check(callback) != 0 && result.slotIndex != -1
+            && result.slotIndex < metaObject->methodOffset()) {
+             // Find the class in which the slot is declared.
+             while (result.slotIndex < metaObject->methodOffset())
+                 metaObject = metaObject->superClass();
+             // If the Python callback is not declared in the same class, assume it is
+             // a Python override. Resort to global receiver (PYSIDE-2418).
+             if (!isDeclaredIn(callback, metaObject->className()))
+                 result.usingGlobalReceiver = true;
+         }
     }
 
     const auto receiverThread = result.receiver ? result.receiver->thread() : nullptr;
 
     if (result.usingGlobalReceiver) {
         PySide::SignalManager &signalManager = PySide::SignalManager::instance();
-        result.receiver = signalManager.globalReceiver(source, callback);
+        result.receiver = signalManager.globalReceiver(source, callback, result.receiver);
         // PYSIDE-1354: Move the global receiver to the original receivers's thread
         // so that autoconnections work correctly.
         if (receiverThread && receiverThread != result.receiver->thread())
             result.receiver->moveToThread(receiverThread);
         result.callbackSig =
             PySide::Signal::getCallbackSignature(signal, result.receiver, callback,
-                                                 result.usingGlobalReceiver).toLatin1();
+                                                 result.usingGlobalReceiver);
         const QMetaObject *metaObject = result.receiver->metaObject();
         result.slotIndex = metaObject->indexOfSlot(result.callbackSig.constData());
     }
@@ -208,7 +243,50 @@ QMetaObject::Connection qobjectConnectCallback(QObject *source, const char *sign
         }
     }
 
-    auto connection = QMetaObject::connect(source, signalIndex, receiver.receiver, slotIndex, type);
+    QMetaObject::Connection connection{};
+    Py_BEGIN_ALLOW_THREADS // PYSIDE-2367, prevent threading deadlocks with connectNotify()
+    connection = QMetaObject::connect(source, signalIndex, receiver.receiver, slotIndex, type);
+    Py_END_ALLOW_THREADS
+    if (!connection) {
+        if (receiver.usingGlobalReceiver)
+            signalManager.releaseGlobalReceiver(source, receiver.receiver);
+        return {};
+    }
+
+    Q_ASSERT(receiver.receiver);
+    if (receiver.usingGlobalReceiver)
+        signalManager.notifyGlobalReceiver(receiver.receiver);
+
+    const QMetaMethod signalMethod = receiver.receiver->metaObject()->method(signalIndex);
+    static_cast<FriendlyQObject *>(source)->connectNotify(signalMethod);
+    return connection;
+}
+
+QMetaObject::Connection qobjectConnectCallback(QObject *source, const char *signal, QObject *context,
+                                               PyObject *callback, Qt::ConnectionType type)
+{
+    if (!signal || !PySide::Signal::checkQtSignal(signal))
+        return {};
+
+    const int signalIndex =
+        PySide::SignalManager::registerMetaMethodGetIndex(source, signal + 1,
+                                                          QMetaMethod::Signal);
+    if (signalIndex == -1)
+        return {};
+
+    // Extract receiver from callback
+    const GetReceiverResult receiver = getReceiver(source, signal + 1, callback);
+    if (receiver.receiver == nullptr && receiver.self == nullptr)
+        return {};
+
+    PySide::SignalManager &signalManager = PySide::SignalManager::instance();
+
+    PySideQSlotObject *slotObject = new PySideQSlotObject(callback);
+
+    QMetaObject::Connection connection{};
+    Py_BEGIN_ALLOW_THREADS // PYSIDE-2367, prevent threading deadlocks with connectNotify()
+    connection = QObjectPrivate::connect(source, signalIndex, context, slotObject, type);
+    Py_END_ALLOW_THREADS
     if (!connection) {
         if (receiver.usingGlobalReceiver)
             signalManager.releaseGlobalReceiver(source, receiver.receiver);
@@ -237,7 +315,11 @@ bool qobjectDisconnectCallback(QObject *source, const char *signal, PyObject *ca
     const int signalIndex = source->metaObject()->indexOfSignal(signal + 1);
     const int slotIndex = receiver.slotIndex;
 
-    if (!QMetaObject::disconnectOne(source, signalIndex, receiver.receiver, slotIndex))
+    bool ok{};
+    Py_BEGIN_ALLOW_THREADS // PYSIDE-2367, prevent threading deadlocks with disconnectNotify()
+    ok = QMetaObject::disconnectOne(source, signalIndex, receiver.receiver, slotIndex);
+    Py_END_ALLOW_THREADS
+    if (!ok)
         return false;
 
     Q_ASSERT(receiver.receiver);
diff --git a/sources/pyside6/libpyside/qobjectconnect.h b/sources/pyside6/libpyside/qobjectconnect.h
index 70b862233..c99b8006e 100644
--- a/sources/pyside6/libpyside/qobjectconnect.h
+++ b/sources/pyside6/libpyside/qobjectconnect.h
@@ -33,6 +33,11 @@ PYSIDE_API QMetaObject::Connection
     qobjectConnectCallback(QObject *source, const char *signal,
                            PyObject *callback, Qt::ConnectionType type);
 
+/// Helpers for QObject::connect(): Make a connection to a Python callback and a context object
+PYSIDE_API QMetaObject::Connection
+    qobjectConnectCallback(QObject *source, const char *signal, QObject *context,
+                           PyObject *callback, Qt::ConnectionType type);
+
 /// Helpers for QObject::disconnect(): Disconnect a Python callback
 PYSIDE_API bool qobjectDisconnectCallback(QObject *source, const char *signal,
                                           PyObject *callback);
diff --git a/sources/pyside6/libpyside/signalmanager.cpp b/sources/pyside6/libpyside/signalmanager.cpp
index 9a9d1c19b..f4c2bbf43 100644
--- a/sources/pyside6/libpyside/signalmanager.cpp
+++ b/sources/pyside6/libpyside/signalmanager.cpp
@@ -19,16 +19,21 @@
 #include <sbkconverter.h>
 #include <sbkstring.h>
 #include <sbkstaticstrings.h>
+#include <sbkerrors.h>
 
+#include <QtCore/QCoreApplication>
 #include <QtCore/QByteArrayView>
 #include <QtCore/QDebug>
 #include <QtCore/QHash>
 #include <QtCore/QScopedPointer>
+#include <QtCore/QTimerEvent>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 
+using namespace Qt::StringLiterals;
+
 #if QSLOT_CODE != 1 || QSIGNAL_CODE != 2
 #error QSLOT_CODE and/or QSIGNAL_CODE changed! change the hardcoded stuff to the correct value!
 #endif
@@ -36,21 +41,19 @@
 #define PYSIDE_SIGNAL '2'
 #include "globalreceiverv2.h"
 
-namespace {
-    static PyObject *metaObjectAttr = nullptr;
+static PyObject *metaObjectAttr = nullptr;
+static PyObject *parseArguments(const QMetaMethod &method, void **args);
 
-    static PyObject *parseArguments(const QList< QByteArray >& paramTypes, void **args);
-    static bool emitShortCircuitSignal(QObject *source, int signalIndex, PyObject *args);
+static bool qAppRunning = false;
 
-    static void destroyMetaObject(PyObject *obj)
-    {
-        void *ptr = PyCapsule_GetPointer(obj, nullptr);
-        auto meta = reinterpret_cast<PySide::MetaObjectBuilder *>(ptr);
-        SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta);
-        if (wrapper)
-            Shiboken::BindingManager::instance().releaseWrapper(wrapper);
-        delete meta;
-    }
+static void destroyMetaObject(PyObject *obj)
+{
+    void *ptr = PyCapsule_GetPointer(obj, nullptr);
+    auto meta = reinterpret_cast<PySide::MetaObjectBuilder *>(ptr);
+    SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta);
+    if (wrapper)
+        Shiboken::BindingManager::instance().releaseWrapper(wrapper);
+    delete meta;
 }
 
 static const char *metaCallName(QMetaObject::Call call)
@@ -71,6 +74,29 @@ static const char *metaCallName(QMetaObject::Call call)
     return it != mapping.constEnd() ? it.value() : "<Unknown>";
 }
 
+static QByteArray methodSignature(const QMetaMethod &method)
+{
+    QByteArray result;
+    if (auto *t = method.typeName()) {
+        result += t;
+        result += ' ';
+    }
+    result += method.methodSignature();
+    return result;
+}
+
+static QByteArray msgCannotConvertParameter(const QMetaMethod &method, qsizetype p)
+{
+    return "Cannot call meta function \""_ba + methodSignature(method)
+           + "\" because parameter " + QByteArray::number(p) + " of type \""_ba
+           + method.parameterTypeName(p) + "\" cannot be converted."_ba;
+}
+
+static QByteArray msgCannotConvertReturn(const QMetaMethod &method)
+{
+    return "The return value of \""_ba + methodSignature(method) + "\" cannot be converted."_ba;
+}
+
 namespace PySide {
 
 PyObjectWrapper::PyObjectWrapper()
@@ -128,6 +154,14 @@ PyObjectWrapper::operator PyObject *() const
     return m_me;
 }
 
+
+int PyObjectWrapper::toInt() const
+{
+    // hold the GIL
+    Shiboken::GilState state;
+    return Shiboken::Enum::check(m_me) ? Shiboken::Enum::getValue(m_me) : -1;
+}
+
 QDataStream &operator<<(QDataStream &out, const PyObjectWrapper &myObj)
 {
     if (Py_IsInitialized() == 0) {
@@ -187,33 +221,66 @@ QDataStream &operator>>(QDataStream &in, PyObjectWrapper &myObj)
 
 };
 
+namespace PySide {
+using GlobalReceiverV2Ptr = std::shared_ptr<GlobalReceiverV2>;
+using GlobalReceiverV2Map = QHash<PySide::GlobalReceiverKey, GlobalReceiverV2Ptr>;
+}
+
 using namespace PySide;
 
-struct SignalManager::SignalManagerPrivate
+// Listen for destroy() of main thread objects and ensure cleanup
+class SignalManagerDestroyListener : public QObject
 {
-    GlobalReceiverV2MapPtr m_globalReceivers;
-    static SignalManager::QmlMetaCallErrorHandler m_qmlMetaCallErrorHandler;
+    Q_OBJECT
+public:
+    Q_DISABLE_COPY_MOVE(SignalManagerDestroyListener)
 
-    SignalManagerPrivate() : m_globalReceivers(new GlobalReceiverV2Map{})
-    {
-    }
+    using QObject::QObject;
 
-    ~SignalManagerPrivate()
-    {
-        if (!m_globalReceivers.isNull()) {
-            // Delete receivers by always retrieving the current first element, because deleting a
-            // receiver can indirectly delete another one, and if we use qDeleteAll, that could
-            // cause either a double delete, or iterator invalidation, and thus undefined behavior.
-            while (!m_globalReceivers->isEmpty())
-                delete *m_globalReceivers->cbegin();
-            Q_ASSERT(m_globalReceivers->isEmpty());
-        }
+public Q_SLOTS:
+    void destroyNotify(const QObject *);
+
+protected:
+    void timerEvent(QTimerEvent *event) override;
+
+private:
+    int m_timerId = -1;
+};
+
+void SignalManagerDestroyListener::destroyNotify(const QObject *)
+{
+    if (qAppRunning && m_timerId == -1)
+        m_timerId = startTimer(0);
+}
+
+void SignalManagerDestroyListener::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_timerId) {
+        killTimer(std::exchange(m_timerId, -1));
+        SignalManager::instance().purgeEmptyGlobalReceivers();
     }
+}
+
+struct SignalManager::SignalManagerPrivate
+{
+    Q_DISABLE_COPY_MOVE(SignalManagerPrivate)
+
+    SignalManagerPrivate() noexcept = default;
+    ~SignalManagerPrivate() { clear(); }
+
+    void deleteGlobalReceiver(const QObject *gr);
+    void clear();
+    void purgeEmptyGlobalReceivers();
+
+    GlobalReceiverV2Map m_globalReceivers;
+    static SignalManager::QmlMetaCallErrorHandler m_qmlMetaCallErrorHandler;
 
     static void handleMetaCallError(QObject *object, int *result);
     static int qtPropertyMetacall(QObject *object, QMetaObject::Call call,
                                   int id, void **args);
     static int qtMethodMetacall(QObject *object, int id, void **args);
+
+    QPointer<SignalManagerDestroyListener> m_listener;
 };
 
 SignalManager::QmlMetaCallErrorHandler
@@ -247,6 +314,8 @@ SignalManager::SignalManager() : m_d(new SignalManagerPrivate)
 
     // Register PyObject type to use in queued signal and slot connections
     qRegisterMetaType<PyObjectWrapper>("PyObject");
+    // Register QVariant(enum) conversion to QVariant(int)
+    QMetaType::registerConverter<PyObjectWrapper, int>(&PyObjectWrapper::toInt);
 
     SbkConverter *converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type, nullptr);
     Shiboken::Conversions::setCppPointerToPythonFunction(converter, PyObject_PTR_CppToPython_PyObject);
@@ -264,8 +333,7 @@ SignalManager::SignalManager() : m_d(new SignalManagerPrivate)
 
 void SignalManager::clear()
 {
-    delete m_d;
-    m_d = new SignalManagerPrivate();
+    m_d->clear();
 }
 
 SignalManager::~SignalManager()
@@ -284,52 +352,118 @@ void SignalManager::setQmlMetaCallErrorHandler(QmlMetaCallErrorHandler handler)
     SignalManagerPrivate::m_qmlMetaCallErrorHandler = handler;
 }
 
-QObject *SignalManager::globalReceiver(QObject *sender, PyObject *callback)
+static void qAppAboutToQuit()
 {
-    GlobalReceiverV2MapPtr globalReceivers = m_d->m_globalReceivers;
-    GlobalReceiverKey key = GlobalReceiverV2::key(callback);
-    GlobalReceiverV2 *gr = nullptr;
-    auto it = globalReceivers->find(key);
-    if (it == globalReceivers->end()) {
-        gr = new GlobalReceiverV2(callback, globalReceivers);
-        globalReceivers->insert(key, gr);
-        if (sender) {
-            gr->incRef(sender); // create a link reference
-            gr->decRef(); // remove extra reference
+    qAppRunning = false;
+    SignalManager::instance().purgeEmptyGlobalReceivers();
+}
+
+static bool isInMainThread(const QObject *o)
+{
+    if (o->isWidgetType() || o->isWindowType() || o->isQuickItemType())
+        return true;
+    auto *app = QCoreApplication::instance();
+    return app != nullptr && app->thread() == o->thread();
+}
+
+QObject *SignalManager::globalReceiver(QObject *sender, PyObject *callback, QObject *receiver)
+{
+    if (m_d->m_listener.isNull() && !QCoreApplication::closingDown()) {
+        if (auto *app = QCoreApplication::instance()) {
+            // The signal manager potentially outlives QCoreApplication, ensure deletion
+            m_d->m_listener = new SignalManagerDestroyListener(app);
+            m_d->m_listener->setObjectName("qt_pyside_signalmanagerdestroylistener");
+            QObject::connect(app, &QCoreApplication::aboutToQuit, qAppAboutToQuit);
+            qAppRunning = true;
+        }
+    }
+
+    auto &globalReceivers = m_d->m_globalReceivers;
+    const GlobalReceiverKey key = GlobalReceiverV2::key(callback);
+    auto it = globalReceivers.find(key);
+    if (it == globalReceivers.end()) {
+        auto gr = std::make_shared<GlobalReceiverV2>(callback, receiver);
+        it = globalReceivers.insert(key, gr);
+    }
+
+    if (sender != nullptr) {
+        it.value()->incRef(sender); // create a link reference
+
+        // For main thread-objects, add a notification for destroy (PYSIDE-2646, 2141)
+        if (qAppRunning && !m_d->m_listener.isNull() && isInMainThread(sender)) {
+            QObject::connect(sender, &QObject::destroyed,
+                             m_d->m_listener, &SignalManagerDestroyListener::destroyNotify,
+                             Qt::UniqueConnection);
         }
-    } else {
-        gr = it.value();
-        if (sender)
-            gr->incRef(sender);
     }
 
-    return reinterpret_cast<QObject *>(gr);
+    return it.value().get();
 }
 
-int SignalManager::countConnectionsWith(const QObject *object)
+void SignalManager::purgeEmptyGlobalReceivers()
 {
-    int count = 0;
-    for (GlobalReceiverV2Map::const_iterator it = m_d->m_globalReceivers->cbegin(), end = m_d->m_globalReceivers->cend(); it != end; ++it) {
-        if (it.value()->refCount(object))
-            count++;
-    }
-    return count;
+    m_d->purgeEmptyGlobalReceivers();
 }
 
 void SignalManager::notifyGlobalReceiver(QObject *receiver)
 {
     reinterpret_cast<GlobalReceiverV2 *>(receiver)->notify();
+    purgeEmptyGlobalReceivers();
 }
 
 void SignalManager::releaseGlobalReceiver(const QObject *source, QObject *receiver)
 {
-    auto gr = reinterpret_cast<GlobalReceiverV2 *>(receiver);
+    auto gr = static_cast<GlobalReceiverV2 *>(receiver);
     gr->decRef(source);
+    if (gr->isEmpty())
+        m_d->deleteGlobalReceiver(gr);
+}
+
+void SignalManager::deleteGlobalReceiver(const QObject *gr)
+{
+    SignalManager::instance().m_d->deleteGlobalReceiver(gr);
+}
+
+void SignalManager::SignalManagerPrivate::deleteGlobalReceiver(const QObject *gr)
+{
+    for (auto it = m_globalReceivers.begin(), end = m_globalReceivers.end(); it != end; ++it) {
+        if (it.value().get() == gr) {
+            m_globalReceivers.erase(it);
+            break;
+        }
+    }
+}
+
+void SignalManager::SignalManagerPrivate::clear()
+{
+    // Delete receivers by always retrieving the current first element,
+    // because deleting a receiver can indirectly delete another one
+    // via ~DynamicSlotDataV2(). Using ~QHash/clear() could cause an
+    // iterator invalidation, and thus undefined behavior.
+    while (!m_globalReceivers.isEmpty())
+        m_globalReceivers.erase(m_globalReceivers.cbegin());
+}
+
+static bool isEmptyGlobalReceiver(const GlobalReceiverV2Ptr &g)
+{
+    return g->isEmpty();
+}
+
+void SignalManager::SignalManagerPrivate::purgeEmptyGlobalReceivers()
+{
+    // Delete repetitively (see comment in clear()).
+    while (true) {
+        auto it = std::find_if(m_globalReceivers.cbegin(), m_globalReceivers.cend(),
+                               isEmptyGlobalReceiver);
+        if (it == m_globalReceivers.cend())
+            break;
+        m_globalReceivers.erase(it);
+    }
 }
 
 int SignalManager::globalReceiverSlotIndex(QObject *receiver, const char *signature) const
 {
-    return reinterpret_cast<GlobalReceiverV2 *>(receiver)->addSlot(signature);
+    return static_cast<GlobalReceiverV2 *>(receiver)->addSlot(signature);
 }
 
 bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *args)
@@ -339,16 +473,7 @@ bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *ar
     signal++;
 
     int signalIndex = source->metaObject()->indexOfSignal(signal);
-    if (signalIndex != -1) {
-        // cryptic but works!
-        // if the signature doesn't have a '(' it's a shor circuited signal, i.e. std::find
-        // returned the string null terminator.
-        bool isShortCircuit = !*std::find(signal, signal + std::strlen(signal), '(');
-        return isShortCircuit
-            ? emitShortCircuitSignal(source, signalIndex, args)
-            : MetaFunction::call(source, signalIndex, args);
-    }
-    return false;
+    return signalIndex != -1 && MetaFunction::call(source, signalIndex, args);
 }
 
 // Handle errors from meta calls. Requires GIL and PyErr_Occurred()
@@ -392,7 +517,6 @@ int SignalManager::SignalManagerPrivate::qtPropertyMetacall(QObject *object,
     auto *pySbkSelf = Shiboken::BindingManager::instance().retrieveWrapper(object);
     Q_ASSERT(pySbkSelf);
     auto *pySelf = reinterpret_cast<PyObject *>(pySbkSelf);
-    Q_ASSERT(pySelf);
     Shiboken::AutoDecRef pp_name(Shiboken::String::fromCString(mp.name()));
     PySideProperty *pp = Property::getObject(pySelf, pp_name);
     if (!pp) {
@@ -400,9 +524,25 @@ int SignalManager::SignalManagerPrivate::qtPropertyMetacall(QObject *object,
         return false;
     }
     pp->d->metaCall(pySelf, call, args);
-    Py_XDECREF(pp);
-
+    Py_DECREF(pp);
     if (PyErr_Occurred()) {
+        // PYSIDE-2160: An unknown type was reported. Indicated by StopIteration.
+        if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+            PyObject *excType, *excValue, *excTraceback;
+            PyErr_Fetch(&excType, &excValue, &excTraceback);
+            bool ign = call == QMetaObject::WriteProperty;
+            PyErr_WarnFormat(PyExc_RuntimeWarning, 0,
+                ign ? "Unknown property type '%s' of QObject '%s' used in fset"
+                    : "Unknown property type '%s' of QObject '%s' used in fget with %R",
+                pp->d->typeName.constData(), metaObject->className(), excValue);
+            if (PyErr_Occurred())
+                Shiboken::Errors::storeErrorOrPrint();
+            Py_DECREF(excType);
+            Py_DECREF(excValue);
+            Py_XDECREF(excTraceback);
+            return result;
+        }
+
         qWarning().noquote().nospace()
             << "An error occurred executing the property metacall " << call
             << " on property \"" << mp.name() << "\" of " << object;
@@ -439,7 +579,7 @@ int SignalManager::SignalManagerPrivate::qtMethodMetacall(QObject *object,
             PyErr_Format(PyExc_AttributeError, "Slot '%s::%s' not found.",
                          metaObject->className(), method.methodSignature().constData());
         } else {
-            SignalManager::callPythonMetaMethod(method, args, pyMethod, false);
+            SignalManager::callPythonMetaMethod(method, args, pyMethod);
         }
     }
     // WARNING Isn't safe to call any metaObject and/or object methods beyond this point
@@ -477,43 +617,38 @@ int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id,
                 << metaCallName(call) << " #" << id << ' '  << object;
             id -= object->metaObject()->methodCount();
             break;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
+        case QMetaObject::ConstructInPlace:
+            break;
+#endif
     }
     return id;
 }
 
-int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args, PyObject *pyMethod, bool isShortCuit)
+int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args, PyObject *pyMethod)
 {
     Q_ASSERT(pyMethod);
 
     Shiboken::GilState gil;
-    PyObject *pyArguments = nullptr;
-
-    if (isShortCuit){
-        pyArguments = reinterpret_cast<PyObject *>(args[1]);
-    } else {
-        pyArguments = parseArguments(method.parameterTypes(), args);
-    }
+    PyObject *pyArguments = parseArguments(method, args);
 
     if (pyArguments) {
         QScopedPointer<Shiboken::Conversions::SpecificConverter> retConverter;
         const char *returnType = method.typeName();
-        if (returnType && std::strcmp("", returnType) && std::strcmp("void", returnType)) {
+        if (returnType != nullptr && returnType[0] != 0 && std::strcmp("void", returnType) != 0) {
             retConverter.reset(new Shiboken::Conversions::SpecificConverter(returnType));
             if (!retConverter->isValid()) {
-                PyErr_Format(PyExc_RuntimeError, "Can't find converter for '%s' to call Python meta method.", returnType);
+                PyErr_SetString(PyExc_RuntimeError, msgCannotConvertReturn(method).constData());
                 return -1;
             }
         }
 
         Shiboken::AutoDecRef retval(PyObject_CallObject(pyMethod, pyArguments));
 
-        if (!isShortCuit && pyArguments){
-            Py_DECREF(pyArguments);
-        }
+        Py_DECREF(pyArguments);
 
-        if (!retval.isNull() && retval != Py_None && !PyErr_Occurred() && retConverter) {
+        if (!retval.isNull() && retval != Py_None && !PyErr_Occurred() && retConverter)
             retConverter->toCpp(retval, args[0]);
-        }
     }
 
     return -1;
@@ -607,7 +742,9 @@ int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signa
     if (methodIndex == -1) {
         SbkObject *self = Shiboken::BindingManager::instance().retrieveWrapper(source);
         if (!Shiboken::Object::hasCppWrapper(self)) {
-            qWarning() << "Invalid Signal signature:" << signature;
+            qWarning().noquote().nospace() << __FUNCTION__
+                << ": Cannot add dynamic method \"" << signature << "\" (" << type
+                << ") to " << source << ": No Wrapper found.";
             return -1;
         }
         auto *pySelf = reinterpret_cast<PyObject *>(self);
@@ -625,8 +762,8 @@ int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signa
         if (type == QMetaMethod::Slot) {
             qCWarning(lcPySide).noquote().nospace()
                 << "Warning: Registering dynamic slot \""
-                << signature << "\" on " << source->metaObject()->className()
-                << ". Consider annotating with " << slotSignature(signature);
+                << signature << "\" on \"" << source->metaObject()->className()
+                << "\". Consider annotating with " << slotSignature(signature);
         }
 
         return type == QMetaMethod::Signal
@@ -655,33 +792,24 @@ const QMetaObject *SignalManager::retrieveMetaObject(PyObject *self)
     return builder->update();
 }
 
-namespace {
-
-static PyObject *parseArguments(const QList<QByteArray>& paramTypes, void **args)
+static PyObject *parseArguments(const QMetaMethod &method, void **args)
 {
+    const auto &paramTypes = method.parameterTypes();
     const qsizetype argsSize = paramTypes.size();
     PyObject *preparedArgs = PyTuple_New(argsSize);
 
     for (qsizetype i = 0; i < argsSize; ++i) {
         void *data = args[i+1];
-        const char *dataType = paramTypes[i].constData();
-        Shiboken::Conversions::SpecificConverter converter(dataType);
-        if (converter) {
-            PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data));
-        } else {
-            PyErr_Format(PyExc_TypeError, "Can't call meta function because I have no idea how to handle %s", dataType);
+        auto param = paramTypes.at(i);
+        Shiboken::Conversions::SpecificConverter converter(param.constData());
+        if (!converter) {
+            PyErr_SetString(PyExc_TypeError, msgCannotConvertParameter(method, i).constData());
             Py_DECREF(preparedArgs);
             return nullptr;
         }
+        PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data));
     }
     return preparedArgs;
 }
 
-static bool emitShortCircuitSignal(QObject *source, int signalIndex, PyObject *args)
-{
-    void *signalArgs[2] = {nullptr, args};
-    source->qt_metacall(QMetaObject::InvokeMetaMethod, signalIndex, signalArgs);
-    return true;
-}
-
-} //namespace
+#include "signalmanager.moc"
diff --git a/sources/pyside6/libpyside/signalmanager.h b/sources/pyside6/libpyside/signalmanager.h
index 60cf4e75e..397700df1 100644
--- a/sources/pyside6/libpyside/signalmanager.h
+++ b/sources/pyside6/libpyside/signalmanager.h
@@ -35,6 +35,14 @@ public:
     ~PyObjectWrapper();
     operator PyObject*() const;
 
+    // FIXME: To be removed in Qt7
+    // This was done to make QAbstractItemModel::data() work without explicit conversion of
+    // QVariant(PyObjectWrapper) to QVariant(int). This works because QAbstractItemModel::data()
+    // inturn calls legacyEnumValueFromModelData(const QVariant &data). But this function will
+    // be removed in Qt7.
+    // The proper fix would be to associate PyObjectWrapper to the corresponding C++ Enum.
+    int toInt() const;
+
 private:
     PyObject* m_me;
 };
@@ -44,15 +52,16 @@ PYSIDE_API QDataStream &operator>>(QDataStream& in, PyObjectWrapper& myObj);
 
 class PYSIDE_API SignalManager
 {
-    Q_DISABLE_COPY(SignalManager)
 public:
+    Q_DISABLE_COPY_MOVE(SignalManager)
+
     using QmlMetaCallErrorHandler = std::optional<int>(*)(QObject *object);
 
     static SignalManager& instance();
 
     static void setQmlMetaCallErrorHandler(QmlMetaCallErrorHandler handler);
 
-    QObject* globalReceiver(QObject* sender, PyObject* callback);
+    QObject* globalReceiver(QObject *sender, PyObject *callback, QObject *receiver = nullptr);
     void releaseGlobalReceiver(const QObject* sender, QObject* receiver);
     int globalReceiverSlotIndex(QObject* sender, const char* slotSignature) const;
     void notifyGlobalReceiver(QObject* receiver);
@@ -67,14 +76,14 @@ public:
     // used to discovery metaobject
     static const QMetaObject* retrieveMetaObject(PyObject* self);
 
-    // Used to discovery if SignalManager was connected with object "destroyed()" signal.
-    int countConnectionsWith(const QObject *object);
-
     // Disconnect all signals managed by Globalreceiver
     void clear();
+    void purgeEmptyGlobalReceivers();
 
     // Utility function to call a python method usign args received in qt_metacall
-    static int callPythonMetaMethod(const QMetaMethod& method, void** args, PyObject* obj, bool isShortCuit);
+    static int callPythonMetaMethod(const QMetaMethod& method, void** args, PyObject* obj);
+
+    static void deleteGlobalReceiver(const QObject *globalReceiver);
 
 private:
     struct SignalManagerPrivate;
diff --git a/sources/pyside6/libpysideqml/CMakeLists.txt b/sources/pyside6/libpysideqml/CMakeLists.txt
index ed9049def..1af8c02cf 100644
--- a/sources/pyside6/libpysideqml/CMakeLists.txt
+++ b/sources/pyside6/libpysideqml/CMakeLists.txt
@@ -1,5 +1,24 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 set(libpysideqml_libraries Qt::Core Qt::CorePrivate Qt::Qml Qt::QmlPrivate)
 
+set(libpysideqml_HEADERS # installed below
+    pysideqmlattached.h
+    pysideqmlattached_p.h
+    pysideqmlextended_p.h
+    pysideqmlforeign_p.h
+    pysideqml.h
+    pysideqmllistproperty_p.h
+    pysideqmlmacros.h
+    pysideqmlmetacallerror_p.h
+    pysideqmlnamedelement_p.h
+    pysideqmlregistertype.h
+    pysideqmlregistertype_p.h
+    pysideqmltypeinfo_p.h
+    pysideqmluncreatable.h
+)
+
 set(libpysideqml_SRC
     pysideqml.cpp
     pysideqmlattached.cpp
@@ -11,6 +30,12 @@ set(libpysideqml_SRC
     pysideqmlnamedelement.cpp
     pysideqmluncreatable.cpp
     pysideqmltypeinfo.cpp
+    ${libpysideqml_HEADERS}
+)
+
+# Hack for // https://github.com/python/cpython/issues/86286 causes issues
+set_source_files_properties(
+    pysideqmlmetacallerror.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON
 )
 
 add_library(pyside6qml SHARED ${libpysideqml_SRC} ${other_files})
@@ -21,6 +46,8 @@ target_include_directories(pyside6qml PUBLIC
   $<INSTALL_INTERFACE:include/PySide6Qml>
 )
 
+target_compile_definitions(pyside6qml PRIVATE -DQT_LEAN_HEADERS=1 -DQT_NO_KEYWORDS=1)
+
 target_link_libraries(pyside6qml
                       PRIVATE PySide6::pyside6 Shiboken6::libshiboken ${libpysideqml_libraries})
 
@@ -32,7 +59,7 @@ set_target_properties(pyside6qml PROPERTIES
 
 target_compile_definitions(pyside6qml PRIVATE -DQT_LEAN_HEADERS=1)
 
-set_property(TARGET pyside6 PROPERTY CXX_STANDARD 17)
+set_property(TARGET pyside6qml PROPERTY CXX_STANDARD 17)
 
 if(PYSIDE_QT_CONF_PREFIX)
     set_property(SOURCE pysideqml.cpp
@@ -45,22 +72,6 @@ endif()
 # install stuff
 #
 
-set(libpysideqml_HEADERS
-    pysideqmlattached.h
-    pysideqmlattached_p.h
-    pysideqmlextended_p.h
-    pysideqmlforeign_p.h
-    pysideqml.h
-    pysideqmllistproperty_p.h
-    pysideqmlmacros.h
-    pysideqmlmetacallerror_p.h
-    pysideqmlnamedelement_p.h
-    pysideqmlregistertype.h
-    pysideqmlregistertype_p.h
-    pysideqmltypeinfo_p.h
-    pysideqmluncreatable.h
-)
-
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(LIBRARY_OUTPUT_SUFFIX ${CMAKE_DEBUG_POSTFIX})
 else()
diff --git a/sources/pyside6/libpysideqml/pysideqml.cpp b/sources/pyside6/libpysideqml/pysideqml.cpp
index aeb2e6910..3fe673fdf 100644
--- a/sources/pyside6/libpysideqml/pysideqml.cpp
+++ b/sources/pyside6/libpysideqml/pysideqml.cpp
@@ -11,6 +11,7 @@
 #include "pysideqmlmetacallerror_p.h"
 
 #include <QtQml/QQmlPropertyMap>
+#include <QtQml/QQmlComponent>
 
 #include <signalmanager.h>
 
@@ -28,6 +29,7 @@ void init(PyObject *module)
     PySide::SignalManager::setQmlMetaCallErrorHandler(PySide::Qml::qmlMetaCallErrorHandler);
 
     qRegisterMetaType<QQmlPropertyMap *>(); // PYSIDE-1845, QQmlPropertyMap * properties
+    qRegisterMetaType<QQmlComponent *>(); // PYSIDE-2415, QQmlComponent * properties
 }
 
 } //namespace PySide::Qml
diff --git a/sources/pyside6/libpysideqml/pysideqmlattached.cpp b/sources/pyside6/libpysideqml/pysideqmlattached.cpp
index 295cb7595..d484257e2 100644
--- a/sources/pyside6/libpysideqml/pysideqmlattached.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlattached.cpp
@@ -14,7 +14,6 @@
 #include <signature.h>
 #include <sbkstring.h>
 
-#include <QtCore/QtGlobal>
 #include <QtQml/qqml.h>
 
 #include <algorithm>
@@ -173,10 +172,10 @@ void initQmlAttached(PyObject *module)
 }
 
 PySide::Qml::QmlExtensionInfo qmlAttachedInfo(PyTypeObject *t,
-                                              const QSharedPointer<QmlTypeInfo> &info)
+                                              const std::shared_ptr<QmlTypeInfo> &info)
 {
     PySide::Qml::QmlExtensionInfo result{nullptr, nullptr};
-    if (info.isNull() || info->attachedType == nullptr)
+    if (!info || info->attachedType == nullptr)
         return result;
 
     auto *name = reinterpret_cast<PyTypeObject *>(t)->tp_name;
diff --git a/sources/pyside6/libpysideqml/pysideqmlattached.h b/sources/pyside6/libpysideqml/pysideqmlattached.h
index 9365b68d3..96f788268 100644
--- a/sources/pyside6/libpysideqml/pysideqmlattached.h
+++ b/sources/pyside6/libpysideqml/pysideqmlattached.h
@@ -8,7 +8,7 @@
 
 #include "pysideqmlmacros.h"
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtconfigmacros.h>
 
 QT_FORWARD_DECLARE_CLASS(QObject)
 
diff --git a/sources/pyside6/libpysideqml/pysideqmlattached_p.h b/sources/pyside6/libpysideqml/pysideqmlattached_p.h
index 93b1bb0e6..7c8a47fb8 100644
--- a/sources/pyside6/libpysideqml/pysideqmlattached_p.h
+++ b/sources/pyside6/libpysideqml/pysideqmlattached_p.h
@@ -6,7 +6,7 @@
 
 #include <sbkpython.h>
 
-#include <QtCore/QSharedPointer>
+#include <memory>
 
 namespace PySide::Qml {
 struct QmlExtensionInfo;
@@ -15,7 +15,7 @@ struct QmlTypeInfo;
 void initQmlAttached(PyObject *module);
 
 PySide::Qml::QmlExtensionInfo qmlAttachedInfo(PyTypeObject *t,
-                                              const QSharedPointer<QmlTypeInfo> &info);
+                                              const std::shared_ptr<QmlTypeInfo> &info);
 } // namespace PySide::Qml
 
 #endif // PYSIDEQMLATTACHED_P_H
diff --git a/sources/pyside6/libpysideqml/pysideqmlextended.cpp b/sources/pyside6/libpysideqml/pysideqmlextended.cpp
index e42fe20dd..23543d589 100644
--- a/sources/pyside6/libpysideqml/pysideqmlextended.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlextended.cpp
@@ -12,7 +12,6 @@
 #include <signature.h>
 #include <sbkstring.h>
 
-#include <QtCore/QtGlobal>
 #include <QtQml/qqml.h>
 
 // The QmlExtended decorator modifies QmlElement to register an extension.
@@ -92,7 +91,7 @@ static QObject *extensionFactory(QObject *o)
 
     auto *pyObjType = Py_TYPE(pyObj);
     const auto info = qmlTypeInfo(reinterpret_cast<PyObject *>(pyObjType));
-    if (info.isNull() || info->extensionType == nullptr) {
+    if (!info || info->extensionType == nullptr) {
         qWarning("QmlExtended: Cannot find extension of %s.", pyObjType->tp_name);
         return nullptr;
     }
@@ -128,10 +127,10 @@ void initQmlExtended(PyObject *module)
 }
 
 PySide::Qml::QmlExtensionInfo qmlExtendedInfo(PyObject *t,
-                                              const QSharedPointer<QmlTypeInfo> &info)
+                                              const std::shared_ptr<QmlTypeInfo> &info)
 {
     PySide::Qml::QmlExtensionInfo result{nullptr, nullptr};
-    if (!info.isNull() && info->extensionType) {
+    if (info && info->extensionType) {
         result.metaObject = PySide::retrieveMetaObject(info->extensionType);
         if (result.metaObject) {
             result.factory = extensionFactory;
diff --git a/sources/pyside6/libpysideqml/pysideqmlextended_p.h b/sources/pyside6/libpysideqml/pysideqmlextended_p.h
index 9650a26c3..17d6dae64 100644
--- a/sources/pyside6/libpysideqml/pysideqmlextended_p.h
+++ b/sources/pyside6/libpysideqml/pysideqmlextended_p.h
@@ -6,7 +6,7 @@
 
 #include <sbkpython.h>
 
-#include <QtCore/QSharedPointer>
+#include <memory>
 
 namespace PySide::Qml {
 struct QmlExtensionInfo;
@@ -15,7 +15,7 @@ struct QmlTypeInfo;
 void initQmlExtended(PyObject *module);
 
 PySide::Qml::QmlExtensionInfo qmlExtendedInfo(PyObject *t,
-                                              const QSharedPointer<QmlTypeInfo> &info);
+                                              const std::shared_ptr<QmlTypeInfo> &info);
 } // namespace PySide::Qml
 
 #endif // PYSIDEQMLEXTENDED_P_H
diff --git a/sources/pyside6/libpysideqml/pysideqmlforeign.cpp b/sources/pyside6/libpysideqml/pysideqmlforeign.cpp
index 67aea1756..18d39d121 100644
--- a/sources/pyside6/libpysideqml/pysideqmlforeign.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlforeign.cpp
@@ -11,7 +11,6 @@
 #include <signature.h>
 #include <sbkstring.h>
 
-#include <QtCore/QtGlobal>
 #include <QtCore/QDebug>
 
 // The QmlForeign decorator modifies QmlElement to create a different type
@@ -73,7 +72,7 @@ PyTypeObject *PySideQmlForeign_TypeF(void)
 
 } // extern "C"
 
-static const char *qmlAttached_SignatureStrings[] = {
+static const char *qmlForeign_SignatureStrings[] = {
     "PySide6.QtQml.QmlForeign(self,type:type)",
     nullptr // Sentinel
 };
@@ -82,7 +81,7 @@ namespace PySide::Qml {
 
 void initQmlForeign(PyObject *module)
 {
-    if (InitSignatureStrings(PySideQmlForeign_TypeF(), qmlAttached_SignatureStrings) < 0)
+    if (InitSignatureStrings(PySideQmlForeign_TypeF(), qmlForeign_SignatureStrings) < 0)
         return;
 
     Py_INCREF(PySideQmlForeign_TypeF());
diff --git a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
index a23b1af42..75bb5af96 100644
--- a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
@@ -5,6 +5,7 @@
 #include "pysideqmlregistertype_p.h"
 
 #include <shiboken.h>
+#include <pep384ext.h>
 #include <signature.h>
 
 #include <pysideproperty.h>
@@ -33,30 +34,51 @@ extern "C"
 
 static PyObject *propList_tp_new(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */)
 {
-    PySideProperty *me = reinterpret_cast<PySideProperty *>(subtype->tp_alloc(subtype, 0));
+    auto *me = PepExt_TypeCallAlloc<PySideProperty>(subtype, 0);
     me->d = new QmlListPropertyPrivate;
     return reinterpret_cast<PyObject *>(me);
 }
 
 static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    static const char *kwlist[] = {"type", "append", "count", "at", "clear", "replace", "removeLast", 0};
+    static const char *kwlist[] = {"type", "append", "count", "at", "clear",
+                                   "replace", "removeLast",
+                                   "doc", "notify", // PySideProperty
+                                   "designable", "scriptable", "stored",
+                                   "user", "constant", "final",
+                                   nullptr};
     PySideProperty *pySelf = reinterpret_cast<PySideProperty *>(self);
 
     auto *data = static_cast<QmlListPropertyPrivate *>(pySelf->d);
 
+    char *doc{};
+
     if (!PyArg_ParseTupleAndKeywords(args, kwds,
-                                     "O|OOOOOO:QtQml.ListProperty", (char **) kwlist,
+                                     "O|OOOOOOsObbbbbb:QtQml.ListProperty",
+                                     const_cast<char **>(kwlist),
                                      &data->type,
                                      &data->append,
                                      &data->count,
                                      &data->at,
                                      &data->clear,
                                      &data->replace,
-                                     &data->removeLast)) {
+                                     &data->removeLast,
+                                     /*s*/   &doc,
+                                     /*O*/   &(data->notify), // PySideProperty
+                                     /*bbb*/ &(data->designable),
+                                             &(data->scriptable),
+                                             &(data->stored),
+                                     /*bbb*/ &(data->user),
+                                             &(data->constant),
+                                             &(data->final))) {
         return -1;
     }
 
+    if (doc)
+        data->doc = doc;
+    else
+        data->doc.clear();
+
     PyTypeObject *qobjectType = qObjectType();
 
     if (!PySequence_Contains(data->type->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) {
@@ -80,24 +102,31 @@ static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
     return 0;
 }
 
-static PyType_Slot PropertyListType_slots[] = {
-    {Py_tp_new, reinterpret_cast<void *>(propList_tp_new)},
-    {Py_tp_init, reinterpret_cast<void *>(propListTpInit)},
-    {0, nullptr}
-};
-static PyType_Spec PropertyListType_spec = {
-    "2:PySide6.QtQml.ListProperty",
-    sizeof(PySideProperty),
-    0,
-    Py_TPFLAGS_DEFAULT,
-    PropertyListType_slots,
-};
-
+static PyTypeObject *createPropertyListType()
+{
+    PyType_Slot PropertyListType_slots[] = {
+        {Py_tp_new, reinterpret_cast<void *>(propList_tp_new)},
+        {Py_tp_init, reinterpret_cast<void *>(propListTpInit)},
+        {0, nullptr}
+    };
+
+    PyType_Spec PropertyListType_spec = {
+        "2:PySide6.QtQml.ListProperty",
+        sizeof(PySideProperty),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        PropertyListType_slots,
+    };
+
+    Shiboken::AutoDecRef bases(Py_BuildValue("(O)", PySideProperty_TypeF()));
+    return SbkType_FromSpecWithBases(&PropertyListType_spec, bases.object());
+}
 
 PyTypeObject *PropertyList_TypeF(void)
 {
-    static Shiboken::AutoDecRef bases(Py_BuildValue("(O)", PySideProperty_TypeF()));
-    static auto *type = SbkType_FromSpecWithBases(&PropertyListType_spec, bases);
+    // PYSIDE-2230: This was a wrong replacement by static AutoDecref.
+    //              Never do that, deletes things way too late.
+    static PyTypeObject *type = createPropertyListType();
     return type;
 }
 
@@ -140,7 +169,7 @@ qsizetype propListCount(QQmlListProperty<QObject> *propList)
         return 0;
     }
 
-    int cppResult = 0;
+    qsizetype cppResult = 0;
     auto *converter = Shiboken::Conversions::PrimitiveTypeConverter<qsizetype>();
     if (auto *pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(converter, retVal))
         pythonToCpp(retVal, &cppResult);
diff --git a/sources/pyside6/libpysideqml/pysideqmlmetacallerror.cpp b/sources/pyside6/libpysideqml/pysideqmlmetacallerror.cpp
index 8e1381a4e..63cefedb5 100644
--- a/sources/pyside6/libpysideqml/pysideqmlmetacallerror.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlmetacallerror.cpp
@@ -45,7 +45,7 @@ std::optional<int> qmlMetaCallErrorHandler(QObject *object)
     // PYSIDE-464: The error is only valid before PyErr_Restore,
     // PYSIDE-464: therefore we take local copies.
     Shiboken::AutoDecRef objStr(PyObject_Str(errValue));
-    const QString errString = QLatin1String(Shiboken::String::toCString(objStr));
+    const QString errString = QString::fromUtf8(Shiboken::String::toCString(objStr));
     const bool isSyntaxError = errType == PyExc_SyntaxError;
     const bool isTypeError = errType == PyExc_TypeError;
     PyErr_Restore(errType, errValue, errTraceback);
diff --git a/sources/pyside6/libpysideqml/pysideqmlmetacallerror_p.h b/sources/pyside6/libpysideqml/pysideqmlmetacallerror_p.h
index 745ade51e..fcbb6395d 100644
--- a/sources/pyside6/libpysideqml/pysideqmlmetacallerror_p.h
+++ b/sources/pyside6/libpysideqml/pysideqmlmetacallerror_p.h
@@ -6,7 +6,7 @@
 
 #include <optional>
 
-#include <QtCore/QtGlobal>
+#include <QtCore/qtclasshelpermacros.h>
 
 QT_FORWARD_DECLARE_CLASS(QObject)
 
diff --git a/sources/pyside6/libpysideqml/pysideqmlnamedelement.cpp b/sources/pyside6/libpysideqml/pysideqmlnamedelement.cpp
index f29638017..faf3e4116 100644
--- a/sources/pyside6/libpysideqml/pysideqmlnamedelement.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlnamedelement.cpp
@@ -2,15 +2,12 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "pysideqmlnamedelement_p.h"
-#include "pysideqmltypeinfo_p.h"
 #include <pysideclassdecorator_p.h>
 #include <pysideqmlregistertype_p.h>
 
 #include <shiboken.h>
 #include <signature.h>
 
-#include <QtCore/QtGlobal>
-
 class PySideQmlNamedElementPrivate : public PySide::ClassDecorator::StringDecoratorPrivate
 {
 public:
@@ -31,7 +28,7 @@ PyObject *PySideQmlNamedElementPrivate::tp_call(PyObject *self, PyObject *args,
         return nullptr;
 
     auto *data = DecoratorPrivate::get<PySideQmlNamedElementPrivate>(self);
-    auto *result = PySide::Qml::qmlNamedElementMacro(klass, data->string().c_str());
+    auto *result = PySide::Qml::qmlNamedElementMacro(klass, data->string());
     Py_XINCREF(result);
     return result;
 }
diff --git a/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp b/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
index 26398ae76..4ccd459d5 100644
--- a/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmlregistertype.cpp
@@ -6,8 +6,10 @@
 #include "pysideqmltypeinfo_p.h"
 #include "pysideqmlattached_p.h"
 #include "pysideqmlextended_p.h"
+#include "pysideqmluncreatable.h"
 
 #include <limits>
+#include <optional>
 
 // shiboken
 #include <shiboken.h>
@@ -16,6 +18,7 @@
 // pyside
 #include <pyside.h>
 #include <pysideqobject.h>
+#include <pysideclassinfo.h>
 #include <pyside_p.h>
 
 #include <QtCore/QMutex>
@@ -25,9 +28,16 @@
 #include <QtQml/QJSValue>
 #include <QtQml/QQmlListProperty>
 #include <private/qqmlmetatype_p.h>
+#include <private/qmetaobjectbuilder_p.h>
+
+#include <memory>
+
+using namespace Qt::StringLiterals;
 
 static PySide::Qml::QuickRegisterItemFunction quickRegisterItemFunction = nullptr;
 
+static const auto qmlElementKey = "QML.Element"_ba;
+
 static void createInto(void *memory, void *type)
 {
     QMutexLocker locker(&PySide::nextQObjectMemoryAddrMutex());
@@ -85,49 +95,154 @@ static inline bool isQmlParserStatus(const QMetaObject *o)
     return inheritsFrom(o, "QPyQmlParserStatus");
 }
 
-namespace PySide::Qml {
+static QByteArray getGlobalString(const char *name)
+{
+    PyObject *globalVar = PyDict_GetItemString(PyEval_GetGlobals(), name);
 
-int qmlRegisterType(PyObject *pyObj, const char *uri, int versionMajor,
-                    int versionMinor, const char *qmlName, const char *noCreationReason,
-                    bool creatable)
+    if (globalVar == nullptr || PyUnicode_Check(globalVar) == 0)
+        return {};
+
+    const char *stringValue = _PepUnicode_AsString(globalVar);
+    return stringValue != nullptr ? QByteArray(stringValue) : QByteArray{};
+}
+
+static int getGlobalInt(const char *name)
 {
-    using namespace Shiboken;
+    PyObject *globalVar = PyDict_GetItemString(PyEval_GetGlobals(), name);
 
-    PyTypeObject *qobjectType = qObjectType();
+    if (globalVar == nullptr || PyLong_Check(globalVar) == 0)
+        return -1;
 
-    PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj);
-    if (!PySequence_Contains(pyObjType->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) {
-        PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.",
-                     qobjectType->tp_name, pyObjType->tp_name);
+    long value = PyLong_AsLong(globalVar);
+
+    if (value > std::numeric_limits<int>::max() || value < std::numeric_limits<int>::min())
         return -1;
+
+    return value;
+}
+
+struct ImportData
+{
+    QByteArray importName;
+    int majorVersion = 0;
+    int minorVersion = 0;
+
+    QTypeRevision toTypeRevision() const;
+};
+
+QTypeRevision ImportData::toTypeRevision() const
+{
+    return QTypeRevision::fromVersion(majorVersion, minorVersion);
+}
+
+std::optional<ImportData> getGlobalImportData(const char *decoratorName)
+{
+    ImportData result{getGlobalString("QML_IMPORT_NAME"),
+                      getGlobalInt("QML_IMPORT_MAJOR_VERSION"),
+                      getGlobalInt("QML_IMPORT_MINOR_VERSION")};
+
+    if (result.importName.isEmpty()) {
+        PyErr_Format(PyExc_TypeError, "You need specify QML_IMPORT_NAME in order to use %s.",
+                     decoratorName);
+        return {};
     }
 
-    const QMetaObject *metaObject = PySide::retrieveMetaObject(pyObjType);
-    Q_ASSERT(metaObject);
+    if (result.majorVersion == -1) {
+        PyErr_Format(PyExc_TypeError, "You need specify QML_IMPORT_MAJOR_VERSION in order to use %s.",
+                     decoratorName);
+        return {};
+    }
 
-    QQmlPrivate::RegisterType type;
+    // Specifying a minor version is optional
+    if (result.minorVersion == -1)
+        result.minorVersion = 0;
+    return result;
+}
 
-    // Allow registering Qt Quick items.
-    const bool isQuickType = quickRegisterItemFunction && quickRegisterItemFunction(pyObj, &type);
+static PyTypeObject *checkTypeObject(PyObject *pyObj, const char *what)
+{
+    if (PyType_Check(pyObj) == 0) {
+        PyErr_Format(PyExc_TypeError, "%s can only be used for classes.", what);
+        return nullptr;
+    }
+    return reinterpret_cast<PyTypeObject *>(pyObj);
+}
+
+static bool setClassInfo(PyTypeObject *type, const QByteArray &key, const QByteArray &value)
+{
+    if (!PySide::ClassInfo::setClassInfo(type, key, value)) {
+        PyErr_Format(PyExc_TypeError, "Setting class info \"%s\" to \"%s\" on \"%s\" failed.",
+                     key.constData(), value.constData(), type->tp_name);
+        return false;
+    }
+    return true;
+}
+
+static inline bool setSingletonClassInfo(PyTypeObject *type)
+{
+    return setClassInfo(type, "QML.Singleton"_ba, "true"_ba);
+}
+
+static QQmlCustomParser *defaultCustomParserFactory()
+{
+    return nullptr;
+}
+
+namespace PySide::Qml {
+
+// Modern (6.7) type registration using RegisterTypeAndRevisions
+// and information set to QMetaClassInfo.
+static int qmlRegisterType(PyObject *pyObj,
+                           const ImportData &importData,
+                           const QMetaObject *metaObject,
+                           const QMetaObject *classInfoMetaObject = nullptr)
+{
+    PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj);
+
+    if (classInfoMetaObject == nullptr)
+        classInfoMetaObject = metaObject;
 
     // Register as simple QObject rather than Qt Quick item.
     // Incref the type object, don't worry about decref'ing it because
     // there's no way to unregister a QML type.
     Py_INCREF(pyObj);
 
-    type.structVersion = 0;
-
     const QByteArray typeName(pyObjType->tp_name);
     QByteArray ptrType = typeName + '*';
     QByteArray listType = QByteArrayLiteral("QQmlListProperty<") + typeName + '>';
+    const auto typeId = QMetaType(new QQmlMetaTypeInterface(ptrType));
+    const auto listId = QMetaType(new QQmlListMetaTypeInterface(listType, typeId.iface()));
+    const int objectSize = static_cast<int>(PySide::getSizeOfQObject(reinterpret_cast<PyTypeObject *>(pyObj)));
 
-    type.typeId = QMetaType(new QQmlMetaTypeInterface(ptrType));
-    type.listId = QMetaType(new QQmlListMetaTypeInterface(listType,
-                                                          type.typeId.iface()));
     const auto typeInfo = qmlTypeInfo(pyObj);
-    auto info = qmlAttachedInfo(pyObjType, typeInfo);
-    type.attachedPropertiesFunction = info.factory;
-    type.attachedPropertiesMetaObject = info.metaObject;
+    const auto attachedInfo = qmlAttachedInfo(pyObjType, typeInfo);
+    const auto extendedInfo = qmlExtendedInfo(pyObj, typeInfo);
+
+    QList<int> ids;
+    QQmlPrivate::RegisterTypeAndRevisions type {
+        QQmlPrivate::RegisterType::StructVersion::Base, // structVersion
+        typeId, listId, objectSize,
+        createInto, // create
+        pyObj, // userdata
+        nullptr, // createValueType (Remove in Qt 7)
+        importData.importName.constData(),
+        importData.toTypeRevision(), // version
+        metaObject,
+        classInfoMetaObject,
+        attachedInfo.factory, // attachedPropertiesFunction
+        attachedInfo.metaObject, // attachedPropertiesMetaObject
+        0, 0, 0, // parserStatusCast, valueSourceCast, valueInterceptorCast
+        extendedInfo.factory, // extensionObjectCreate
+        extendedInfo.metaObject, // extensionMetaObject
+        defaultCustomParserFactory, // customParser
+        &ids, // qmlTypeIds
+        0, // finalizerCast
+        false, // forceAnonymous
+        {} // listMetaSequence
+    };
+
+    // Allow registering Qt Quick items.
+    const bool isQuickType = quickRegisterItemFunction && quickRegisterItemFunction(pyObj, &type);
 
     if (!isQuickType) { // values filled by the Quick registration
         // QPyQmlParserStatus inherits QObject, QQmlParserStatus, so,
@@ -143,55 +258,245 @@ int qmlRegisterType(PyObject *pyObj, const char *uri, int versionMajor,
                 QQmlPrivate::StaticCastSelector<QObject, QQmlPropertyValueInterceptor>::cast();
     }
 
-    int objectSize = static_cast<int>(PySide::getSizeOfQObject(
-                                      reinterpret_cast<PyTypeObject *>(pyObj)));
-    type.objectSize = objectSize;
-    type.create = creatable ? createInto : nullptr;
-    type.noCreationReason = QString::fromUtf8(noCreationReason);
-    type.userdata = pyObj;
-    type.uri = uri;
-    type.version = QTypeRevision::fromVersion(versionMajor, versionMinor);
-    type.elementName = qmlName;
-
-    info = qmlExtendedInfo(pyObj, typeInfo);
-    type.extensionObjectCreate = info.factory;
-    type.extensionMetaObject = info.metaObject;
-    type.customParser = 0;
-    type.metaObject = metaObject; // Snapshot may have changed.
-
-    int qmlTypeId = QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
+    QQmlPrivate::qmlregister(QQmlPrivate::TypeAndRevisionsRegistration, &type);
+    const int qmlTypeId = ids.value(0, -1);
     if (qmlTypeId == -1) {
         PyErr_Format(PyExc_TypeError, "QML meta type registration of \"%s\" failed.",
-                     qmlName);
+                     typeName.constData());
     }
     return qmlTypeId;
 }
 
-int qmlRegisterSingletonType(PyObject *pyObj, const char *uri, int versionMajor,
-                             int versionMinor, const char *qmlName, PyObject *callback,
-                             bool isQObject, bool hasCallback)
+static int qmlRegisterType(PyObject *pyObj, PyObject *pyClassInfoObj,
+                           const ImportData &importData)
 {
-    using namespace Shiboken;
+    PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj);
+    if (!isQObjectDerived(pyObjType, true))
+        return -1;
 
-    if (hasCallback) {
-        if (!PyCallable_Check(callback)) {
-            PyErr_Format(PyExc_TypeError, "Invalid callback specified.");
-            return -1;
-        }
+    const QMetaObject *metaObject = PySide::retrieveMetaObject(pyObjType);
+    Q_ASSERT(metaObject);
+    const QMetaObject *classInfoMetaObject = pyObj == pyClassInfoObj
+        ? metaObject : PySide::retrieveMetaObject(pyClassInfoObj);
+    return qmlRegisterType(pyObj, importData, metaObject, classInfoMetaObject);
+}
 
-        AutoDecRef funcCode(PyObject_GetAttrString(callback, "__code__"));
-        AutoDecRef argCount(PyObject_GetAttrString(funcCode, "co_argcount"));
+// Legacy (pre 6.7) compatibility helper for the free register functions.
+int qmlRegisterType(PyObject *pyObj, const char *uri, int versionMajor, int versionMinor,
+                    const char *qmlName, const char *noCreationReason,
+                    bool creatable)
+{
+    auto *type = checkTypeObject(pyObj, "qmlRegisterType()");
+    if (type == nullptr || !PySide::isQObjectDerived(type, true))
+        return -1;
 
-        int count = PyLong_AsLong(argCount);
+    const QMetaObject *metaObject = PySide::retrieveMetaObject(type);
+    Q_ASSERT(metaObject);
 
-        if (count != 1) {
-            PyErr_Format(PyExc_TypeError, "Callback has a bad parameter count.");
-            return -1;
+    // PYSIDE-2709: Use a separate QMetaObject for the class information
+    // as modifying metaObject breaks inheritance.
+    QMetaObjectBuilder classInfobuilder(&QObject::staticMetaObject);
+    classInfobuilder.addClassInfo(qmlElementKey, qmlName);
+    if (!creatable)
+        setUncreatableClassInfo(&classInfobuilder, noCreationReason);
+    auto *classInfoMetaObject = classInfobuilder.toMetaObject();
+
+    const int qmlTypeId = qmlRegisterType(pyObj, {uri, versionMajor, versionMinor},
+                                          metaObject, classInfoMetaObject);
+    free(classInfoMetaObject);
+    return qmlTypeId;
+}
+
+// Singleton helpers
+
+// Check the arguments of a singleton callback (C++: "QJSValue cb(QQmlEngine *, QJSEngine *)",
+// but we drop the QJSEngine since it will be the same as QQmlEngine when the latter exists.
+static bool checkSingletonCallback(PyObject *callback)
+{
+    if (callback == nullptr) {
+        PyErr_SetString(PyExc_TypeError, "No callback specified.");
+        return false;
+    }
+    if (PyCallable_Check(callback) == 0) {
+        PyErr_Format(PyExc_TypeError, "Invalid callback specified (%S).", callback);
+        return false;
+    }
+    Shiboken::AutoDecRef funcCode(PyObject_GetAttrString(callback, "__code__"));
+    if (funcCode.isNull()) {
+        PyErr_Format(PyExc_TypeError, "Cannot retrieve code of callback (%S).", callback);
+        return false;
+    }
+    Shiboken::AutoDecRef argCountAttr(PyObject_GetAttrString(funcCode, "co_argcount"));
+    const int argCount = PyLong_AsLong(argCountAttr.object());
+    if (argCount != 1) {
+        PyErr_Format(PyExc_TypeError, "Callback (%S) has %d parameter(s), expected one.",
+                     callback, argCount);
+        return false;
+    }
+
+    return true;
+}
+
+// Shared data of a singleton creation callback which dereferences an object on
+// destruction.
+class SingletonQObjectCreationSharedData
+{
+public:
+    Q_DISABLE_COPY_MOVE(SingletonQObjectCreationSharedData)
+
+    SingletonQObjectCreationSharedData(PyObject *cb, PyObject *ref = nullptr) noexcept :
+        callable(cb), reference(ref)
+    {
+        Py_XINCREF(ref);
+    }
+
+    // FIXME: Currently, the QML registration data are in global static variables
+    // and thus cleaned up after Python terminates. Once they are cleaned up
+    // by the QML engine, the code can be activated for proper cleanup of the references.
+   ~SingletonQObjectCreationSharedData()
+#if 0 //
+    ~SingletonQObjectCreationSharedData()
+    {
+        if (reference != nullptr) {
+            Shiboken::GilState gil;
+            Py_DECREF(reference);
         }
+    }
+#else
+        = default;
+#endif
+
+    PyObject *callable{}; // Callback, static method or type object to  be invoked.
+    PyObject *reference{}; // Object to dereference when going out scope
+};
+
+// Base class for QML singleton creation callbacks with helper for error checking.
+class SingletonQObjectCreationBase
+{
+protected:
+    explicit SingletonQObjectCreationBase(PyObject *cb, PyObject *ref = nullptr) :
+        m_data(std::make_shared<SingletonQObjectCreationSharedData>(cb, ref))
+    {
+    }
+
+    static QObject *handleReturnValue(PyObject *retVal);
 
-        // Make sure the callback never gets deallocated
-        Py_INCREF(callback);
+    std::shared_ptr<SingletonQObjectCreationSharedData> data() const { return m_data; }
+
+private:
+    std::shared_ptr<SingletonQObjectCreationSharedData> m_data;
+};
+
+QObject *SingletonQObjectCreationBase::handleReturnValue(PyObject *retVal)
+{
+    using Shiboken::Conversions::isPythonToCppPointerConvertible;
+    // Make sure the callback returns something we can convert, else the entire application will crash.
+    if (retVal == nullptr) {
+        PyErr_Format(PyExc_TypeError, "Callback returns 0 value.");
+        return nullptr;
     }
+    if (isPythonToCppPointerConvertible(qObjectType(), retVal) == nullptr) {
+        PyErr_Format(PyExc_TypeError, "Callback returns invalid value (%S).", retVal);
+        return nullptr;
+    }
+
+    QObject *obj = nullptr;
+    Shiboken::Conversions::pythonToCppPointer(qObjectType(), retVal, &obj);
+    return obj;
+}
+
+// QML singleton creation callback by invoking a type object
+class SingletonQObjectFromTypeCreation : public SingletonQObjectCreationBase
+{
+public:
+    explicit SingletonQObjectFromTypeCreation(PyObject *typeObj) :
+        SingletonQObjectCreationBase(typeObj, typeObj) {}
+
+    QObject *operator ()(QQmlEngine *, QJSEngine *) const
+    {
+        Shiboken::GilState gil;
+        Shiboken::AutoDecRef args(PyTuple_New(0));
+        PyObject *retVal = PyObject_CallObject(data()->callable, args);
+        QObject *result = handleReturnValue(retVal);
+        if (result == nullptr)
+            Py_XDECREF(retVal);
+        return result;
+    }
+};
+
+// QML singleton creation by invoking a callback, passing QQmlEngine. Keeps a
+// references to the the callback.
+class SingletonQObjectCallbackCreation : public SingletonQObjectCreationBase
+{
+public:
+    explicit SingletonQObjectCallbackCreation(PyObject *callback) :
+        SingletonQObjectCreationBase(callback, callback) {}
+    explicit SingletonQObjectCallbackCreation(PyObject *callback, PyObject *ref) :
+        SingletonQObjectCreationBase(callback, ref) {}
+
+    QObject *operator ()(QQmlEngine *engine, QJSEngine *) const
+    {
+        Shiboken::GilState gil;
+        Shiboken::AutoDecRef args(PyTuple_New(1));
+        PyTuple_SET_ITEM(args, 0,
+                         Shiboken::Conversions::pointerToPython(qQmlEngineType(), engine));
+        PyObject *retVal = PyObject_CallObject(data()->callable, args);
+        QObject *result = handleReturnValue(retVal);
+        if (result == nullptr)
+            Py_XDECREF(retVal);
+        return result;
+    }
+};
+
+using SingletonQObjectCreation = std::function<QObject*(QQmlEngine *, QJSEngine *)>;
+
+// Modern (6.7) singleton type registration using RegisterSingletonTypeAndRevisions
+// and information set to QMetaClassInfo (QObject only pending QTBUG-110467).
+static int qmlRegisterSingletonTypeV2(PyObject *pyObj, PyObject *pyClassInfoObj,
+                                      const ImportData &importData,
+                                      const SingletonQObjectCreation &callback)
+{
+    PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj);
+    if (!isQObjectDerived(pyObjType, true))
+        return -1;
+
+    const QMetaObject *metaObject = PySide::retrieveMetaObject(pyObjType);
+    Q_ASSERT(metaObject);
+    const QMetaObject *classInfoMetaObject = pyObj == pyClassInfoObj
+        ? metaObject : PySide::retrieveMetaObject(pyClassInfoObj);
+
+    QList<int> ids;
+    QQmlPrivate::RegisterSingletonTypeAndRevisions type {
+        QQmlPrivate::RegisterType::StructVersion::Base, // structVersion
+        importData.importName.constData(),
+        importData.toTypeRevision(), // version
+        callback, // qObjectApi,
+        metaObject,
+        classInfoMetaObject,
+        QMetaType(QMetaType::QObjectStar), // typeId
+        nullptr, // extensionMetaObject
+        nullptr, // extensionObjectCreate
+        &ids
+    };
+
+    QQmlPrivate::qmlregister(QQmlPrivate::SingletonAndRevisionsRegistration, &type);
+    const int qmlTypeId = ids.value(0, -1);
+    if (qmlTypeId == -1) {
+        PyErr_Format(PyExc_TypeError, "Singleton QML meta type registration of \"%s\" failed.",
+                     pyObjType->tp_name);
+    }
+    return qmlTypeId;
+}
+
+// Legacy (pre 6.7) singleton type registration using RegisterSingletonType
+// for QObject and value types. Still used by qmlRegisterSingletonType()
+// for the hypothetical case of a value type.
+static int qmlRegisterSingletonType(PyObject *pyObj, const ImportData &importData,
+                                    const char *qmlName, PyObject *callback,
+                                    bool isQObject, bool hasCallback)
+{
+    if (hasCallback && !checkSingletonCallback(callback))
+        return -1;
 
     const QMetaObject *metaObject = nullptr;
 
@@ -201,56 +506,37 @@ int qmlRegisterSingletonType(PyObject *pyObj, const char *uri, int versionMajor,
         if (!isQObjectDerived(pyObjType, true))
             return -1;
 
-        // If we don't have a callback we'll need the pyObj to stay allocated indefinitely
-        if (!hasCallback)
-            Py_INCREF(pyObj);
-
         metaObject = PySide::retrieveMetaObject(pyObjType);
         Q_ASSERT(metaObject);
     }
 
-    QQmlPrivate::RegisterSingletonType type;
-    type.structVersion = 0;
-
-    type.uri = uri;
-    type.version = QTypeRevision::fromVersion(versionMajor, versionMinor);
-    type.typeName = qmlName;
-    type.instanceMetaObject = metaObject;
+    QQmlPrivate::RegisterSingletonType type {
+        QQmlPrivate::RegisterType::StructVersion::Base, // structVersion
+        importData.importName.constData(),
+        importData.toTypeRevision(), // version
+        qmlName, // typeName
+        {}, // scriptApi
+        {}, // qObjectApi
+        metaObject, // instanceMetaObject
+        {}, // typeId
+        nullptr, // extensionMetaObject
+        nullptr, // extensionObjectCreate
+        {} // revision
+    };
 
     if (isQObject) {
         // FIXME: Fix this to assign new type ids each time.
         type.typeId = QMetaType(QMetaType::QObjectStar);
 
-        type.qObjectApi =
-            [callback, pyObj, hasCallback](QQmlEngine *engine, QJSEngine *) -> QObject * {
-                Shiboken::GilState gil;
-                AutoDecRef args(PyTuple_New(hasCallback ? 1 : 0));
-
-                if (hasCallback) {
-                    PyTuple_SET_ITEM(args, 0, Conversions::pointerToPython(
-                                     qQmlEngineType(), engine));
-                }
-
-                AutoDecRef retVal(PyObject_CallObject(hasCallback ? callback : pyObj, args));
-
-                // Make sure the callback returns something we can convert, else the entire application will crash.
-                if (retVal.isNull() ||
-                    Conversions::isPythonToCppPointerConvertible(qObjectType(), retVal) == nullptr) {
-                    PyErr_Format(PyExc_TypeError, "Callback returns invalid value.");
-                    return nullptr;
-                }
-
-                QObject *obj = nullptr;
-                Conversions::pythonToCppPointer(qObjectType(), retVal, &obj);
-
-                if (obj != nullptr)
-                    Py_INCREF(retVal);
-
-                return obj;
-            };
+        if (hasCallback)
+            type.qObjectApi = SingletonQObjectCallbackCreation(callback);
+        else
+            type.qObjectApi = SingletonQObjectFromTypeCreation(pyObj);
     } else {
         type.scriptApi =
             [callback](QQmlEngine *engine, QJSEngine *) -> QJSValue {
+                using namespace Shiboken;
+
                 Shiboken::GilState gil;
                 AutoDecRef args(PyTuple_New(1));
 
@@ -280,9 +566,19 @@ int qmlRegisterSingletonType(PyObject *pyObj, const char *uri, int versionMajor,
     return QQmlPrivate::qmlregister(QQmlPrivate::SingletonRegistration, &type);
 }
 
-int qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int versionMajor,
-                                 int versionMinor, const char *qmlName,
-                                 PyObject *instanceObject)
+// Legacy (pre 6.7) compatibility helper for the free register functions.
+int qmlRegisterSingletonType(PyObject *pyObj,const char *uri,
+                             int versionMajor, int versionMinor, const char *qmlName,
+                             PyObject *callback, bool isQObject, bool hasCallback)
+{
+    return qmlRegisterSingletonType(pyObj, {uri, versionMajor, versionMinor}, qmlName,
+                                    callback, isQObject, hasCallback);
+}
+
+// Modern (6.7) singleton instance registration using RegisterSingletonTypeAndRevisions
+// and information set to QMetaClassInfo (QObject only).
+static int qmlRegisterSingletonInstance(PyObject *pyObj, const ImportData &importData,
+                                        PyObject *instanceObject)
 {
     using namespace Shiboken;
 
@@ -305,165 +601,140 @@ int qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int versionMa
     const QMetaObject *metaObject = PySide::retrieveMetaObject(pyObjType);
     Q_ASSERT(metaObject);
 
-    QQmlPrivate::RegisterSingletonType type;
-    type.structVersion = 0;
-
-    type.uri = uri;
-    type.version = QTypeRevision::fromVersion(versionMajor, versionMinor);
-    type.typeName = qmlName;
-    type.instanceMetaObject = metaObject;
-
-    // FIXME: Fix this to assign new type ids each time.
-    type.typeId = QMetaType(QMetaType::QObjectStar);
-    type.qObjectApi = registrationFunctor;
-
-
-    return QQmlPrivate::qmlregister(QQmlPrivate::SingletonRegistration, &type);
+    QList<int> ids;
+    QQmlPrivate::RegisterSingletonTypeAndRevisions type {
+        QQmlPrivate::RegisterType::StructVersion::Base, // structVersion
+        importData.importName.constData(),
+        importData.toTypeRevision(), // version
+        registrationFunctor, // qObjectApi,
+        metaObject,
+        metaObject, // classInfoMetaObject
+        QMetaType(QMetaType::QObjectStar), // typeId
+        nullptr, // extensionMetaObject
+        nullptr, // extensionObjectCreate
+        &ids
+    };
+
+    QQmlPrivate::qmlregister(QQmlPrivate::SingletonAndRevisionsRegistration, &type);
+    return ids.value(0, -1);
 }
 
-} // namespace PySide::Qml
-
-static std::string getGlobalString(const char *name)
-{
-    using Shiboken::AutoDecRef;
-
-    PyObject *globals = PyEval_GetGlobals();
-
-    AutoDecRef pyName(Py_BuildValue("s", name));
-
-    PyObject *globalVar = PyDict_GetItem(globals, pyName);
-
-    if (globalVar == nullptr || !PyUnicode_Check(globalVar))
-        return "";
-
-    const char *stringValue = _PepUnicode_AsString(globalVar);
-    return stringValue != nullptr ? stringValue : "";
-}
-
-static int getGlobalInt(const char *name)
+// Legacy (pre 6.7) compatibility helper for the free register functions.
+int qmlRegisterSingletonInstance(PyObject *pyObj, const char *uri, int versionMajor,
+                                 int versionMinor, const char *qmlName,
+                                 PyObject *instanceObject)
 {
-    using Shiboken::AutoDecRef;
-
-    PyObject *globals = PyEval_GetGlobals();
-
-    AutoDecRef pyName(Py_BuildValue("s", name));
-
-    PyObject *globalVar = PyDict_GetItem(globals, pyName);
-
-    if (globalVar == nullptr || !PyLong_Check(globalVar))
-        return -1;
-
-    long value = PyLong_AsLong(globalVar);
-
-    if (value > std::numeric_limits<int>::max() || value < std::numeric_limits<int>::min())
+    auto *type = checkTypeObject(pyObj, "qmlRegisterSingletonInstance()");
+    if (type == nullptr || !setClassInfo(type, qmlElementKey, qmlName)
+        || !setSingletonClassInfo(type)) {
         return -1;
-
-    return value;
+    }
+    return qmlRegisterSingletonInstance(pyObj, {uri, versionMajor, versionMinor},
+                                        instanceObject);
 }
 
+} // namespace PySide::Qml
+
 enum class RegisterMode {
     Normal,
-    Anonymous,
-    Uncreatable,
     Singleton
 };
 
-static PyObject *qmlElementMacroHelper(PyObject *pyObj,
-                                       const char *decoratorName,
-                                       const char *typeName = nullptr,
-                                       RegisterMode mode = RegisterMode::Normal,
-                                       const char *noCreationReason = nullptr)
+namespace PySide::Qml {
+
+// Check for a static create() method on a decorated singleton.
+// Might set a Python error if the check fails.
+static std::optional<SingletonQObjectCreation>
+    singletonCreateMethod(PyTypeObject *pyObjType)
 {
-    if (!PyType_Check(pyObj)) {
-        PyErr_Format(PyExc_TypeError, "This decorator can only be used on classes.");
-        return nullptr;
+    Shiboken::AutoDecRef tpDict(PepType_GetDict(pyObjType));
+    auto *create = PyDict_GetItemString(tpDict.object(), "create");
+    // Method decorated by "@staticmethod"
+    if (create == nullptr || std::strcmp(Py_TYPE(create)->tp_name, "staticmethod") != 0)
+        return std::nullopt;
+    // 3.10: "__wrapped__"
+    Shiboken::AutoDecRef function(PyObject_GetAttrString(create, "__func__"));
+    if (function.isNull()) {
+        PyErr_Format(PyExc_TypeError, "Cannot retrieve function of callback (%S).",
+                     create);
+        return std::nullopt;
     }
+    if (!checkSingletonCallback(function.object()))
+        return std::nullopt;
+    // Reference to the type needs to be kept.
+    return SingletonQObjectCallbackCreation(function.object(),
+                                            reinterpret_cast<PyObject *>(pyObjType));
+}
 
-    PyTypeObject *pyObjType = reinterpret_cast<PyTypeObject *>(pyObj);
-    if (typeName == nullptr)
-        typeName = pyObjType->tp_name;
-    if (!PySequence_Contains(pyObjType->tp_mro, reinterpret_cast<PyObject *>(qObjectType()))) {
-        PyErr_Format(PyExc_TypeError, "This decorator can only be used with classes inherited from QObject, got %s.",
-                     typeName);
+PyObject *qmlElementMacro(PyObject *pyObj, const char *decoratorName,
+                          const QByteArray &typeName)
+{
+    auto *pyObjType = checkTypeObject(pyObj, decoratorName);
+    if (pyObjType == nullptr)
         return nullptr;
-    }
 
-    std::string importName = getGlobalString("QML_IMPORT_NAME");
-    int majorVersion = getGlobalInt("QML_IMPORT_MAJOR_VERSION");
-    int minorVersion = getGlobalInt("QML_IMPORT_MINOR_VERSION");
-
-    if (importName.empty()) {
-        PyErr_Format(PyExc_TypeError, "You need specify QML_IMPORT_NAME in order to use %s.",
-                     decoratorName);
+    if (!PySide::isQObjectDerived(pyObjType, false)) {
+        PyErr_Format(PyExc_TypeError,
+                     "%s can only be used with classes inherited from QObject, got %s.",
+                     decoratorName, pyObjType->tp_name);
         return nullptr;
     }
 
-    if (majorVersion == -1) {
-       PyErr_Format(PyExc_TypeError, "You need specify QML_IMPORT_MAJOR_VERSION in order to use %s.",
-                    decoratorName);
-       return nullptr;
-    }
-
-    // Specifying a minor version is optional
-    if (minorVersion == -1)
-        minorVersion = 0;
-
-    const char *uri = importName.c_str();
-    const int result = mode == RegisterMode::Singleton
-        ? PySide::Qml::qmlRegisterSingletonType(pyObj, uri, majorVersion, minorVersion,
-                                                typeName, nullptr,
-                                                PySide::isQObjectDerived(pyObjType, false),
-                                                false)
-        : PySide::Qml::qmlRegisterType(pyObj, uri, majorVersion, minorVersion,
-                                       mode != RegisterMode::Anonymous ? typeName : nullptr,
-                                       noCreationReason,
-                                       mode == RegisterMode::Normal);
-
-    if (result == -1) {
-        PyErr_Format(PyExc_TypeError, "%s: Failed to register type %s.",
-                     decoratorName, typeName);
-    }
-
-    return pyObj;
-}
-
-namespace PySide::Qml {
+    if (!setClassInfo(pyObjType, qmlElementKey, typeName))
+        return nullptr;
 
-PyObject *qmlElementMacro(PyObject *pyObj, const char *decoratorName,
-                          const char *typeName = nullptr)
-{
     RegisterMode mode = RegisterMode::Normal;
-    const char *noCreationReason = nullptr;
     const auto info = PySide::Qml::qmlTypeInfo(pyObj);
     auto *registerObject = pyObj;
-    if (!info.isNull()) {
-        if (info->flags.testFlag(PySide::Qml::QmlTypeFlag::Singleton))
+    if (info) {
+        if (info->flags.testFlag(PySide::Qml::QmlTypeFlag::Singleton)) {
             mode = RegisterMode::Singleton;
-        else if (info->flags.testFlag(PySide::Qml::QmlTypeFlag::Uncreatable))
-            mode = RegisterMode::Uncreatable;
-        noCreationReason = info->noCreationReason.c_str();
+            setSingletonClassInfo(pyObjType);
+        }
         if (info->foreignType)
             registerObject = reinterpret_cast<PyObject *>(info->foreignType);
     }
-    if (!qmlElementMacroHelper(registerObject, decoratorName, typeName, mode, noCreationReason))
+
+    const auto importDataO = getGlobalImportData(decoratorName);
+    if (!importDataO.has_value())
+        return nullptr;
+    const auto importData = importDataO.value();
+
+    int result{};
+    if (mode == RegisterMode::Singleton) {
+        auto singletonCreateMethodO = singletonCreateMethod(pyObjType);
+        if (!singletonCreateMethodO.has_value()) {
+            if (PyErr_Occurred() != nullptr)
+                return nullptr;
+            singletonCreateMethodO = SingletonQObjectFromTypeCreation(pyObj);
+        }
+        result = PySide::Qml::qmlRegisterSingletonTypeV2(registerObject, pyObj, importData,
+                                                         singletonCreateMethodO.value());
+    } else {
+        result = PySide::Qml::qmlRegisterType(registerObject, pyObj, importData);
+    }
+    if (result == -1) {
+        PyErr_Format(PyExc_TypeError, "%s: Failed to register type %s.",
+                     decoratorName, pyObjType->tp_name);
         return nullptr;
+    }
+
     return pyObj;
 }
 
 PyObject *qmlElementMacro(PyObject *pyObj)
 {
-    return qmlElementMacro(pyObj, "QmlElement");
+    return qmlElementMacro(pyObj, "QmlElement", "auto"_ba);
 }
 
-PyObject *qmlNamedElementMacro(PyObject *pyObj, const char *typeName)
+PyObject *qmlNamedElementMacro(PyObject *pyObj, const QByteArray &typeName)
 {
-    return qmlElementMacro(pyObj, "QmlNamedElement", qstrdup(typeName));
+    return qmlElementMacro(pyObj, "QmlNamedElement", typeName);
 }
 
 PyObject *qmlAnonymousMacro(PyObject *pyObj)
 {
-    return qmlElementMacroHelper(pyObj, "QmlAnonymous", nullptr,
-                                 RegisterMode::Anonymous);
+    return qmlElementMacro(pyObj, "QmlAnonymous",  "anonymous"_ba);
 }
 
 PyObject *qmlSingletonMacro(PyObject *pyObj)
diff --git a/sources/pyside6/libpysideqml/pysideqmlregistertype.h b/sources/pyside6/libpysideqml/pysideqmlregistertype.h
index 1e6c7d28d..859172322 100644
--- a/sources/pyside6/libpysideqml/pysideqmlregistertype.h
+++ b/sources/pyside6/libpysideqml/pysideqmlregistertype.h
@@ -7,11 +7,14 @@
 #include "pysideqmlmacros.h"
 
 #include <sbkpython.h>
+#include <QtCore/qtconfigmacros.h>
 
+QT_BEGIN_NAMESPACE
 namespace QQmlPrivate
 {
-struct RegisterType;
+struct RegisterTypeAndRevisions;
 }
+QT_END_NAMESPACE
 
 namespace PySide::Qml
 {
@@ -19,6 +22,9 @@ namespace PySide::Qml
 /**
  * PySide implementation of qmlRegisterType<T> function.
  *
+ * This is a helper for the legacy free qmlRegisterType*() type functions.
+ * Decorators should be used instead.
+ *
  * \param pyObj Python type to be registered.
  * \param uri QML element uri.
  * \param versionMajor QML component major version.
@@ -34,6 +40,9 @@ PYSIDEQML_API int qmlRegisterType(PyObject *pyObj, const char *uri,
 /**
  * PySide implementation of qmlRegisterSingletonType<T> function.
  *
+ * This is a helper for the legacy free qmlRegisterSingletonType<T> type function.
+ * Decorators should be used instead.
+ *
  * \param pyObj Python type to be registered.
  * \param uri QML element uri.
  * \param versionMajor QML component major version.
@@ -80,7 +89,7 @@ PYSIDEQML_API PyObject *qmlSingletonMacro(PyObject *pyObj);
 // Used by QtQuick module to fill the QQmlPrivate::RegisterType::parserStatusCast,
 // valueSourceCast and valueInterceptorCast fields with the correct values.
 using QuickRegisterItemFunction =
-    bool (*)(PyObject *pyObj, QQmlPrivate::RegisterType *);
+    bool (*)(PyObject *pyObj, QT_PREPEND_NAMESPACE(QQmlPrivate::RegisterTypeAndRevisions) *);
 
 PYSIDEQML_API QuickRegisterItemFunction getQuickRegisterItemFunction();
 PYSIDEQML_API void setQuickRegisterItemFunction(QuickRegisterItemFunction function);
diff --git a/sources/pyside6/libpysideqml/pysideqmlregistertype_p.h b/sources/pyside6/libpysideqml/pysideqmlregistertype_p.h
index 3f077ee2a..f11f92241 100644
--- a/sources/pyside6/libpysideqml/pysideqmlregistertype_p.h
+++ b/sources/pyside6/libpysideqml/pysideqmlregistertype_p.h
@@ -6,12 +6,14 @@
 
 #include <sbkpython.h>
 
+#include <QtCore/QByteArray>
+
 PyTypeObject *qObjectType();
 
 
 namespace PySide::Qml {
 
-PyObject *qmlNamedElementMacro(PyObject *pyObj, const char *typeName);
+PyObject *qmlNamedElementMacro(PyObject *pyObj, const QByteArray &typeName);
 
 }
 
diff --git a/sources/pyside6/libpysideqml/pysideqmltypeinfo.cpp b/sources/pyside6/libpysideqml/pysideqmltypeinfo.cpp
index 31abedd8a..f369f7400 100644
--- a/sources/pyside6/libpysideqml/pysideqmltypeinfo.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmltypeinfo.cpp
@@ -19,7 +19,7 @@ QmlTypeInfoPtr ensureQmlTypeInfo(const PyObject *o)
     auto *hash = qmlTypeInfoHashStatic();
     auto it = hash->find(o);
     if (it == hash->end())
-        it = hash->insert(o, QmlTypeInfoPtr(new QmlTypeInfo));
+        it = hash->insert(o, std::make_shared<QmlTypeInfo>());
     return it.value();
 }
 
@@ -42,8 +42,6 @@ QDebug operator<<(QDebug d, const QmlTypeInfo &i)
     d.noquote();
     d.nospace();
     d << "QmlTypeInfo(" << i.flags;
-    if (!i.noCreationReason.empty())
-        d << ", noCreationReason=\"" << i.noCreationReason.c_str() << '"';
     if (i.foreignType)
         d << ", foreignType=" << i.foreignType->tp_name;
     if (i.attachedType)
diff --git a/sources/pyside6/libpysideqml/pysideqmltypeinfo_p.h b/sources/pyside6/libpysideqml/pysideqmltypeinfo_p.h
index 465299833..112e127a7 100644
--- a/sources/pyside6/libpysideqml/pysideqmltypeinfo_p.h
+++ b/sources/pyside6/libpysideqml/pysideqmltypeinfo_p.h
@@ -6,10 +6,10 @@
 
 #include <sbkpython.h>
 
+#include <QtCore/QByteArray>
 #include <QtCore/QFlags>
-#include <QtCore/QSharedPointer>
 
-#include <string>
+#include <memory>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 QT_FORWARD_DECLARE_CLASS(QObject)
@@ -19,8 +19,7 @@ namespace PySide::Qml {
 
 enum class QmlTypeFlag
 {
-    Singleton = 0x1,
-    Uncreatable = 0x2
+    Singleton = 0x1
 };
 
 Q_DECLARE_FLAGS(QmlTypeFlags, QmlTypeFlag)
@@ -30,13 +29,12 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(QmlTypeFlags)
 struct QmlTypeInfo
 {
     QmlTypeFlags flags;
-    std::string noCreationReason;
     PyTypeObject *foreignType = nullptr;
     PyTypeObject *attachedType = nullptr;
     PyTypeObject *extensionType = nullptr;
 };
 
-using QmlTypeInfoPtr = QSharedPointer<QmlTypeInfo>;
+using QmlTypeInfoPtr = std::shared_ptr<QmlTypeInfo>;
 
 QmlTypeInfoPtr ensureQmlTypeInfo(const PyObject *o);
 void insertQmlTypeInfoAlias(const PyObject *o, const QmlTypeInfoPtr &value);
diff --git a/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp b/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
index 43c795cb0..7c0f6b8ff 100644
--- a/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmluncreatable.cpp
@@ -2,17 +2,17 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #include "pysideqmluncreatable.h"
-#include "pysideqmltypeinfo_p.h"
 #include <pysideclassdecorator_p.h>
+#include <pysideclassinfo.h>
 
 #include <shiboken.h>
 #include <signature.h>
 #include <sbkcppstring.h>
 
-#include <string>
-#include <unordered_map>
+#include <QtCore/qbytearray.h>
+#include <private/qmetaobjectbuilder_p.h>
 
-#include <QtCore/QtGlobal>
+using namespace Qt::StringLiterals;
 
 class PySideQmlUncreatablePrivate : public PySide::ClassDecorator::StringDecoratorPrivate
 {
@@ -35,11 +35,9 @@ PyObject *PySideQmlUncreatablePrivate::tp_call(PyObject *self, PyObject *args, P
     if (klass== nullptr)
         return nullptr;
 
+    auto *type = reinterpret_cast<PyTypeObject *>(klass);
     auto *data = DecoratorPrivate::get<PySideQmlUncreatablePrivate>(self);
-
-    const auto info = PySide::Qml::ensureQmlTypeInfo(klass);
-    info->flags.setFlag(PySide::Qml::QmlTypeFlag::Uncreatable);
-    info->noCreationReason = data->string();
+    setUncreatableClassInfo(type, data->string());
 
     Py_INCREF(klass);
     return klass;
@@ -105,3 +103,16 @@ void initQmlUncreatable(PyObject *module)
     PyModule_AddObject(module, "QmlUncreatable",
                        reinterpret_cast<PyObject *>(PySideQmlUncreatable_TypeF()));
 }
+
+void setUncreatableClassInfo(PyTypeObject *type, const QByteArray &reason)
+{
+    PySide::ClassInfo::setClassInfo(type, {
+        {"QML.Creatable"_ba, "false"_ba},
+        {"QML.UncreatableReason"_ba, reason} });
+}
+
+void setUncreatableClassInfo(QMetaObjectBuilder *builder, const QByteArray &reason)
+{
+    builder->addClassInfo("QML.Creatable", "false");
+    builder->addClassInfo("QML.UncreatableReason", reason);
+}
diff --git a/sources/pyside6/libpysideqml/pysideqmluncreatable.h b/sources/pyside6/libpysideqml/pysideqmluncreatable.h
index 7961634ca..8a8adb3c8 100644
--- a/sources/pyside6/libpysideqml/pysideqmluncreatable.h
+++ b/sources/pyside6/libpysideqml/pysideqmluncreatable.h
@@ -6,6 +6,10 @@
 
 #include <sbkpython.h>
 
+#include <QtCore/QByteArray>
+
+QT_FORWARD_DECLARE_CLASS(QMetaObjectBuilder)
+
 // The QmlUncreatable decorator modifies QmlElement to register an uncreatable
 // type. Due to the (reverse) execution order of decorators, it needs to follow
 // QmlElement.
@@ -16,4 +20,7 @@ extern "C"
 
 void initQmlUncreatable(PyObject *module);
 
+void setUncreatableClassInfo(PyTypeObject *type, const QByteArray &reason);
+void setUncreatableClassInfo(QMetaObjectBuilder *builder, const QByteArray &reason);
+
 #endif // PYSIDEQMLUNCREATABLE_H
diff --git a/sources/pyside6/plugins/designer/CMakeLists.txt b/sources/pyside6/plugins/designer/CMakeLists.txt
index f1b7f83b3..717652314 100644
--- a/sources/pyside6/plugins/designer/CMakeLists.txt
+++ b/sources/pyside6/plugins/designer/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(PySidePlugin)
 
 # Note: At runtime, the dependency to the shiboken library is resolved
@@ -12,10 +15,13 @@ find_package(Qt6 COMPONENTS Core Gui Widgets UiPlugin)
 qt_add_plugin(PySidePlugin)
 
 target_sources(PySidePlugin PRIVATE
-    designercustomwidgets.cpp
+    designercustomwidgets.cpp designercustomwidgets.h
 )
 
 # See libshiboken/CMakeLists.txt
+
+target_compile_definitions(PySidePlugin PRIVATE -DQT_NO_KEYWORDS=1)
+
 if(PYTHON_LIMITED_API)
     target_compile_definitions(PySidePlugin PRIVATE "-DPy_LIMITED_API=0x03050000")
 endif()
@@ -50,4 +56,4 @@ target_link_libraries(PySidePlugin PRIVATE
                       Qt::Widgets
                       ${SHIBOKEN_PYTHON_LIBRARIES})
 
-install(TARGETS PySidePlugin LIBRARY DESTINATION "plugins/designer")
+install(TARGETS PySidePlugin LIBRARY DESTINATION "${QT6_INSTALL_PLUGINS}/designer")
diff --git a/sources/pyside6/plugins/designer/designercustomwidgets.cpp b/sources/pyside6/plugins/designer/designercustomwidgets.cpp
index c62f8b6fc..d23156a9d 100644
--- a/sources/pyside6/plugins/designer/designercustomwidgets.cpp
+++ b/sources/pyside6/plugins/designer/designercustomwidgets.cpp
@@ -1,6 +1,7 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
+#undef slots
 #include <Python.h> // Include before Qt headers due to 'slots' macro definition
 
 #include "designercustomwidgets.h"
@@ -17,6 +18,8 @@
 
 #include <string_view>
 
+using namespace Qt::StringLiterals;
+
 Q_LOGGING_CATEGORY(lcPySidePlugin, "qt.pysideplugin")
 
 static const char pathVar[] = "PYSIDE_DESIGNER_PLUGINS";
@@ -27,7 +30,7 @@ static const char pythonPathVar[] = "PYTHONPATH";
 static QDesignerCustomWidgetCollectionInterface *findPyDesignerCustomWidgetCollection()
 {
     static const char propertyName[] =  "__qt_PySideCustomWidgetCollection";
-    if (auto coreApp = QCoreApplication::instance()) {
+    if (auto *coreApp = QCoreApplication::instance()) {
         const QVariant value = coreApp->property(propertyName);
         if (value.isValid() && value.canConvert<void *>())
             return reinterpret_cast<QDesignerCustomWidgetCollectionInterface *>(value.value<void *>());
@@ -47,17 +50,17 @@ static QString pyStringToQString(PyObject *s)
 static QString pyStr(PyObject *o)
 {
     PyObject *pstr = PyObject_Str(o);
-    return pstr ? pyStringToQString(pstr) : QString();
+    return pstr != nullptr ? pyStringToQString(pstr) : QString();
 }
 
 static QString pyErrorMessage()
 {
-    QString result = QLatin1String("<error information not available>");
+    QString result = "<error information not available>"_L1;
     PyObject *ptype = {};
     PyObject *pvalue = {};
     PyObject *ptraceback = {};
     PyErr_Fetch(&ptype, &pvalue, &ptraceback);
-    if (pvalue)
+    if (pvalue != nullptr)
         result = pyStr(pvalue);
     PyErr_Restore(ptype, pvalue, ptraceback);
     return result;
@@ -84,7 +87,7 @@ static bool runPyScript(const char *script, QString *errorMessage)
 {
     PyObject *main = PyImport_AddModule("__main__");
     if (main == nullptr) {
-        *errorMessage = QLatin1String("Internal error: Cannot retrieve __main__");
+        *errorMessage = "Internal error: Cannot retrieve __main__"_L1;
         return false;
     }
     PyObject *globalDictionary = PyModule_GetDict(main);
@@ -115,8 +118,7 @@ static bool runPyScriptFile(const QString &fileName, QString *errorMessage)
     file.close();
     const bool ok = runPyScript(script.constData(), errorMessage);
     if (!ok && !errorMessage->isEmpty()) {
-        errorMessage->prepend(QLatin1String("Error running ") + fileName
-                              + QLatin1String(": "));
+        errorMessage->prepend("Error running "_L1 + fileName + ": "_L1);
     }
     return ok;
 }
@@ -154,10 +156,10 @@ static void initVirtualEnvironment()
         pythonPath.append(virtualEnvPath + R"(\Lib\site-packages)");
         break;
     case QOperatingSystemVersion::MacOS:
-        pythonPath.append(virtualEnvPath + QByteArrayLiteral("/lib/python") +
+        pythonPath.append(virtualEnvPath + "/lib/python"_ba +
                           QByteArray::number(majorVersion) + '.'
                           + QByteArray::number(minorVersion)
-                          + QByteArrayLiteral("/site-packages"));
+                          + "/site-packages"_ba);
         break;
     default:
         break;
@@ -175,13 +177,20 @@ static void initPython()
     qAddPostRoutine(Py_Finalize);
 }
 
+static bool withinQtDesigner = false;
+
 PyDesignerCustomWidgets::PyDesignerCustomWidgets(QObject *parent) : QObject(parent)
 {
     qCDebug(lcPySidePlugin, "%s", __FUNCTION__);
 
+    withinQtDesigner = QCoreApplication::applicationName() == u"Designer"
+                       && QCoreApplication::organizationName() == u"QtProject";
+
     if (!qEnvironmentVariableIsSet(pathVar)) {
-        qCWarning(lcPySidePlugin, "Environment variable %s is not set, bailing out.",
-                  pathVar);
+        if (withinQtDesigner) {
+            qCWarning(lcPySidePlugin, "Environment variable %s is not set, bailing out.",
+                      pathVar);
+        }
         return;
     }
 
@@ -197,7 +206,7 @@ PyDesignerCustomWidgets::PyDesignerCustomWidgets(QObject *parent) : QObject(pare
         QDir dir(p);
         if (dir.exists()) {
             const QFileInfoList matches =
-                dir.entryInfoList({QStringLiteral("register*.py")}, QDir::Files,
+                dir.entryInfoList({u"register*.py"_s}, QDir::Files,
                                   QDir::Name);
             for (const auto &fi : matches)
                 pythonFiles.append(fi.absoluteFilePath());
@@ -224,7 +233,9 @@ PyDesignerCustomWidgets::PyDesignerCustomWidgets(QObject *parent) : QObject(pare
         qputenv(pythonPathVar, value);
     }
 
-    initPython();
+    // Might be initialized already, for example, when loaded from QUiLoader.
+    if (Py_IsInitialized() == 0)
+        initPython();
 
     // Run all register*py files
     QString errorMessage;
@@ -242,8 +253,9 @@ PyDesignerCustomWidgets::~PyDesignerCustomWidgets()
 
 QList<QDesignerCustomWidgetInterface *> PyDesignerCustomWidgets::customWidgets() const
 {
-    if (auto collection = findPyDesignerCustomWidgetCollection())
+    if (auto *collection = findPyDesignerCustomWidgetCollection())
         return collection->customWidgets();
-    qCWarning(lcPySidePlugin, "No instance of QPyDesignerCustomWidgetCollection was found.");
+    if (withinQtDesigner)
+        qCWarning(lcPySidePlugin, "No instance of QPyDesignerCustomWidgetCollection was found.");
     return {};
 }
diff --git a/sources/pyside6/plugins/designer/designercustomwidgets.h b/sources/pyside6/plugins/designer/designercustomwidgets.h
index f88548044..2f1db1f31 100644
--- a/sources/pyside6/plugins/designer/designercustomwidgets.h
+++ b/sources/pyside6/plugins/designer/designercustomwidgets.h
@@ -1,8 +1,8 @@
 // Copyright (C) 2021 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-#ifndef _PY_DESIGNER_CUSTOM_WIDGETS_H_
-#define _PY_DESIGNER_CUSTOM_WIDGETS_H_
+#ifndef PY_DESIGNER_CUSTOM_WIDGETS_H_
+#define PY_DESIGNER_CUSTOM_WIDGETS_H_
 
 #include <QtUiPlugin/QDesignerCustomWidgetCollectionInterface>
 
@@ -17,10 +17,12 @@ class PyDesignerCustomWidgets: public QObject,
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.PySide.PyDesignerCustomWidgetsInterface")
 
 public:
+    Q_DISABLE_COPY_MOVE(PyDesignerCustomWidgets)
+
     explicit PyDesignerCustomWidgets(QObject *parent = nullptr);
-    ~PyDesignerCustomWidgets();
+    ~PyDesignerCustomWidgets() override;
 
     QList<QDesignerCustomWidgetInterface *> customWidgets() const override;
 };
 
-#endif // _PY_DESIGNER_CUSTOM_WIDGETS_H_
+#endif // PY_DESIGNER_CUSTOM_WIDGETS_H_
diff --git a/sources/pyside6/plugins/uitools/CMakeLists.txt b/sources/pyside6/plugins/uitools/CMakeLists.txt
index b6e6502d2..06d0ae900 100644
--- a/sources/pyside6/plugins/uitools/CMakeLists.txt
+++ b/sources/pyside6/plugins/uitools/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(plugins)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
@@ -7,8 +10,8 @@ set(CMAKE_AUTOMOC ON)
 find_package(Qt6 COMPONENTS Core Gui Widgets UiPlugin)
 
 set(ui_plugin_src
-    customwidgets.cpp
-    customwidget.cpp
+    customwidgets.cpp customwidgets.h
+    customwidget.cpp customwidget.h
 )
 
 add_library(uiplugin STATIC ${ui_plugin_src})
diff --git a/sources/pyside6/plugins/uitools/customwidget.cpp b/sources/pyside6/plugins/uitools/customwidget.cpp
index 4e0949b25..976754feb 100644
--- a/sources/pyside6/plugins/uitools/customwidget.cpp
+++ b/sources/pyside6/plugins/uitools/customwidget.cpp
@@ -24,22 +24,22 @@ bool PyCustomWidget::isInitialized() const
 
 QIcon PyCustomWidget::icon() const
 {
-    return QIcon();
+    return {};
 }
 
 QString PyCustomWidget::domXml() const
 {
-    return QString();
+    return {};
 }
 
 QString PyCustomWidget::group() const
 {
-    return QString();
+    return {};
 }
 
 QString PyCustomWidget::includeFile() const
 {
-    return QString();
+    return {};
 }
 
 QString PyCustomWidget::name() const
@@ -49,12 +49,12 @@ QString PyCustomWidget::name() const
 
 QString PyCustomWidget::toolTip() const
 {
-    return QString();
+    return {};
 }
 
 QString PyCustomWidget::whatsThis() const
 {
-    return QString();
+    return {};
 }
 
 // A copy of this code exists in PyDesignerCustomWidget::createWidget()
@@ -64,9 +64,9 @@ QWidget *PyCustomWidget::createWidget(QWidget *parent)
     // Create a python instance and return cpp object
     PyObject *pyParent = nullptr;
     bool unknownParent = false;
-    if (parent) {
+    if (parent != nullptr) {
         pyParent = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(parent));
-        if (pyParent) {
+        if (pyParent != nullptr) {
             Py_INCREF(pyParent);
         } else {
             static Shiboken::Conversions::SpecificConverter converter("QWidget*");
@@ -79,11 +79,11 @@ QWidget *PyCustomWidget::createWidget(QWidget *parent)
     }
 
     Shiboken::AutoDecRef pyArgs(PyTuple_New(1));
-    PyTuple_SET_ITEM(pyArgs, 0, pyParent); // tuple will keep pyParent reference
+    PyTuple_SET_ITEM(pyArgs.object(), 0, pyParent); // tuple will keep pyParent reference
 
     // Call python constructor
-    auto result = reinterpret_cast<SbkObject *>(PyObject_CallObject(m_pyObject, pyArgs));
-    if (!result) {
+    auto *result = reinterpret_cast<SbkObject *>(PyObject_CallObject(m_pyObject, pyArgs));
+    if (result == nullptr) {
         qWarning("Unable to create a Python custom widget of type \"%s\".",
                  qPrintable(m_name));
         PyErr_Print();
diff --git a/sources/pyside6/plugins/uitools/customwidget.h b/sources/pyside6/plugins/uitools/customwidget.h
index 8ffd88bc8..52621f0bd 100644
--- a/sources/pyside6/plugins/uitools/customwidget.h
+++ b/sources/pyside6/plugins/uitools/customwidget.h
@@ -1,15 +1,13 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-#ifndef _PY_CUSTOM_WIDGET_H_
-#define _PY_CUSTOM_WIDGET_H_
+#ifndef PY_CUSTOM_WIDGET_H_
+#define PY_CUSTOM_WIDGET_H_
 
 #include <shiboken.h>
 
 #include <QtUiPlugin/QDesignerCustomWidgetInterface>
 
-#include <QtCore/qglobal.h>
-
 class PyCustomWidget: public QObject, public QDesignerCustomWidgetInterface
 {
      Q_OBJECT
@@ -36,4 +34,4 @@ private:
     bool m_initialized = false;
 };
 
-#endif // _PY_CUSTOM_WIDGET_H_
+#endif // PY_CUSTOM_WIDGET_H_
diff --git a/sources/pyside6/plugins/uitools/customwidgets.h b/sources/pyside6/plugins/uitools/customwidgets.h
index 47e2f73ed..f67a0847d 100644
--- a/sources/pyside6/plugins/uitools/customwidgets.h
+++ b/sources/pyside6/plugins/uitools/customwidgets.h
@@ -1,8 +1,8 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-#ifndef _PY_CUSTOM_WIDGETS_H_
-#define _PY_CUSTOM_WIDGETS_H_
+#ifndef PY_CUSTOM_WIDGETS_H_
+#define PY_CUSTOM_WIDGETS_H_
 
 #include <shiboken.h>
 
@@ -18,8 +18,10 @@ class PyCustomWidgets: public QObject, public QDesignerCustomWidgetCollectionInt
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.PySide.PyCustomWidgetsInterface")
 
 public:
+    Q_DISABLE_COPY_MOVE(PyCustomWidgets)
+
     explicit PyCustomWidgets(QObject *parent = nullptr);
-    ~PyCustomWidgets();
+    ~PyCustomWidgets() override;
 
     QList<QDesignerCustomWidgetInterface*> customWidgets() const override;
 
diff --git a/sources/pyside6/qtexampleicons/CMakeLists.txt b/sources/pyside6/qtexampleicons/CMakeLists.txt
new file mode 100644
index 000000000..1562f7b27
--- /dev/null
+++ b/sources/pyside6/qtexampleicons/CMakeLists.txt
@@ -0,0 +1,52 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.18)
+cmake_policy(VERSION 3.18)
+
+project(QtExampleIcons)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+set(CMAKE_AUTORCC ON)
+
+set(CMAKE_AUTOMOC ON)
+
+find_package(Qt6 COMPONENTS ExampleIconsPrivate)
+
+add_library(QtExampleIcons MODULE module.c)
+
+# See libshiboken/CMakeLists.txt
+if(PYTHON_LIMITED_API)
+    target_compile_definitions(QtExampleIcons PRIVATE "-DPy_LIMITED_API=0x03050000")
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(PYTHON_WITH_DEBUG)
+        target_compile_definitions(QtExampleIcons PRIVATE "-DPy_DEBUG")
+    endif()
+    if (PYTHON_WITH_COUNT_ALLOCS)
+        target_compile_definitions(QtExampleIcons PRIVATE "-DCOUNT_ALLOCS")
+    endif()
+elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
+    target_compile_definitions(QtExampleIcons PRIVATE "-DNDEBUG")
+endif()
+
+target_include_directories(QtExampleIcons PRIVATE ${SHIBOKEN_PYTHON_INCLUDE_DIRS})
+
+get_property(SHIBOKEN_PYTHON_LIBRARIES GLOBAL PROPERTY shiboken_python_libraries)
+
+target_link_libraries(QtExampleIcons PRIVATE
+                      Qt::ExampleIconsPrivate
+                      ${SHIBOKEN_PYTHON_LIBRARIES})
+
+set_target_properties(QtExampleIcons PROPERTIES
+                      PREFIX ""
+                      OUTPUT_NAME "QtExampleIcons${SHIBOKEN_PYTHON_EXTENSION_SUFFIX}"
+                      LIBRARY_OUTPUT_DIRECTORY "${pyside6_BINARY_DIR}")
+
+if(WIN32)
+    set_property(TARGET QtExampleIcons PROPERTY SUFFIX ".pyd")
+endif()
+
+install(TARGETS QtExampleIcons LIBRARY DESTINATION "${PYTHON_SITE_PACKAGES}/PySide6")
diff --git a/sources/pyside6/qtexampleicons/module.c b/sources/pyside6/qtexampleicons/module.c
new file mode 100644
index 000000000..814204f1a
--- /dev/null
+++ b/sources/pyside6/qtexampleicons/module.c
@@ -0,0 +1,41 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <Python.h>
+
+#if defined _WIN32
+#  define MODULE_EXPORT __declspec(dllexport)
+#else
+#  define MODULE_EXPORT __attribute__ ((visibility("default")))
+#endif
+
+static PyMethodDef QtExampleIconsMethods[] = {
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef moduleDef = {
+    /* m_base     */ PyModuleDef_HEAD_INIT,
+    /* m_name     */ "QtExampleIcons",
+    /* m_doc      */ NULL,
+    /* m_size     */ -1,
+    /* m_methods  */ QtExampleIconsMethods,
+    /* m_reload   */ NULL,
+    /* m_traverse */ NULL,
+    /* m_clear    */ NULL,
+    /* m_free     */ NULL
+};
+
+MODULE_EXPORT PyObject *PyInit_QtExampleIcons(void)
+{
+    return PyModule_Create(&moduleDef);
+}
+
+int main(int argc, char *argv[])
+{
+#ifndef PYPY_VERSION
+    Py_SetProgramName(L"module-test");
+    Py_Initialize();
+#endif
+    PyInit_QtExampleIcons();
+    return 0;
+}
diff --git a/sources/pyside6/tests/CMakeLists.txt b/sources/pyside6/tests/CMakeLists.txt
index e945e681b..539e1aea8 100644
--- a/sources/pyside6/tests/CMakeLists.txt
+++ b/sources/pyside6/tests/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 if(PYSIDE_IS_CROSS_BUILD)
     # SHIBOKEN_PYTHON_INTERPRETER will be empty when cross-building.
     message(WARNING
@@ -14,7 +17,7 @@ endif()
 # the path to the testbinding module
 get_filename_component(BUILD_DIR "${CMAKE_BINARY_DIR}" DIRECTORY)
 get_filename_component(BUILD_DIR "${CMAKE_BINARY_DIR}" DIRECTORY)
-set(QT_DIR "${_qt5Core_install_prefix}")
+set(QT_DIR "${QT6_INSTALL_PREFIX}")
 
 macro(TEST_QT_MODULE var name)
   if(NOT DISABLE_${name} AND ${var})
@@ -49,8 +52,13 @@ add_subdirectory(registry)
 add_subdirectory(signals)
 add_subdirectory(support)
 add_subdirectory(tools/metaobjectdump)
+add_subdirectory(tools/pyside6-deploy)
+
+if(UNIX AND NOT APPLE)
+    add_subdirectory(tools/pyside6-android-deploy)
+endif()
 
-if (NOT DISABLE_QtQml)
+if (NOT DISABLE_QtQuick)
     add_subdirectory(tools/pyside6-qml)
 endif()
 
diff --git a/sources/pyside6/tests/Qt3DExtras/qt3dextras_test.py b/sources/pyside6/tests/Qt3DExtras/qt3dextras_test.py
index 6f472def7..23e2d6e7e 100644
--- a/sources/pyside6/tests/Qt3DExtras/qt3dextras_test.py
+++ b/sources/pyside6/tests/Qt3DExtras/qt3dextras_test.py
@@ -13,7 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import (Property, QObject, QPropertyAnimation, QTimer, Signal, Slot)
 from PySide6.QtGui import (QGuiApplication, QMatrix4x4, QQuaternion, QVector3D, QWindow)
@@ -123,7 +123,7 @@ class Window(Qt3DExtras.Qt3DWindow):
         self.sphereEntity.addComponent(self.material)
 
 
-class Qt3DExtrasTestCase(UsesQGuiApplication):
+class Qt3DExtrasTestCase(UsesQApplication):
     '''Tests related to Q3DExtras'''
 
     def test3DExtras(self):
diff --git a/sources/pyside6/tests/QtAsyncio/CMakeLists.txt b/sources/pyside6/tests/QtAsyncio/CMakeLists.txt
new file mode 100644
index 000000000..935e0d90a
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/CMakeLists.txt
@@ -0,0 +1,2 @@
+PYSIDE_TEST(qasyncio_test.py)
+PYSIDE_TEST(qasyncio_test_chain.py)
diff --git a/sources/pyside6/tests/QtAsyncio/QtAsyncio.pyproject b/sources/pyside6/tests/QtAsyncio/QtAsyncio.pyproject
new file mode 100644
index 000000000..a36dcd5ad
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/QtAsyncio.pyproject
@@ -0,0 +1,3 @@
+{
+    "files": ["qt_asyncio_test.py", "qt_asyncio_test_chain.py", "qt_asyncio_test_time.py"]
+}
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test.py
new file mode 100644
index 000000000..f3c971285
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test.py
@@ -0,0 +1,51 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCase(unittest.TestCase):
+    async def sleep(self, output):
+        output += "Hello"
+        await asyncio.sleep(0.2)
+        output += "World"
+
+    async def gather(self, output):
+        await asyncio.gather(self.sleep(output), self.sleep(output), self.sleep(output))
+
+    def test_sleep(self):
+        outputs_expected = []
+        outputs_real = []
+
+        # Run the code without QAsyncioEventLoopPolicy
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+        asyncio.run(self.sleep(outputs_expected))
+
+        # Run the code with QAsyncioEventLoopPolicy and QtEventLoop
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        asyncio.run(self.sleep(outputs_real))
+
+        self.assertEqual(outputs_expected, outputs_real)
+
+    def test_gather(self):
+        outputs_expected = []
+        outputs_real = []
+
+        # Run the code without QAsyncioEventLoopPolicy
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+        asyncio.run(self.gather(outputs_expected))
+
+        # Run the code with QAsyncioEventLoopPolicy and QtEventLoop
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        asyncio.run(self.gather(outputs_real))
+
+        self.assertEqual(outputs_expected, outputs_real)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_task.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_task.py
new file mode 100644
index 000000000..7ef2bb90d
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_task.py
@@ -0,0 +1,46 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import asyncio
+import unittest
+
+import PySide6.QtAsyncio as QtAsyncio
+
+
+class QAsyncioTestCaseCancelTask(unittest.TestCase):
+    # Taken from https://docs.python.org/3/library/asyncio-task.html#asyncio.Task.cancel
+
+    async def cancel_me(self, output):
+        output += "(1) cancel_me(): before sleep"
+
+        try:
+            await asyncio.sleep(10)
+        except asyncio.CancelledError:
+            output += "(2) cancel_me(): cancel sleep"
+            raise
+        finally:
+            output += "(3) cancel_me(): after sleep"
+
+    async def main(self, output):
+        task = asyncio.create_task(self.cancel_me(output))
+        await asyncio.sleep(0.1)
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            output += "(4) main(): cancel_me is cancelled now"
+
+    def test_await_tasks(self):
+        output_expected = []
+        output_real = []
+
+        asyncio.run(self.main(output_expected))
+        QtAsyncio.run(self.main(output_real), keep_running=False)
+
+        self.assertEqual(output_real, output_expected)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_taskgroup.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_taskgroup.py
new file mode 100644
index 000000000..aa8ce4718
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_cancel_taskgroup.py
@@ -0,0 +1,57 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import asyncio
+import unittest
+
+import PySide6.QtAsyncio as QtAsyncio
+
+
+class QAsyncioTestCaseCancelTaskGroup(unittest.TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        # We only reach the end of the loop if the task is not cancelled.
+        self.loop_end_reached = False
+
+    async def raise_error(self):
+        raise RuntimeError
+
+    async def loop_short(self):
+        self._loop_end_reached = False
+        for _ in range(1000):
+            await asyncio.sleep(1e-3)
+        self._loop_end_reached = True
+
+    async def loop_shorter(self):
+        self._loop_end_reached = False
+        for _ in range(1000):
+            await asyncio.sleep(1e-4)
+        self._loop_end_reached = True
+
+    async def loop_the_shortest(self):
+        self._loop_end_reached = False
+        for _ in range(1000):
+            await asyncio.to_thread(lambda: None)
+        self._loop_end_reached = True
+
+    async def main(self, coro):
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(coro())
+            tg.create_task(self.raise_error())
+
+    def test_cancel_taskgroup(self):
+        coros = [self.loop_short, self.loop_shorter, self.loop_the_shortest]
+
+        for coro in coros:
+            try:
+                QtAsyncio.run(self.main(coro), keep_running=False)
+            except ExceptionGroup as e:
+                self.assertEqual(len(e.exceptions), 1)
+                self.assertIsInstance(e.exceptions[0], RuntimeError)
+                self.assertFalse(self._loop_end_reached)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_chain.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_chain.py
new file mode 100644
index 000000000..a0a949720
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_chain.py
@@ -0,0 +1,57 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+import random
+import time
+
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCaseChain(unittest.TestCase):
+
+    async def link(self, output, n, i):
+        t = random.randint(0, 5)
+        output += f"link {i}({n}): {t}s "
+        await asyncio.sleep(i)
+        result = f"result {n}-{i}"
+        output += f"link {i}({n}) finished with {result} "
+        return result
+
+    async def chain(self, output, n):
+        link1 = await self.link(output, n, 0.2)
+        link2 = await self.link(output, n, 0.5)
+        output += f"chain {n}: {link1} -> {link2} "
+
+    async def gather(self, output, *args):
+        await asyncio.gather(*(self.chain(output, n) for n in args))
+
+    def test_chain(self):
+        args = [1, 2, 3]
+
+        outputs_expected = []
+        outputs_real = []
+
+        # Run the code without QAsyncioEventLoopPolicy
+        random.seed(17)
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+        start = time.perf_counter()
+        asyncio.run(self.gather(outputs_expected, *args))
+        end_expected = time.perf_counter() - start
+
+        # Run the code with QAsyncioEventLoopPolicy and QtEventLoop
+        random.seed(17)
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        start = time.perf_counter()
+        asyncio.run(self.gather(outputs_real, *args))
+        end_real = time.perf_counter() - start
+
+        self.assertEqual(outputs_expected, outputs_real)
+        self.assertAlmostEqual(end_expected, end_real, delta=0.5)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_executor.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_executor.py
new file mode 100644
index 000000000..25e680b39
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_executor.py
@@ -0,0 +1,47 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+
+from concurrent.futures import ThreadPoolExecutor
+
+from PySide6.QtCore import QThread
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCaseExecutor(unittest.TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.executor_thread = None
+
+    def tearDown(self) -> None:
+        super().tearDown()
+
+    def blocking_function(self):
+        self.executor_thread = QThread.currentThread()
+        return 42
+
+    async def run_asyncio_executor(self):
+        main_thread = QThread.currentThread()
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            result = await asyncio.get_running_loop().run_in_executor(
+                executor, self.blocking_function)
+
+            # Assert that we are back to the main thread.
+            self.assertEqual(QThread.currentThread(), main_thread)
+
+            # Assert that the blocking function was executed in a different thread.
+            self.assertNotEqual(self.executor_thread, main_thread)
+
+            self.assertEqual(result, 42)
+
+    def test_qasyncio_executor(self):
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        asyncio.run(self.run_asyncio_executor())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_queues.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_queues.py
new file mode 100644
index 000000000..0bd98c361
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_queues.py
@@ -0,0 +1,70 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+import random
+import time
+
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCaseQueues(unittest.TestCase):
+
+    async def produce(self, output, queue):
+        for _ in range(random.randint(0, 2)):
+            await asyncio.sleep(random.random())
+            await queue.put(self.i)
+            output += f"{self.i} added to queue\n"
+            self.i += 1
+
+    async def consume(self, output, queue):
+        while True:
+            await asyncio.sleep(random.random())
+            i = await queue.get()
+            output += f"{i} pulled from queue\n"
+            queue.task_done()
+
+    async def main(self, output1, output2, num_producers, num_consumers):
+        self.i = 0
+        queue = asyncio.Queue()
+        producers = [
+            asyncio.create_task(self.produce(output1, queue)) for _ in range(num_producers)]
+        consumers = [
+            asyncio.create_task(self.consume(output2, queue)) for _ in range(num_consumers)]
+        await asyncio.gather(*producers)
+        await queue.join()
+        for consumer in consumers:
+            consumer.cancel()
+
+    def test_queues(self):
+        args = [(2, 3), (2, 1)]
+        for arg in args:
+            outputs_expected1 = []
+            outputs_expected2 = []
+            outputs_real1 = []
+            outputs_real2 = []
+
+            # Run the code without QAsyncioEventLoopPolicy
+            random.seed(17)
+            start = time.perf_counter()
+            asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+            asyncio.run(self.main(outputs_expected1, outputs_expected2, *arg))
+            end_expected = time.perf_counter() - start
+
+            # Run the code with QAsyncioEventLoopPolicy and QtEventLoop
+            random.seed(17)
+            start = time.perf_counter()
+            asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+            asyncio.run(self.main(outputs_real1, outputs_real2, *arg))
+            end_real = time.perf_counter() - start
+
+            self.assertEqual(outputs_expected1, outputs_real1)
+            self.assertEqual(outputs_expected2, outputs_real2)
+            self.assertAlmostEqual(end_expected, end_real, delta=1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_threadsafe.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_threadsafe.py
new file mode 100644
index 000000000..5b52db239
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_threadsafe.py
@@ -0,0 +1,58 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+import threading
+import time
+
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCaseThreadsafe(unittest.TestCase):
+
+    def setUp(self) -> None:
+        super().setUp()
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        self.loop_event = asyncio.Event()
+
+    def thread_target(self, is_threadsafe):
+        time.sleep(1)
+        if is_threadsafe:
+            # call_soon_threadsafe() wakes the loop that is in another thread, so the
+            # loop checks the event and will not hang.
+            asyncio.get_event_loop().call_soon_threadsafe(self.loop_event.set)
+        else:
+            # call_soon() does not wake the loop that is in another thread, and so the
+            # loop keeps waiting without checking the event and will hang.
+            asyncio.get_event_loop().call_soon(self.loop_event.set)
+
+    async def coro(self, is_threadsafe):
+        thread = threading.Thread(target=self.thread_target, args=(is_threadsafe,))
+        thread.start()
+
+        task = asyncio.create_task(self.loop_event.wait())
+
+        # The timeout is necessary because the loop will hang for the non-threadsafe case.
+        done, pending = await asyncio.wait([task], timeout=2)
+
+        thread.join()
+
+        if is_threadsafe:
+            self.assertEqual(len(done), 1)
+            self.assertEqual(len(pending), 0)
+        else:
+            self.assertEqual(len(done), 0)
+            self.assertEqual(len(pending), 1)
+
+    def test_not_threadsafe(self):
+        asyncio.run(self.coro(False))
+
+    def test_threadsafe(self):
+        asyncio.run(self.coro(True))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtAsyncio/qasyncio_test_time.py b/sources/pyside6/tests/QtAsyncio/qasyncio_test_time.py
new file mode 100644
index 000000000..07a126644
--- /dev/null
+++ b/sources/pyside6/tests/QtAsyncio/qasyncio_test_time.py
@@ -0,0 +1,49 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QtAsyncio'''
+
+import unittest
+import asyncio
+import datetime
+
+from PySide6.QtAsyncio import QAsyncioEventLoopPolicy
+
+
+class QAsyncioTestCaseTime(unittest.TestCase):
+
+    def setUp(self):
+        self.previous_time = None
+        self.exception = None
+
+    def display_date(self, end_time, loop):
+        if self.previous_time is not None:
+            try:
+                self.assertAlmostEqual(
+                    (datetime.datetime.now() - self.previous_time).total_seconds(), 1, delta=0.1)
+            except AssertionError as e:
+                self.exception = e
+        self.previous_time = datetime.datetime.now()
+        if (loop.time() + 1.0) < end_time:
+            loop.call_later(1, self.display_date, end_time, loop)
+        else:
+            loop.stop()
+
+    def test_time(self):
+        asyncio.set_event_loop_policy(QAsyncioEventLoopPolicy())
+        loop = asyncio.new_event_loop()
+
+        end_time = loop.time() + 3.0
+        loop.call_soon(self.display_date, end_time, loop)
+
+        try:
+            loop.run_forever()
+        finally:
+            loop.close()
+
+        if self.exception is not None:
+            raise self.exception
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtBluetooth/localdevice.py b/sources/pyside6/tests/QtBluetooth/localdevice.py
index b09cc12b2..21801106f 100644
--- a/sources/pyside6/tests/QtBluetooth/localdevice.py
+++ b/sources/pyside6/tests/QtBluetooth/localdevice.py
@@ -15,9 +15,11 @@ init_test_paths(False)
 
 from PySide6.QtBluetooth import QBluetoothLocalDevice
 
+
 class QBluetoothLocalDeviceTest(unittest.TestCase):
     def testInitialization(self):
         device = QBluetoothLocalDevice()
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtCharts/CMakeLists.txt b/sources/pyside6/tests/QtCharts/CMakeLists.txt
index 16e8b4bc9..4d031937a 100644
--- a/sources/pyside6/tests/QtCharts/CMakeLists.txt
+++ b/sources/pyside6/tests/QtCharts/CMakeLists.txt
@@ -1 +1,2 @@
 PYSIDE_TEST(qcharts_test.py)
+PYSIDE_TEST(qcharts_numpy_test.py)
diff --git a/sources/pyside6/tests/QtCharts/qcharts_numpy_test.py b/sources/pyside6/tests/QtCharts/qcharts_numpy_test.py
new file mode 100644
index 000000000..8154020c0
--- /dev/null
+++ b/sources/pyside6/tests/QtCharts/qcharts_numpy_test.py
@@ -0,0 +1,49 @@
+#!/usr/bin/python
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QCharts/numpy'''
+
+import os
+import sys
+import unittest
+try:
+    import numpy as np
+    HAVE_NUMPY = True
+except ModuleNotFoundError:
+    HAVE_NUMPY = False
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from helper.usesqapplication import UsesQApplication
+from PySide6.QtCore import QCoreApplication
+from PySide6.QtCharts import QLineSeries
+
+
+class QChartsNumpyTestCase(UsesQApplication):
+    '''Tests related to QCharts/numpy'''
+
+    @unittest.skipUnless(HAVE_NUMPY, "requires numpy")
+    def test(self):
+        """PYSIDE-2313: Verify various types."""
+        line_series = QLineSeries()
+        data_types = [np.short, np.ushort, np.int32, np.uint32,
+                      np.int64, np.uint64, np.float32, np.float64]
+        for dt in data_types:
+            print("Testing ", dt)
+            old_size = line_series.count()
+            x_arr = np.array([2], dtype=dt)
+            y_arr = np.array([3], dtype=dt)
+            line_series.appendNp(x_arr, y_arr)
+            size = line_series.count()
+            self.assertEqual(size, old_size + 1)
+            point = line_series.points()[size - 1]
+            self.assertEqual(point.x(), 2)
+            self.assertEqual(point.y(), 3)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/CMakeLists.txt b/sources/pyside6/tests/QtCore/CMakeLists.txt
index 59f4161cb..f0228d943 100644
--- a/sources/pyside6/tests/QtCore/CMakeLists.txt
+++ b/sources/pyside6/tests/QtCore/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(attr_cache_py3k.py)
 PYSIDE_TEST(bug_278_test.py)
 PYSIDE_TEST(bug_300_test.py)
@@ -31,6 +34,7 @@ PYSIDE_TEST(bug_1313.py)
 PYSIDE_TEST(bug_PYSIDE-41.py)
 PYSIDE_TEST(bug_PYSIDE-42.py)
 PYSIDE_TEST(bug_PYSIDE-164.py)
+PYSIDE_TEST(bug_PYSIDE-2745.py)
 PYSIDE_TEST(blocking_signals_test.py)
 PYSIDE_TEST(classinfo_test.py)
 PYSIDE_TEST(child_event_test.py)
@@ -126,6 +130,7 @@ PYSIDE_TEST(quuid_test.py)
 PYSIDE_TEST(qversionnumber_test.py)
 PYSIDE_TEST(repr_test.py)
 PYSIDE_TEST(setprop_on_ctor_test.py)
+PYSIDE_TEST(signal_sender.py)
 PYSIDE_TEST(snake_prop_feature_test.py)
 PYSIDE_TEST(staticMetaObject_test.py)
 PYSIDE_TEST(static_method_test.py)
@@ -136,6 +141,7 @@ PYSIDE_TEST(unaryoperator_test.py)
 PYSIDE_TEST(unicode_test.py)
 PYSIDE_TEST(versioninfo_test.py)
 PYSIDE_TEST(loggingcategorymacros_test.py)
+PYSIDE_TEST(qrunnable_test.py)
 
 if(X11)
     PYSIDE_TEST(qhandle_test.py)
diff --git a/sources/pyside6/tests/QtCore/blocking_signals_test.py b/sources/pyside6/tests/QtCore/blocking_signals_test.py
index d8159c2ef..493abb071 100644
--- a/sources/pyside6/tests/QtCore/blocking_signals_test.py
+++ b/sources/pyside6/tests/QtCore/blocking_signals_test.py
@@ -14,7 +14,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, QFile, QSignalBlocker
+from PySide6.QtCore import QObject, Signal, QFile, QSignalBlocker
+
+
+class Sender(QObject):
+    mysignal = Signal()
+    mysignal_int_int = Signal(int, int)
 
 
 class TestSignalsBlockedBasic(unittest.TestCase):
@@ -61,7 +66,7 @@ class TestSignalsBlocked(unittest.TestCase):
 
     def setUp(self):
         # Set up the basic resources needed
-        self.obj = QObject()
+        self.obj = Sender()
         self.args = tuple()
         self.called = False
 
@@ -81,27 +86,28 @@ class TestSignalsBlocked(unittest.TestCase):
 
     def testShortCircuitSignals(self):
         # Blocking of Python short-circuit signals
-        QObject.connect(self.obj, SIGNAL('mysignal()'), self.callback)
+        self.obj.mysignal.connect(self.callback)
 
-        self.obj.emit(SIGNAL('mysignal()'))
+        self.obj.mysignal.emit()
         self.assertTrue(self.called)
 
         self.called = False
         self.obj.blockSignals(True)
-        self.obj.emit(SIGNAL('mysignal()'))
+        self.obj.mysignal.emit()
         self.assertTrue(not self.called)
 
     def testPythonSignals(self):
         # Blocking of Python typed signals
-        QObject.connect(self.obj, SIGNAL('mysignal(int,int)'), self.callback)
+
+        self.obj.mysignal_int_int.connect(self.callback)
         self.args = (1, 3)
 
-        self.obj.emit(SIGNAL('mysignal(int,int)'), *self.args)
+        self.obj.mysignal_int_int.emit(*self.args)
         self.assertTrue(self.called)
 
         self.called = False
         self.obj.blockSignals(True)
-        self.obj.emit(SIGNAL('mysignal(int,int)'), *self.args)
+        self.obj.mysignal_int_int.emit(*self.args)
         self.assertTrue(not self.called)
 
 
@@ -130,7 +136,7 @@ class TestQFileSignalBlocking(unittest.TestCase):
     def testAboutToCloseBlocking(self):
         # QIODevice.aboutToClose() blocking
 
-        QObject.connect(self.qfile, SIGNAL('aboutToClose()'), self.callback)
+        self.qfile.aboutToClose.connect(self.callback)
 
         self.assertTrue(self.qfile.open(QFile.ReadOnly))
         self.qfile.close()
diff --git a/sources/pyside6/tests/QtCore/bug_1019.py b/sources/pyside6/tests/QtCore/bug_1019.py
index 89e400428..4a35956b1 100644
--- a/sources/pyside6/tests/QtCore/bug_1019.py
+++ b/sources/pyside6/tests/QtCore/bug_1019.py
@@ -30,6 +30,7 @@ class MyTimer2 (MyTimer):
         pass
 
     def start(self):
+        """ 'Overrides' non-virtual slot QTimer.start()."""
         self.startCalled = True
         QCoreApplication.instance().quit()
 
diff --git a/sources/pyside6/tests/QtCore/bug_462.py b/sources/pyside6/tests/QtCore/bug_462.py
index 2f13bb531..04a42fe08 100644
--- a/sources/pyside6/tests/QtCore/bug_462.py
+++ b/sources/pyside6/tests/QtCore/bug_462.py
@@ -16,7 +16,7 @@ from PySide6.QtCore import QObject, QCoreApplication, QEvent, QThread
 class MyEvent(QEvent):
     def __init__(self, i):
         print("TYPE:", type(QEvent.User))
-        super().__init__(QEvent.Type(QEvent.User + (0 if sys.pyside63_option_python_enum else 100)))
+        super().__init__(QEvent.Type(QEvent.User))
         self.i = i
 
 
diff --git a/sources/pyside6/tests/QtCore/bug_515.py b/sources/pyside6/tests/QtCore/bug_515.py
index 52293b808..4e270a441 100644
--- a/sources/pyside6/tests/QtCore/bug_515.py
+++ b/sources/pyside6/tests/QtCore/bug_515.py
@@ -26,7 +26,7 @@ def _cleanup():
 
 def _checkCleanup():
     global callCleanup
-    assert(callCleanup)
+    assert (callCleanup)
 
 
 app = QCoreApplication([])
diff --git a/sources/pyside6/tests/QtCore/bug_826.py b/sources/pyside6/tests/QtCore/bug_826.py
index 65b237d24..95edc0a7c 100644
--- a/sources/pyside6/tests/QtCore/bug_826.py
+++ b/sources/pyside6/tests/QtCore/bug_826.py
@@ -33,11 +33,6 @@ class TestEnums(unittest.TestCase):
         self.assertTrue(QEvent.User <= TestEvent.TestEventType <= QEvent.MaxUser)
         self.assertTrue(QEvent.User <= TEST_EVENT_TYPE <= QEvent.MaxUser)
 
-    @unittest.skipIf(sys.pyside63_option_python_enum, "makes no sense for tested Python enums")
-    def testUserTypesRepr(self):
-        self.assertEqual(eval(repr(TestEvent.TestEventType)), TestEvent.TestEventType)
-        self.assertEqual(eval(repr(TEST_EVENT_TYPE)), TEST_EVENT_TYPE)
-
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtCore/bug_927.py b/sources/pyside6/tests/QtCore/bug_927.py
index 1ecea61b2..c15a7014b 100644
--- a/sources/pyside6/tests/QtCore/bug_927.py
+++ b/sources/pyside6/tests/QtCore/bug_927.py
@@ -24,7 +24,7 @@ class thread_function():
 
 class Task(QRunnable):
     def run(self):
-        QThread.sleep(2)  # Sleep 2 seconds
+        QThread.msleep(100)
 
 
 class QThreadPoolTest(unittest.TestCase):
@@ -34,15 +34,15 @@ class QThreadPoolTest(unittest.TestCase):
         for i in range(3):
             task = Task()
             QThreadPool.globalInstance().start(task)
-            time.sleep(1)  # Sleep 1 second
+            time.sleep(0.05)
 
-        QThreadPool.globalInstance().waitForDone()
+        self.assertTrue(QThreadPool.globalInstance().waitForDone())
 
     def testCallable(self):
         global thread_function_called
         tp = QThreadPool.globalInstance()
         tp.start(thread_function)
-        tp.waitForDone()
+        self.assertTrue(tp.waitForDone())
         self.assertTrue(thread_function_called)
 
 
diff --git a/sources/pyside6/tests/QtCore/bug_987.py b/sources/pyside6/tests/QtCore/bug_987.py
index bc92e5736..a8c9799e0 100644
--- a/sources/pyside6/tests/QtCore/bug_987.py
+++ b/sources/pyside6/tests/QtCore/bug_987.py
@@ -19,7 +19,7 @@ class TestBug987(unittest.TestCase):
 
     def testInvalidDisconnection(self):
         o = QObject()
-        self.assertRaises(RuntimeError, o.destroyed.disconnect, self.callback)
+        self.assertFalse(o.destroyed.disconnect(self.callback))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtCore/bug_PYSIDE-164.py b/sources/pyside6/tests/QtCore/bug_PYSIDE-164.py
index c5a6736a8..84859af84 100644
--- a/sources/pyside6/tests/QtCore/bug_PYSIDE-164.py
+++ b/sources/pyside6/tests/QtCore/bug_PYSIDE-164.py
@@ -10,16 +10,19 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QCoreApplication, QEventLoop, QObject, Qt, QThread, QTimer, SIGNAL
+from PySide6.QtCore import QCoreApplication, QEventLoop, QObject, Qt, QThread, Signal
 
 
 class Emitter(QThread):
+
+    signal = Signal(int)
+
     def __init__(self):
         super().__init__()
 
     def run(self):
         print("Before emit.")
-        self.emit(SIGNAL("signal(int)"), 0)
+        self.signal.emit(0)
         print("After emit.")
 
 
@@ -36,12 +39,11 @@ class Receiver(QObject):
 class TestBugPYSIDE164(unittest.TestCase):
 
     def testBlockingSignal(self):
-        app = QCoreApplication.instance() or QCoreApplication([])
+        app = QCoreApplication.instance() or QCoreApplication([])  # noqa: F841
         eventloop = QEventLoop()
         emitter = Emitter()
         receiver = Receiver(eventloop)
-        emitter.connect(emitter, SIGNAL("signal(int)"),
-                        receiver.receive, Qt.BlockingQueuedConnection)
+        emitter.signal.connect(receiver.receive, Qt.BlockingQueuedConnection)
         emitter.start()
         retval = eventloop.exec()
         emitter.wait(2000)
diff --git a/sources/pyside6/tests/QtCore/bug_PYSIDE-2745.py b/sources/pyside6/tests/QtCore/bug_PYSIDE-2745.py
new file mode 100644
index 000000000..3d6c603b7
--- /dev/null
+++ b/sources/pyside6/tests/QtCore/bug_PYSIDE-2745.py
@@ -0,0 +1,37 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtCore import QTimer
+
+from helper.usesqapplication import UsesQApplication
+
+
+class TestBugPYSIDE2745(UsesQApplication):
+
+    def setUp(self):
+        UsesQApplication.setUp(self)
+        self.counter = 0
+
+    def fail(self):
+        self.counter += 1
+        raise Exception()
+
+    def test_fail(self):
+        QTimer.singleShot(0, self.fail)
+        QTimer.singleShot(0, self.fail)
+        QTimer.singleShot(1, self.app.quit)
+        self.app.exec()
+        self.assertEqual(self.counter, 2)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/child_event_test.py b/sources/pyside6/tests/QtCore/child_event_test.py
index 356bf0f72..6b17ddc93 100644
--- a/sources/pyside6/tests/QtCore/child_event_test.py
+++ b/sources/pyside6/tests/QtCore/child_event_test.py
@@ -14,7 +14,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, QTimer, QCoreApplication
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class ExtQObject(QObject):
@@ -37,14 +37,14 @@ class ExtQTimer(QTimer):
         self.child_event_received = True
 
 
-class TestChildEvent(UsesQCoreApplication):
+class TestChildEvent(UsesQApplication):
     '''Test case for QObject::childEvent and QTimer::childEvent'''
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
 
     def tearDown(self):
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testQObject(self):
         parent = ExtQObject()
diff --git a/sources/pyside6/tests/QtCore/classinfo_test.py b/sources/pyside6/tests/QtCore/classinfo_test.py
index 30d141acf..0b0a0b4b6 100644
--- a/sources/pyside6/tests/QtCore/classinfo_test.py
+++ b/sources/pyside6/tests/QtCore/classinfo_test.py
@@ -33,7 +33,7 @@ class TestClassInfo(unittest.TestCase):
         self.assertEqual(ci.value(), 'http://www.pyside.org')
 
     def test_dictionary(self):
-        @ClassInfo({'author':'pyside', 'author company':'The Qt Company'})
+        @ClassInfo({'author': 'pyside', 'author company': 'The Qt Company'})
         class MyObject(QObject):
             pass
 
@@ -50,11 +50,11 @@ class TestClassInfo(unittest.TestCase):
         self.assertEqual(ci.value(), 'The Qt Company')
 
     def test_verify_metadata_types(self):
-        valid_dict = { '123': '456' }
+        valid_dict = {'123': '456'}
 
-        invalid_dict_1 = { '123': 456 }
-        invalid_dict_2 = {  123:  456 }
-        invalid_dict_3 = {  123: '456' }
+        invalid_dict_1 = {'123': 456}
+        invalid_dict_2 = {123: 456}
+        invalid_dict_3 = {123: '456'}
 
         ClassInfo(**valid_dict)
 
@@ -88,6 +88,7 @@ class TestClassInfo(unittest.TestCase):
     def test_can_only_be_used_on_qobjects(self):
         def make_info():
             return ClassInfo(author='pyside')
+
         def test_function():
             pass
         self.assertRaises(TypeError, make_info(), test_function)
diff --git a/sources/pyside6/tests/QtCore/deletelater_test.py b/sources/pyside6/tests/QtCore/deletelater_test.py
index 18e7dea09..0ee078428 100644
--- a/sources/pyside6/tests/QtCore/deletelater_test.py
+++ b/sources/pyside6/tests/QtCore/deletelater_test.py
@@ -15,10 +15,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, QTimer, QCoreApplication, SIGNAL
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class TestDeleteLater(UsesQCoreApplication):
+class TestDeleteLater(UsesQApplication):
     '''Test case for function DeleteLater'''
 
     def testCase(self):
diff --git a/sources/pyside6/tests/QtCore/destroysignal_test.py b/sources/pyside6/tests/QtCore/destroysignal_test.py
index 34aaded9e..ad087b489 100644
--- a/sources/pyside6/tests/QtCore/destroysignal_test.py
+++ b/sources/pyside6/tests/QtCore/destroysignal_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QTimer, QObject
+from PySide6.QtCore import QTimer, QObject, Signal
 
 
 class TestDestroySignal(unittest.TestCase):
@@ -43,6 +43,36 @@ class TestDestroySignal(unittest.TestCase):
         self.assertTrue(self._destroyed)
 
 
+class Foo(QObject):
+    s = Signal(int)
+
+    def __init__(self):
+        QObject.__init__(self)
+        sys.stderr.write(f"__init__ {id(self):x}\n")
+
+    def __del__(self):
+        sys.stderr.write(f"__del__  {id(self):x}\n")
+
+    def send(self, i):
+        self.s.emit(i)
+
+
+# PYSIDE-2201/2328: This crashed until we introduced a weak reference.
+class TestDestroyNoConnect(unittest.TestCase):
+
+    def testSignalDestroyedMissingReference(self):
+        # This works since it has one reference more to Foo
+        Foo().send(43)
+        # This crashed because we have no reference in the signal.
+        with self.assertRaises(RuntimeError):
+            Foo().s.emit(44)
+
+    def testSignalDestroyedinConnect(self):
+        # PYSIDE-2328: Connect to signal of temporary
+        with self.assertRaises(RuntimeError):
+            Foo().s.connect(None)
+
+
 if __name__ == '__main__':
     unittest.main()
 
diff --git a/sources/pyside6/tests/QtCore/duck_punching_test.py b/sources/pyside6/tests/QtCore/duck_punching_test.py
index 668ca5751..145863c3e 100644
--- a/sources/pyside6/tests/QtCore/duck_punching_test.py
+++ b/sources/pyside6/tests/QtCore/duck_punching_test.py
@@ -16,7 +16,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 def MethodType(func, instance, instanceType):
@@ -31,20 +31,20 @@ class Duck(QObject):
         QObject.childEvent(self, event)
 
 
-class TestDuckPunchingOnQObjectInstance(UsesQCoreApplication):
+class TestDuckPunchingOnQObjectInstance(UsesQApplication):
     '''Test case for duck punching new implementations of C++ virtual methods into object instances.'''
 
     def setUp(self):
         # Acquire resources
         self.duck_childEvent_called = False
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
 
     def tearDown(self):
         # Release resources
         del self.duck_childEvent_called
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testChildEventMonkeyPatch(self):
         # Test if the new childEvent injected on QObject instance is called from C++
diff --git a/sources/pyside6/tests/QtCore/errormessages_with_features_test.py b/sources/pyside6/tests/QtCore/errormessages_with_features_test.py
index 8cb38882a..97c4f942e 100644
--- a/sources/pyside6/tests/QtCore/errormessages_with_features_test.py
+++ b/sources/pyside6/tests/QtCore/errormessages_with_features_test.py
@@ -34,7 +34,6 @@ This test is in its own file because combining it with
 @unittest.skipIf(is_pypy, "__feature__ cannot yet be used with PyPy")
 class ErrormessagesWithFeatures(unittest.TestCase):
     probe = "called with wrong argument types"
-    probe_miss = "missing signature"
 
     def setUp(self):
         qApp or QApplication()
@@ -76,20 +75,20 @@ class ErrormessagesWithFeatures(unittest.TestCase):
         with self.assertRaises(TypeError) as cm:
             QApplication.quitOnLastWindowClosed = object
         print("\n\n" + cm.exception.args[0])
-        self.assertTrue(self.probe_miss in cm.exception.args[0])
+        self.assertTrue(self.probe in cm.exception.args[0])
         with self.assertRaises(TypeError) as cm:
             qApp.quitOnLastWindowClosed = object
-        self.assertTrue(self.probe_miss in cm.exception.args[0])
+        self.assertTrue(self.probe in cm.exception.args[0])
 
     def testCorrectErrorMessagesClassSnakeProp(self):
         from __feature__ import snake_case, true_property
         with self.assertRaises(TypeError) as cm:
             QApplication.quit_on_last_window_closed = object
         print("\n\n" + cm.exception.args[0])
-        self.assertTrue(self.probe_miss in cm.exception.args[0])
+        self.assertTrue(self.probe in cm.exception.args[0])
         with self.assertRaises(TypeError) as cm:
             qApp.quit_on_last_window_closed = object
-        self.assertTrue(self.probe_miss in cm.exception.args[0])
+        self.assertTrue(self.probe in cm.exception.args[0])
 
     def testDocIsWorking(self):
         """
diff --git a/sources/pyside6/tests/QtCore/feature_with_uic/window.py b/sources/pyside6/tests/QtCore/feature_with_uic/window.py
index 6632fbaf9..c55bcaf92 100644
--- a/sources/pyside6/tests/QtCore/feature_with_uic/window.py
+++ b/sources/pyside6/tests/QtCore/feature_with_uic/window.py
@@ -28,7 +28,6 @@ class Ui_MainWindow(object):
 
         self.verticalLayout.addWidget(self.pushButton)
 
-
         self.horizontalLayout.addLayout(self.verticalLayout)
 
         MainWindow.setCentralWidget(self.centralwidget)
diff --git a/sources/pyside6/tests/QtCore/hash_test.py b/sources/pyside6/tests/QtCore/hash_test.py
index acd100786..aee2f516c 100644
--- a/sources/pyside6/tests/QtCore/hash_test.py
+++ b/sources/pyside6/tests/QtCore/hash_test.py
@@ -15,13 +15,17 @@ from PySide6.QtCore import QDate, QDateTime, QTime, QUrl
 from PySide6.QtCore import QLine, QPoint, QRect, QSize
 
 
+URL = "https://qt.io/"
+
+
 class HashTest(unittest.TestCase):
     def testInsert(self):
         myHash = {}
         qdate = QDate.currentDate()
         qdatetime = QDateTime.currentDateTime()
         qtime = QTime.currentTime()
-        qurl = QUrl("http://www.pyside.org")
+        qurl = QUrl(URL)
+        self.assertTrue(qurl.isValid())
         qpoint = QPoint(12, 42)
 
         myHash[qdate] = "QDate"
@@ -64,7 +68,34 @@ class HashTest(unittest.TestCase):
         self.assertEqual(l1, l2)
         self.assertEqual(hash(l1), hash(l2))
 
+    def testQTimeHash(self):
+        t1 = QTime(5, 5, 5)
+        t2 = QTime(5, 5, 5)
+        self.assertFalse(t1 is t2)
+        self.assertEqual(t1, t2)
+        self.assertEqual(hash(t1), hash(t2))
+
+    def testQDateHash(self):
+        d1 = QDate(1968, 3, 9)
+        d2 = QDate(1968, 3, 9)
+        self.assertFalse(d1 is d2)
+        self.assertEqual(d1, d2)
+        self.assertEqual(hash(d1), hash(d2))
+
+    def testQDateTimeHash(self):
+        d1 = QDateTime(QDate(1968, 3, 9), QTime(5, 5, 5))
+        d2 = QDateTime(QDate(1968, 3, 9), QTime(5, 5, 5))
+        self.assertFalse(d1 is d2)
+        self.assertEqual(d1, d2)
+        self.assertEqual(hash(d1), hash(d2))
+
+    def testQUrlHash(self):
+        u1 = QUrl(URL)
+        u2 = QUrl(URL)
+        self.assertFalse(u1 is u2)
+        self.assertEqual(u1, u2)
+        self.assertEqual(hash(u1), hash(u2))
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/QtCore/loggingcategorymacros_test.py b/sources/pyside6/tests/QtCore/loggingcategorymacros_test.py
index fa85d95ef..a808f0c3d 100644
--- a/sources/pyside6/tests/QtCore/loggingcategorymacros_test.py
+++ b/sources/pyside6/tests/QtCore/loggingcategorymacros_test.py
@@ -17,6 +17,7 @@ from PySide6.QtCore import (QLoggingCategory, QtMsgType, qCDebug, qCWarning, qCI
 
 param = None
 
+
 def handler(msgt, ctx, msg):
     global param
     param = ctx.category + ": " + msg.strip()
@@ -70,7 +71,6 @@ class TestQLoggingCategory(unittest.TestCase):
         qCWarning(self.criticalCategory, f"devices: {self.no_devices}")
         self.assertEqual(param, "warning.log: devices: 2")
 
-
     def test_qCritical(self):
         qCCritical(self.defaultCategory, "no device")
         self.assertEqual(param, "default: no device")
diff --git a/sources/pyside6/tests/QtCore/multiple_feature_test.py b/sources/pyside6/tests/QtCore/multiple_feature_test.py
index d9f4bb8b2..0f51ace6b 100644
--- a/sources/pyside6/tests/QtCore/multiple_feature_test.py
+++ b/sources/pyside6/tests/QtCore/multiple_feature_test.py
@@ -31,6 +31,11 @@ There is much more to come.
 MethodDescriptorType = type(str.split)
 
 
+def xprint(*args, **kw):
+    if "-v" in sys.argv:
+        print(*args, **kw)
+
+
 @unittest.skipIf(is_pypy, "__feature__ cannot yet be used with PyPy")
 class FeaturesTest(unittest.TestCase):
 
@@ -93,14 +98,14 @@ class FeaturesTest(unittest.TestCase):
         for idx in range(0x100):
             feature.reset()
             config = f"feature_{idx:02x}"
-            print()
-            print(f"--- Feature Test Config `{config}` ---")
-            print("Imports:")
+            xprint()
+            xprint(f"--- Feature Test Config `{config}` ---")
+            xprint("Imports:")
             for bit in range(8):
                 if idx & 1 << bit:
                     cur_feature = feature_list[bit]
                     text = f"from __feature__ import {cur_feature}"
-                    print(text)
+                    xprint(text)
                     eval(compile(text, "<string>", "exec"), globals(), edict)
             for bit in range(8):
                 value = idx & 1 << bit
diff --git a/sources/pyside6/tests/QtCore/qbytearray_test.py b/sources/pyside6/tests/QtCore/qbytearray_test.py
index c00674859..cb8f9a431 100644
--- a/sources/pyside6/tests/QtCore/qbytearray_test.py
+++ b/sources/pyside6/tests/QtCore/qbytearray_test.py
@@ -6,6 +6,7 @@
 import ctypes
 import os
 import pickle
+import struct
 import sys
 import unittest
 
@@ -15,7 +16,8 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 
-from PySide6.QtCore import QByteArray, QSettings, QObject, QDataStream, QIODevice
+from PySide6.QtCore import (QByteArray, QSettings, QObject, QDataStream,
+                            QIODevice, qCompress, qUncompress)
 
 
 class QByteArrayTestToNumber(unittest.TestCase):
@@ -255,6 +257,34 @@ class QByteArraySliceAssignment(unittest.TestCase):
         actual_bytes = bytes(byte_array)
         self.assertEqual(orig_bytes, actual_bytes)
 
+    def testUnpack(self):
+        b = QByteArray(b'\x19\x00\x00\x00\xc4\t\x00\x00')
+        t = struct.unpack('<ii', b)
+        self.assertEqual(len(t), 2)
+        self.assertEqual(t[0], 25)
+        self.assertEqual(t[1], 2500)
+
+
+class QCompressTest(unittest.TestCase):
+    def testQByteArrayCompression(self):
+        """Compress/uncompress a QByteArray."""
+        data = bytes(10 * 'long redundant sentence bla bla', "UTF8")
+        ba = QByteArray(data)
+        compressed = qCompress(ba)
+        self.assertTrue(len(compressed) < len(data))
+        uncompressed = qUncompress(compressed)
+        self.assertEqual(uncompressed, data)
+
+    def testBufferCompression(self):
+        """Compress/uncompress portions of bytes without converting to
+           QByteArray."""
+        data = bytes(10 * 'long redundant sentence bla bla', "UTF8")
+        used_len = int(len(data) / 2)
+        compressed = qCompress(data, used_len, -1)
+        self.assertTrue(len(compressed) < used_len)
+        uncompressed = qUncompress(compressed.data(), len(compressed))
+        self.assertEqual(uncompressed, data[:used_len])
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qcbor_test.py b/sources/pyside6/tests/QtCore/qcbor_test.py
index edcac6c4b..312c9e5c7 100644
--- a/sources/pyside6/tests/QtCore/qcbor_test.py
+++ b/sources/pyside6/tests/QtCore/qcbor_test.py
@@ -15,7 +15,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import (QByteArray, QCborStreamReader, QCborStreamWriter,
-    QCborTag, QCborValue)
+                            QCborTag, QCborValue)
 
 
 class TestCbor(unittest.TestCase):
@@ -56,11 +56,6 @@ class TestCbor(unittest.TestCase):
         value = QCborValue('hello')
         self.assertTrue(value.isString())
         self.assertEqual(value.toString(), 'hello')
-        if sys.pyside63_option_python_enum:
-            # PYSIDE-1735: Undefined enums are not possible
-            return
-        tag = value.tag(QCborTag(32))
-        self.assertEqual(int(tag), 32)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtCore/qdatastream_test.py b/sources/pyside6/tests/QtCore/qdatastream_test.py
index 9ec69076b..517f466aa 100644
--- a/sources/pyside6/tests/QtCore/qdatastream_test.py
+++ b/sources/pyside6/tests/QtCore/qdatastream_test.py
@@ -296,6 +296,16 @@ class QDataStreamBuffer(unittest.TestCase):
         data = QDataStream(ba)
         self.assertEqual(data.readRawData(4), bytes('AB\x00C', "UTF-8"))
 
+    def testRawDataBytes(self):
+        test_data = b'AB\0'
+        data = QDataStream()
+        ba = QByteArray()
+        data = QDataStream(ba, QIODevice.WriteOnly)
+        data.writeRawData(test_data)
+        self.assertEqual(ba.data(), test_data)
+        data = QDataStream(ba)
+        self.assertEqual(data.readRawData(3), test_data)
+
     def testBytes(self):
         dataOne = QDataStream()
         self.assertEqual(dataOne.readBytes(4), None)
diff --git a/sources/pyside6/tests/QtCore/qenum_test.py b/sources/pyside6/tests/QtCore/qenum_test.py
index adcdcbacd..45a8e9124 100644
--- a/sources/pyside6/tests/QtCore/qenum_test.py
+++ b/sources/pyside6/tests/QtCore/qenum_test.py
@@ -19,21 +19,6 @@ from PySide6.QtCore import Qt, QIODevice, QObject, QEnum, QFlag
 
 
 class TestEnum(unittest.TestCase):
-    @unittest.skipIf(sys.pyside63_option_python_enum, "not adequate for new enums to ask the value")
-    def testToInt(self):
-        self.assertEqual(QIODevice.NotOpen, 0)
-        self.assertEqual(QIODevice.ReadOnly, 1)
-        self.assertEqual(QIODevice.WriteOnly, 2)
-        self.assertEqual(QIODevice.ReadWrite, 1 | 2)
-        self.assertEqual(QIODevice.Append, 4)
-        self.assertEqual(QIODevice.Truncate, 8)
-        self.assertEqual(QIODevice.Text, 16)
-        self.assertEqual(QIODevice.Unbuffered, 32)
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "not adequate for new enums to ask the value")
-    def testToIntInFunction(self):
-        self.assertEqual(str(int(QIODevice.WriteOnly)), "2")
-
     def testOperations(self):
         k = Qt.Key.Key_1
 
@@ -42,24 +27,6 @@ class TestEnum(unittest.TestCase):
         self.assertEqual(k - 2, -(2 - k))
         self.assertEqual(k * 2, 2 * k)
 
-        if not sys.pyside63_option_python_enum:
-            # Floats work fine with new enums
-            with self.assertRaises(TypeError):
-                a = k + 2.0
-
-            with self.assertRaises(TypeError):
-                a = k - 2.0
-
-            with self.assertRaises(TypeError):
-                a = k * 2.0
-
-    @unittest.skipIf(sys.pyside63_option_python_enum, "inheritance forbidden for Python enums")
-    def testInherit(self):
-        class A(Qt.Key):
-            pass
-
-        self.assertEqual(A.Key_1, Qt.Key.Key_1)
-
     @unittest.skipUnless(getattr(sys, "getobjects", None), "requires --with-trace-refs")
     @unittest.skipUnless(getattr(sys, "gettotalrefcount", None), "requires --with-pydebug")
     def testEnumNew_NoLeak(self):
@@ -80,11 +47,10 @@ class TestEnum(unittest.TestCase):
 
 
 class TestQFlags(unittest.TestCase):
-    newenum = sys.pyside63_option_python_enum
 
     def testToItn(self):
         om = QIODevice.NotOpen
-        omcmp = om.value if self.newenum else om
+        omcmp = om.value
 
         self.assertEqual(om, QIODevice.NotOpen)
         self.assertTrue(omcmp == 0)
@@ -94,7 +60,7 @@ class TestQFlags(unittest.TestCase):
 
     def testToIntInFunction(self):
         om = QIODevice.WriteOnly
-        self.assertEqual(int(om.value if self.newenum else om), 2)
+        self.assertEqual(int(om.value), 2)
 
     def testNonExtensibleEnums(self):
         try:
diff --git a/sources/pyside6/tests/QtCore/qflags_test.py b/sources/pyside6/tests/QtCore/qflags_test.py
index 3b97e649f..2a5306685 100644
--- a/sources/pyside6/tests/QtCore/qflags_test.py
+++ b/sources/pyside6/tests/QtCore/qflags_test.py
@@ -112,18 +112,6 @@ class QFlagsOnQVariant(unittest.TestCase):
         self.assertEqual(type(o.property("foo")), QIODevice.OpenMode)
 
 
-class QFlagsWrongType(unittest.TestCase):
-    @unittest.skipIf(sys.pyside63_option_python_enum, "Qt.ItemFlag is no longer an IntEnum")
-    def testWrongType(self):
-        '''Wrong type passed to QFlags binary operators'''
-        for op in operator.or_, operator.and_, operator.xor:
-            for x in '43', 'jabba', QObject, object:
-                self.assertRaises(TypeError, op, Qt.NoItemFlags, x)
-                self.assertRaises(TypeError, op, x, Qt.NoItemFlags)
-        # making sure this actually does not fail all the time
-        self.assertEqual(operator.or_(Qt.NoItemFlags, 43), 43)
-
-
 class QEnumFlagDefault(unittest.TestCase):
     """
         Check that old flag and enum syntax can be used.
@@ -136,11 +124,7 @@ class QEnumFlagDefault(unittest.TestCase):
         oldEnum = Qt.AlignmentFlag()
         self.assertEqual(type(oldFlag), Qt.Alignment)
         self.assertEqual(type(oldEnum), Qt.AlignmentFlag)
-        if sys.pyside63_option_python_enum:
-            self.assertEqual(type(oldFlag), type(oldEnum))
-        else:
-            with self.assertRaises(AssertionError):
-                self.assertEqual(type(oldFlag), type(oldEnum))
+        self.assertEqual(type(oldFlag), type(oldEnum))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtCore/qiodevice_buffered_read_test.py b/sources/pyside6/tests/QtCore/qiodevice_buffered_read_test.py
new file mode 100644
index 000000000..ea735112a
--- /dev/null
+++ b/sources/pyside6/tests/QtCore/qiodevice_buffered_read_test.py
@@ -0,0 +1,78 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for buffered read methods of QIODevice'''
+
+from PySide6.QtCore import QBuffer
+
+import enum
+import unittest
+
+
+class TestQIODeviceBufferedRead(unittest.TestCase):
+    class TestType(enum.Enum):
+        Read = enum.auto()
+        ReadLine = enum.auto()
+        Peek = enum.auto()
+
+    def setUp(self) -> None:
+        self.buffer = QBuffer()
+        self.text = "Tomato juice\nPotato salad\n"
+
+        self.assertTrue(
+            self.buffer.open(QBuffer.OpenModeFlag.ReadWrite), self.buffer.errorString())
+        self.assertGreaterEqual(
+            self.buffer.write(self.text.encode("utf-8")), 0, self.buffer.errorString())
+
+        self.buffer.seek(0)
+
+    def tearDown(self) -> None:
+        self.buffer.close()
+
+    def test_read(self) -> None:
+        response1 = self.buffer.read(1024).data().decode("utf-8")
+        self.assertEqual(response1, self.text)
+
+        self.buffer.seek(0)
+        response2 = bytearray(1024)
+        bytes_read = self.buffer.read(response2, 1024)
+
+        self.assertGreaterEqual(bytes_read, 0, self.buffer.errorString())
+        self.assertEqual(response2[:bytes_read].decode("utf-8"), response1)
+
+    def test_readLine(self) -> None:
+        response1 = self.buffer.readLine(1024).data().decode("utf-8")
+        # Only read until the first line (including the line break)
+        self.assertEqual(response1, self.text.split("\n", 1)[0] + "\n")
+
+        self.buffer.seek(0)
+        response2 = bytearray(1024)
+        bytes_read = self.buffer.readLine(response2, 1024)
+
+        self.assertGreaterEqual(bytes_read, 0, self.buffer.errorString())
+        self.assertEqual(response2[:bytes_read].decode("utf-8"), response1)
+
+    def test_peek(self) -> None:
+        response1 = self.buffer.peek(1024).data().decode("utf-8")
+        self.assertEqual(response1, self.text)
+
+        # Test that peek has no side effects
+        response_again1 = self.buffer.read(1024).data().decode("utf-8")
+        self.assertEqual(response_again1, response1)
+
+        self.buffer.seek(0)
+        response2 = bytearray(1024)
+        bytes_read = self.buffer.peek(response2, 1024)
+
+        self.assertGreaterEqual(bytes_read, 0, self.buffer.errorString())
+        self.assertEqual(response2[:bytes_read].decode("utf-8"), response1)
+
+        # Test that peek has no side effects
+        response_again2 = bytearray(1024)
+        bytes_read_again2 = self.buffer.read(response_again2, 1024)
+        self.assertEqual(bytes_read, bytes_read_again2)
+        self.assertEqual(response_again2, response2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qiopipe_test.py b/sources/pyside6/tests/QtCore/qiopipe_test.py
new file mode 100644
index 000000000..53a6ba70a
--- /dev/null
+++ b/sources/pyside6/tests/QtCore/qiopipe_test.py
@@ -0,0 +1,36 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for the QIOPipe class'''
+
+from PySide6.QtCore import QIODevice, QIOPipe
+
+import unittest
+
+
+class QIOPipeTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.pipe = QIOPipe()
+        self.pipe.open(QIODevice.OpenModeFlag.ReadWrite)
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        super().tearDown()
+
+    def ready_read_bytes_written(self):
+        received_data = self.pipe.end2().readAll().data()
+        self.assertEqual(received_data, self.data)
+
+    def test_readyRead(self):
+        self.data = b"Hello, World!"
+        self.pipe.end2().readyRead.connect(self.ready_read_bytes_written)
+        self.pipe.end1().write(self.data)
+
+    def test_bytesWritten(self):
+        self.data = b"Hello, World!"
+        self.pipe.end2().bytesWritten.connect(self.ready_read_bytes_written)
+        self.pipe.end1().write(self.data)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qlocale_test.py b/sources/pyside6/tests/QtCore/qlocale_test.py
index 3d3425445..05b0d3219 100644
--- a/sources/pyside6/tests/QtCore/qlocale_test.py
+++ b/sources/pyside6/tests/QtCore/qlocale_test.py
@@ -37,6 +37,11 @@ class QLocaleTestToNumber(unittest.TestCase):
         self.assertEqual((ctypes.c_short(37).value, True),
                          obj.toShort('37'))
 
+    def testToNumberLong(self):
+        obj = QLocale(QLocale.C)
+        self.assertEqual((ctypes.c_long(37).value, True),
+                         obj.toLong('37'))
+
     def testToNumberULongLong(self):
         obj = QLocale(QLocale.C)
         self.assertEqual((ctypes.c_ulonglong(37).value, True),
@@ -52,6 +57,17 @@ class QLocaleTestToNumber(unittest.TestCase):
         value = en_locale.toCurrencyString(1234.56)
         self.assertEqual(value, "$1,234.56")
 
+    def testToString(self):
+        """PYSIDE-2168, check negative values"""
+        en_locale = QLocale("en_US")
+        value = en_locale.toString(-4)
+        self.assertEqual(value, "-4")
+        # Verify that large types (long long/double) are used.
+        value = en_locale.toString(3000000000)
+        self.assertEqual(value, "3,000,000,000")
+        value = en_locale.toString(10e40)
+        self.assertEqual(value, "1E+41")
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qlockfile_test.py b/sources/pyside6/tests/QtCore/qlockfile_test.py
index 106bca02a..6dca9235c 100644
--- a/sources/pyside6/tests/QtCore/qlockfile_test.py
+++ b/sources/pyside6/tests/QtCore/qlockfile_test.py
@@ -32,6 +32,9 @@ class TestQMessageAuthenticationCode (unittest.TestCase):
         lockFile = QLockFile(self._fileName)
         self.assertTrue(lockFile.lock())
         self.assertTrue(lockFile.isLocked())
+        lock_info = lockFile.getLockInfo();
+        self.assertEqual(len(lock_info), 3)
+        self.assertEqual(lock_info[0], os.getpid())
         lockFile.unlock()
 
 
diff --git a/sources/pyside6/tests/QtCore/qmetaobject_test.py b/sources/pyside6/tests/QtCore/qmetaobject_test.py
index ff320b050..4b3051711 100644
--- a/sources/pyside6/tests/QtCore/qmetaobject_test.py
+++ b/sources/pyside6/tests/QtCore/qmetaobject_test.py
@@ -13,8 +13,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import (QCoreApplication, QFile, QMetaObject, QObject,
-                            QModelIndex, QPoint, QTimer, QSemaphore,
+from PySide6.QtCore import (QCoreApplication, QFile, QMetaMethod, QMetaObject,
+                            QObject, QModelIndex, QPoint, QTimer, QSemaphore,
                             QStringListModel, Qt, Signal, Slot,
                             SIGNAL, Q_ARG, Q_RETURN_ARG)
 
@@ -105,15 +105,6 @@ class qmetaobject_test(unittest.TestCase):
 
         o.connect(o2, SIGNAL("bars()"), o.slot)
         self.assertTrue(o2.metaObject().indexOfMethod("bars()") > -1)
-        #self.assertTrue(o.metaObject().indexOfMethod("bar()") == -1)
-        #self.assertTrue(o.metaObject().indexOfMethod("slot()") > -1)
-
-        #slot_index = o.metaObject().indexOfMethod("slot()")
-
-        #o.connect(o, SIGNAL("foo()"), o2, SIGNAL("bar()"))
-        #signal_index = o.metaObject().indexOfMethod("foo()");
-
-        #self.assertTrue(slot_index != signal_index)
 
     # PYSIDE-784, plain Qt objects should not have intermediary
     # metaObjects.
@@ -125,7 +116,7 @@ class qmetaobject_test(unittest.TestCase):
     # PYSIDE-1827, slots with non-QObject object types should work
     # (metatypes are registered)
     def test_ObjectSlotSignal(self):
-        app = QCoreApplication()
+        app = QCoreApplication()  # noqa: F841
         sender = SemaphoreSender()
         receiver = SemaphoreReceiver()
         sender.signal.connect(receiver.receiverSlot, Qt.QueuedConnection)
@@ -143,6 +134,17 @@ class qmetaobject_test(unittest.TestCase):
                                        Q_ARG(int, 2), Q_ARG(int, 3))
         self.assertEqual(sum, 5)
 
+        # Same with QMetaMethod
+        mo = tester.metaObject()
+        method = mo.method(mo.indexOfMethod("add(int,int)"))
+        self.assertTrue(method.isValid())
+        sum = method.invoke(tester, Qt.ConnectionType.AutoConnection,
+                            Q_RETURN_ARG(int), Q_ARG(int, 2), Q_ARG(int, 3))
+        self.assertEqual(sum, 5)
+        sum = method.invoke(tester, Q_RETURN_ARG(int), Q_ARG(int, 2),
+                            Q_ARG(int, 3))
+        self.assertEqual(sum, 5)
+
         concatenated = QMetaObject.invokeMethod(tester, "concatenate",
                                                 Q_RETURN_ARG(str),
                                                 Q_ARG(str, "bla"),
@@ -190,6 +192,22 @@ class qmetaobject_test(unittest.TestCase):
                                  Q_ARG("QVariant", "bla"))
         self.assertEqual(model.data(index), "bla")
 
+        # Same with QMetaMethod
+        mo = model.metaObject()
+        method = mo.method(mo.indexOfMethod("setData(QModelIndex,QVariant)"))
+        self.assertTrue(method.isValid())
+        method.invoke(model, Qt.ConnectionType.AutoConnection,
+                      Q_ARG(QModelIndex, index), Q_ARG("QVariant", "blub"))
+        self.assertEqual(model.data(index), "blub")
+        method.invoke(model, Q_ARG(QModelIndex, index), Q_ARG("QVariant", "blip"))
+        self.assertEqual(model.data(index), "blip")
+
+    def test_QMetaMethod(self):
+        o = QObject()
+        m = QMetaMethod.fromSignal(o.destroyed)
+        self.assertTrue(m.isValid)
+        self.assertEqual(m.methodSignature(), b"destroyed()")
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qmimedatabase_test.py b/sources/pyside6/tests/QtCore/qmimedatabase_test.py
index 90c99edb4..6a63edb85 100644
--- a/sources/pyside6/tests/QtCore/qmimedatabase_test.py
+++ b/sources/pyside6/tests/QtCore/qmimedatabase_test.py
@@ -4,7 +4,6 @@
 
 '''Unit tests for QMimeDatabase'''
 
-import ctypes
 import os
 import sys
 import unittest
@@ -24,8 +23,7 @@ class QMimeDatabaseTest(unittest.TestCase):
         s0 = db.mimeTypeForName("application/x-zerosize")
         self.assertTrue(s0.isValid())
         self.assertEqual(s0.name(), "application/x-zerosize")
-        if "en" in QLocale().name():
-            self.assertEqual(s0.comment(), "empty document")
+        self.assertTrue(s0.comment())
 
         s0Again = db.mimeTypeForName("application/x-zerosize")
         self.assertEqual(s0Again.name(), s0.name())
@@ -40,13 +38,13 @@ class QMimeDatabaseTest(unittest.TestCase):
         rdf = db.mimeTypeForName("application/rdf+xml")
         self.assertTrue(rdf.isValid())
         self.assertEqual(rdf.name(), "application/rdf+xml")
+        self.assertTrue(rdf.comment())
         if "en" in QLocale().name():
             self.assertEqual(rdf.comment(), "RDF file")
 
         bzip2 = db.mimeTypeForName("application/x-bzip2")
         self.assertTrue(bzip2.isValid())
-        if "en" in QLocale().name():
-            self.assertEqual(bzip2.comment(), "Bzip archive")
+        self.assertTrue(bzip2.comment())
 
         defaultMime = db.mimeTypeForName("application/octet-stream")
         self.assertTrue(defaultMime.isValid())
diff --git a/sources/pyside6/tests/QtCore/qobject_connect_notify_test.py b/sources/pyside6/tests/QtCore/qobject_connect_notify_test.py
index 409b06c3c..b3bfaf007 100644
--- a/sources/pyside6/tests/QtCore/qobject_connect_notify_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_connect_notify_test.py
@@ -12,8 +12,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QObject, Signal, SIGNAL, SLOT
+from helper.usesqapplication import UsesQApplication
 
 
 def cute_slot():
@@ -21,6 +21,9 @@ def cute_slot():
 
 
 class Obj(QObject):
+
+    foo = Signal()
+
     def __init__(self):
         super().__init__()
         self.con_notified = False
@@ -39,49 +42,56 @@ class Obj(QObject):
         self.dis_notified = False
 
 
-class TestQObjectConnectNotify(UsesQCoreApplication):
+class TestQObjectConnectNotify(UsesQApplication):
     '''Test case for QObject::connectNotify'''
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.called = False
 
     def tearDown(self):
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testBasic(self):
         sender = Obj()
         receiver = QObject()
+        sender.destroyed.connect(receiver.deleteLater)
+        self.assertTrue(sender.con_notified)
+        self.assertEqual(sender.signal.methodSignature(), "destroyed()")
+        self.assertTrue(sender.destroyed.disconnect(receiver.deleteLater))
+        self.assertTrue(sender.dis_notified)
+
+    def testBasicString(self):
+        sender = Obj()
+        receiver = QObject()
         sender.connect(SIGNAL("destroyed()"), receiver, SLOT("deleteLater()"))
         self.assertTrue(sender.con_notified)
         # When connecting to a regular slot, and not a python callback function, QObject::connect
         # will use the non-cloned method signature, so connecting to destroyed() will actually
         # connect to destroyed(QObject*).
         self.assertEqual(sender.signal.methodSignature(), "destroyed(QObject*)")
-        sender.disconnect(SIGNAL("destroyed()"), receiver, SLOT("deleteLater()"))
+        self.assertTrue(sender.disconnect(SIGNAL("destroyed()"), receiver, SLOT("deleteLater()")))
         self.assertTrue(sender.dis_notified)
 
     def testPySignal(self):
         sender = Obj()
         receiver = QObject()
-        sender.connect(SIGNAL("foo()"), receiver, SLOT("deleteLater()"))
+        sender.foo.connect(receiver.deleteLater)
         self.assertTrue(sender.con_notified)
-        sender.disconnect(SIGNAL("foo()"), receiver, SLOT("deleteLater()"))
+        self.assertTrue(sender.foo.disconnect(receiver.deleteLater))
         self.assertTrue(sender.dis_notified)
 
     def testPySlots(self):
         sender = Obj()
-        receiver = QObject()
-        sender.connect(SIGNAL("destroyed()"), cute_slot)
+        sender.destroyed.connect(cute_slot)
         self.assertTrue(sender.con_notified)
-        sender.disconnect(SIGNAL("destroyed()"), cute_slot)
+        self.assertTrue(sender.destroyed.disconnect(cute_slot))
         self.assertTrue(sender.dis_notified)
 
     def testpyAll(self):
         sender = Obj()
-        receiver = QObject()
-        sender.connect(SIGNAL("foo()"), cute_slot)
+        sender.foo.connect(cute_slot)
         self.assertTrue(sender.con_notified)
-        sender.disconnect(SIGNAL("foo()"), cute_slot)
+        self.assertTrue(sender.foo.disconnect(cute_slot))
         self.assertTrue(sender.dis_notified)
 
 
diff --git a/sources/pyside6/tests/QtCore/qobject_event_filter_test.py b/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
index a2870221d..ab7a1b6ad 100644
--- a/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
@@ -16,7 +16,7 @@ init_test_paths(False)
 
 from PySide6.QtCore import QObject, QTimerEvent
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class FilterObject(QObject):
@@ -63,14 +63,25 @@ class FilteredObject(QObject):
             self.app.quit()
 
 
-class TestQObjectEventFilterPython(UsesQCoreApplication):
+class PolymorphicIdFilterObject(QObject):
+    """PYSIDE-2675: Check whether QChildEvent.added() is accessible via PolymorphicId"""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.added = False
+
+    def event(self, event):
+        self.added = event.added()
+        return False
+
+
+class TestQObjectEventFilterPython(UsesQApplication):
     '''QObject.eventFilter - Reimplemented in python
     Filters 5 TimerEvents and then bypasses the other events to the
     timerEvent method. After 5 runs, the timerEvent method will ask
     the core application to exit'''
     def setUp(self):
         # Acquire resources
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.obj_filter = FilterObject(event_type=QTimerEvent)
 
     def tearDown(self):
@@ -78,7 +89,7 @@ class TestQObjectEventFilterPython(UsesQCoreApplication):
         del self.obj_filter
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testEventFilter(self):
         # QObject.eventFilter reimplemented in python
@@ -93,6 +104,11 @@ class TestQObjectEventFilterPython(UsesQCoreApplication):
         self.assertEqual(filtered.times_called, 5)
         self.assertEqual(self.obj_filter.events_handled, 5)
 
+    def testPolymorphicId(self):
+        testObject = PolymorphicIdFilterObject()
+        t2 = QObject(testObject)  # noqa: F841
+        self.assertTrue(testObject.added)
+
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testInstallEventFilterRefCountAfterDelete(self):
         '''Bug 910 - installEventFilter() increments reference count on target object
diff --git a/sources/pyside6/tests/QtCore/qobject_parent_test.py b/sources/pyside6/tests/QtCore/qobject_parent_test.py
index 160426b01..6265f77b1 100644
--- a/sources/pyside6/tests/QtCore/qobject_parent_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_parent_test.py
@@ -105,10 +105,9 @@ class ParentCase(unittest.TestCase):
         for i, child in enumerate(children):
             self.assertEqual(child, parent.findChild(QObject, f'object{i}'))
 
-
     def testFindChildOptions(self):
         parent = QObject()
-        child  = QObject(parent)
+        child = QObject(parent)
         nested_child_name = 'nestedChild'
         nested_child = QObject(child)
         nested_child.setObjectName(nested_child_name)
diff --git a/sources/pyside6/tests/QtCore/qobject_timer_event_test.py b/sources/pyside6/tests/QtCore/qobject_timer_event_test.py
index f93d036b4..9e657c27f 100644
--- a/sources/pyside6/tests/QtCore/qobject_timer_event_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_timer_event_test.py
@@ -15,7 +15,7 @@ init_test_paths(False)
 
 from PySide6.QtCore import QObject, QCoreApplication
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class Dummy(QObject):
@@ -34,7 +34,7 @@ class Dummy(QObject):
             self.app.exit(0)
 
 
-class QObjectTimerEvent(UsesQCoreApplication):
+class QObjectTimerEvent(UsesQApplication):
 
     def setUp(self):
         # Acquire resources
diff --git a/sources/pyside6/tests/QtCore/qobject_tr_as_instance_test.py b/sources/pyside6/tests/QtCore/qobject_tr_as_instance_test.py
index 83e8ae1af..9123c5155 100644
--- a/sources/pyside6/tests/QtCore/qobject_tr_as_instance_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_tr_as_instance_test.py
@@ -17,7 +17,7 @@ init_test_paths(False)
 
 from PySide6.QtCore import QObject
 
-#from helper.usesqcoreapplication import UsesQCoreApplication
+#from helper.usesqapplication import UsesQApplication
 
 
 class QObjectTrTest(unittest.TestCase):
diff --git a/sources/pyside6/tests/QtCore/qresource_test.py b/sources/pyside6/tests/QtCore/qresource_test.py
index 67285adcc..1cdd2c785 100644
--- a/sources/pyside6/tests/QtCore/qresource_test.py
+++ b/sources/pyside6/tests/QtCore/qresource_test.py
@@ -31,7 +31,7 @@ class ResourcesUsage(unittest.TestCase):
             if carriage_return != -1:
                 orig.remove(carriage_return, 1)
 
-        f = QFile(':/quote.txt')  #|QIODevice.Text
+        f = QFile(':/quote.txt')  # |QIODevice.Text
         self.assertTrue(f.open(QIODevice.ReadOnly), f.errorString())
         copy = f.readAll()
         f.close()
diff --git a/sources/pyside6/tests/QtCore/qrunnable_test.py b/sources/pyside6/tests/QtCore/qrunnable_test.py
new file mode 100644
index 000000000..d52f50ce1
--- /dev/null
+++ b/sources/pyside6/tests/QtCore/qrunnable_test.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+'''Test cases for QRunnable'''
+
+import os
+import sys
+import unittest
+from io import StringIO
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtCore import QCoreApplication, QRunnable, QThreadPool, QThread, qDebug
+from helper.usesqapplication import UsesQApplication
+test_result = ""
+
+
+def check_test():
+    global test_result
+    test_result = "test works"
+
+
+class QRunnableTest(UsesQApplication):
+    def testCreateWithAutoDelete(self):
+        global test_result
+        test_result = ""  # reset
+        runnable = QRunnable.create(check_test)
+        runnable.run()
+        self.assertEqual(test_result, "test works")
+
+    def testwithQThreadPool(self):
+        global test_result
+        test_result = ""  # reset
+        runnable = QRunnable.create(check_test)
+        tp = QThreadPool.globalInstance()
+        tp.start(runnable)
+        self.assertTrue(tp.waitForDone())
+        self.assertEqual(test_result, "test works")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/qsettings_test.py b/sources/pyside6/tests/QtCore/qsettings_test.py
index 5bae79355..64ceffd70 100644
--- a/sources/pyside6/tests/QtCore/qsettings_test.py
+++ b/sources/pyside6/tests/QtCore/qsettings_test.py
@@ -51,8 +51,12 @@ class TestQSettings(unittest.TestCase):
         self.assertTrue(dir.isValid())
         file_name = dir.filePath('foo.ini')
         settings = QSettings(file_name, QSettings.IniFormat)
+        sample_list = ["a", "b"]
+        string_list_of_empty = [""]
         settings.setValue('zero_value', 0)
         settings.setValue('empty_list', [])
+        settings.setValue('some_strings', sample_list)
+        settings.setValue('string_list_of_empty', string_list_of_empty)
         settings.setValue('bool1', False)
         settings.setValue('bool2', True)
         del settings
@@ -66,6 +70,10 @@ class TestQSettings(unittest.TestCase):
         r = settings.value("variable")
         self.assertEqual(type(r), type(None))
 
+        r = settings.value("variable", type=list)
+        self.assertEqual(type(r), list)
+        self.assertEqual(len(r), 0)
+
         # Handling zero value
         r = settings.value('zero_value')
         self.assertEqual(type(r), int)
@@ -82,6 +90,15 @@ class TestQSettings(unittest.TestCase):
         self.assertTrue(len(r) == 0)
         self.assertEqual(type(r), list)
 
+        r = settings.value('some_strings')
+        self.assertEqual(r, sample_list)
+
+        r = settings.value('some_strings', type=list)
+        self.assertEqual(r, sample_list)
+
+        r = settings.value('string_list_of_empty', type=list)
+        self.assertEqual(r, string_list_of_empty)
+
         # Booleans
         r = settings.value('bool1')
         self.assertEqual(type(r), bool)
diff --git a/sources/pyside6/tests/QtCore/qslot_object_test.py b/sources/pyside6/tests/QtCore/qslot_object_test.py
index 061ce9160..a95afb090 100644
--- a/sources/pyside6/tests/QtCore/qslot_object_test.py
+++ b/sources/pyside6/tests/QtCore/qslot_object_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QCoreApplication, QObject, QTimer, SIGNAL, SLOT
+from PySide6.QtCore import QCoreApplication, QObject, QTimer
 
 """
 This is a simple slot test that was updated to use the qApp "macro".
@@ -28,24 +28,23 @@ class objTest(QObject):
 
     def slot(self):
         self.ok = True
-        qApp.quit()
+        qApp.quit()  # noqa: F821
 
 
 class slotTest(unittest.TestCase):
     def quit_app(self):
-        qApp.quit()
+        qApp.quit()  # noqa: F821
 
     def testBasic(self):
         timer = QTimer()
         timer.setInterval(100)
 
         my_obj = objTest()
-        my_slot = SLOT("slot()")
-        QObject.connect(timer, SIGNAL("timeout()"), my_obj, my_slot)
+        timer.timeout.connect(my_obj.slot)
         timer.start(100)
 
         QTimer.singleShot(1000, self.quit_app)
-        qApp.exec()
+        qApp.exec()  # noqa: F821
 
         self.assertTrue(my_obj.ok)
 
diff --git a/sources/pyside6/tests/QtCore/qsysinfo_test.py b/sources/pyside6/tests/QtCore/qsysinfo_test.py
index a25f7d115..602852fab 100644
--- a/sources/pyside6/tests/QtCore/qsysinfo_test.py
+++ b/sources/pyside6/tests/QtCore/qsysinfo_test.py
@@ -14,15 +14,14 @@ from PySide6.QtCore import QSysInfo
 
 
 class TestQSysInfo(unittest.TestCase):
-    newenum = sys.pyside63_option_python_enum
 
     def testEnumEndian(self):
-        self.assertEqual(QSysInfo.BigEndian.value if self.newenum else QSysInfo.BigEndian, 0)
-        self.assertEqual(QSysInfo.LittleEndian.value if self.newenum else QSysInfo.LittleEndian, 1)
-        self.assertTrue((QSysInfo.ByteOrder.value if self.newenum else QSysInfo.ByteOrder) > -1)
+        self.assertEqual(QSysInfo.BigEndian.value, 0)
+        self.assertEqual(QSysInfo.LittleEndian.value, 1)
+        self.assertTrue(QSysInfo.ByteOrder.value > -1)
 
     def testEnumSizes(self):
-        self.assertTrue((QSysInfo.WordSize.value if self.newenum else QSysInfo.WordSize) > 0)
+        self.assertTrue(QSysInfo.WordSize.value > 0)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtCore/qthread_test.py b/sources/pyside6/tests/QtCore/qthread_test.py
index d81d36db0..4d26e0597 100644
--- a/sources/pyside6/tests/QtCore/qthread_test.py
+++ b/sources/pyside6/tests/QtCore/qthread_test.py
@@ -16,7 +16,7 @@ init_test_paths(False)
 from PySide6.QtCore import QThread, QCoreApplication, QObject, QTimer, Slot
 from PySide6.QtCore import QEventLoop
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class Dummy(QThread):
@@ -31,10 +31,10 @@ class Dummy(QThread):
         self.called = True
 
 
-class QThreadSimpleCase(UsesQCoreApplication):
+class QThreadSimpleCase(UsesQApplication):
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self._started_called = False
         self._finished_called = False
         self.called = False
diff --git a/sources/pyside6/tests/QtCore/qtimer_singleshot_test.py b/sources/pyside6/tests/QtCore/qtimer_singleshot_test.py
index e702f4792..2ccaa300e 100644
--- a/sources/pyside6/tests/QtCore/qtimer_singleshot_test.py
+++ b/sources/pyside6/tests/QtCore/qtimer_singleshot_test.py
@@ -14,8 +14,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, QTimer, QCoreApplication, Signal
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QObject, QThread, QTimer, Signal, Slot, SLOT
+from helper.usesqapplication import UsesQApplication
 
 
 class WatchDog(QObject):
@@ -32,14 +32,28 @@ class WatchDog(QObject):
             self.watched.exit_app_cb()
 
 
-class TestSingleShot(UsesQCoreApplication):
+class ThreadForContext(QThread):
+    def __init__(self):
+        super().__init__()
+        self.called = False
+        self.qthread = None
+        self.context = QObject()
+
+    def run(self):
+        self.called = True
+        self.qthread = QThread.currentThread()
+        self.exec()
+
+
+class TestSingleShot(UsesQApplication):
     '''Test case for QTimer.singleShot'''
 
     def setUp(self):
         # Acquire resources
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.watchdog = WatchDog(self)
         self.called = False
+        self.qthread = None
 
     def tearDown(self):
         # Release resources
@@ -47,10 +61,12 @@ class TestSingleShot(UsesQCoreApplication):
         del self.called
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def callback(self):
         self.called = True
+        self.qthread = QThread.currentThread()
+        self.qthread.exit()
         self.app.quit()
 
     def testSingleShot(self):
@@ -58,17 +74,94 @@ class TestSingleShot(UsesQCoreApplication):
         self.app.exec()
         self.assertTrue(self.called)
 
+    def testSingleShotZero(self):
+        QTimer.singleShot(0, self.callback)
+        self.app.exec()
+        self.assertTrue(self.called)
+
+    def testSingleShotWithContext(self):
+        thread = ThreadForContext()
+        thread.start()
+        thread.context.moveToThread(thread)
+        QTimer.singleShot(100, thread.context, self.callback)
+        self.app.exec()
+        thread.wait()
+        self.assertTrue(self.called)
+        self.assertTrue(thread.called)
+        self.assertEqual(self.qthread, thread.qthread)
+
+    def testSingleShotWithContextZero(self):
+        thread = ThreadForContext()
+        thread.start()
+        thread.context.moveToThread(thread)
+        QTimer.singleShot(0, thread.context, self.callback)
+        self.app.exec()
+        thread.wait()
+        self.assertTrue(self.called)
+        self.assertTrue(thread.called)
+        self.assertEqual(self.qthread, thread.qthread)
+
+
+class TestSingleShotCallableObject(UsesQApplication):
+    '''Test case for QTimer.singleShot with callable inside an object'''
+
+    def setUp(self):
+        # Acquire resources
+        UsesQApplication.setUp(self)
+        self.watchdog = WatchDog(self)
+
+    def tearDown(self):
+        # Release resources
+        del self.watchdog
+        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
+        gc.collect()
+        UsesQApplication.tearDown(self)
+
+    class CallbackObject(QObject):
+        def __init__(self, app) -> None:
+            super().__init__()
+            self.app = app
+
+        @Slot()
+        def func(self):
+            self.called = True
+            self.app.quit()
+
+    def testSingleShotWithObjectAndMember(self):
+        callback = self.CallbackObject(self.app)
+        QTimer.singleShot(100, callback, SLOT("func()"))
+        self.app.exec()
+        self.assertTrue(callback.called)
+
+    def testSingleShotWithObjectAndMemberZero(self):
+        callback = self.CallbackObject(self.app)
+        QTimer.singleShot(0, callback, SLOT("func()"))
+        self.app.exec()
+        self.assertTrue(callback.called)
+
+    def testSingleShotWithCallableInObject(self):
+        callback = self.CallbackObject(self.app)
+        QTimer.singleShot(100, callback.func)
+        self.app.exec()
+        self.assertTrue(callback.called)
+
+    def testSingleShotWithCallableInObjectZero(self):
+        callback = self.CallbackObject(self.app)
+        QTimer.singleShot(0, callback.func)
+        self.app.exec()
+        self.assertTrue(callback.called)
+
 
 class SigEmitter(QObject):
 
     sig1 = Signal()
 
 
-class TestSingleShotSignal(UsesQCoreApplication):
+class TestSingleShotSignal(UsesQApplication):
     '''Test case for QTimer.singleShot connecting to signals'''
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.watchdog = WatchDog(self)
         self.called = False
 
@@ -77,7 +170,7 @@ class TestSingleShotSignal(UsesQCoreApplication):
         del self.called
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def callback(self):
         self.called = True
@@ -90,7 +183,13 @@ class TestSingleShotSignal(UsesQCoreApplication):
         self.app.exec()
         self.assertTrue(self.called)
 
+    def testSingleShotSignalZero(self):
+        emitter = SigEmitter()
+        emitter.sig1.connect(self.callback)
+        QTimer.singleShot(0, emitter.sig1)
+        self.app.exec()
+        self.assertTrue(self.called)
+
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/QtCore/qtimer_timeout_test.py b/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
index b853ee85d..70f151989 100644
--- a/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
+++ b/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
@@ -14,7 +14,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, QTimer, SIGNAL
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class WatchDog(QObject):
@@ -31,12 +31,12 @@ class WatchDog(QObject):
             self.watched.exit_app_cb()
 
 
-class TestTimeoutSignal(UsesQCoreApplication):
+class TestTimeoutSignal(UsesQApplication):
     '''Test case to check if the signals are really being caught'''
 
     def setUp(self):
         # Acquire resources
-        UsesQCoreApplication.setUp(self)
+        super().setUp()
         self.watchdog = WatchDog(self)
         self.timer = QTimer()
         self.called = False
@@ -48,7 +48,7 @@ class TestTimeoutSignal(UsesQCoreApplication):
         del self.called
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        super().tearDown()
 
     def callback(self, *args):
         # Default callback
diff --git a/sources/pyside6/tests/QtCore/signal_sender.py b/sources/pyside6/tests/QtCore/signal_sender.py
new file mode 100644
index 000000000..2552591e5
--- /dev/null
+++ b/sources/pyside6/tests/QtCore/signal_sender.py
@@ -0,0 +1,91 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from helper.usesqapplication import UsesQApplication
+
+from PySide6.QtCore import (QCoreApplication, QObject, QStringListModel,
+                            QTimer, Signal, Slot, Qt)
+
+
+class Sender(QObject):
+    testSignal = Signal()
+
+    def emitSignal(self):
+        self.testSignal.emit()
+
+
+class Receiver(QObject):
+
+    def __init__(self, parent=None):
+        super().__init__()
+        self._sender = None
+        self._slot_count = 0
+
+    @Slot()
+    def testSlot(self):
+        self._sender = self.sender()
+        self._slot_count += 1
+
+
+class DerivedReceiver(Receiver):
+    pass
+
+
+class TestSignalSender(UsesQApplication):
+    """Test PYSIDE-2144/1295, check that QObject::sender() works also if it is
+       routed via GlobalReceiverV2 in case of a non-C++ slot (Python callback,
+       as for derived classes)."""
+    def testSignalSender(self):
+        sender = Sender()
+        receiver = Receiver()
+        sender.testSignal.connect(receiver.testSlot)
+        derived_receiver = DerivedReceiver()
+        sender.testSignal.connect(derived_receiver.testSlot)
+        sender.emitSignal()
+
+        QTimer.singleShot(100, self.app.quit)
+        while derived_receiver._slot_count == 0:
+            QCoreApplication.processEvents()
+
+        self.assertEqual(receiver._sender, sender)
+        self.assertEqual(derived_receiver._sender, sender)
+
+
+class TestConstructorConnection(UsesQApplication):
+    """PYSIDE-2329: Check constructor connections for signals from the
+       base as well as signals with arguments."""
+    def testConstructorConnection(self):
+
+        was_destroyed = False
+        was_changed = False
+
+        def destroyed_handler():
+            nonlocal was_destroyed
+            was_destroyed = True
+
+        def changed_handler():
+            nonlocal was_changed
+            was_changed = True
+
+        data_list = ["blub"]
+        model = QStringListModel(data_list,
+                                 destroyed=destroyed_handler,
+                                 dataChanged=changed_handler)
+        model.setData(model.index(0, 0), "bla", Qt.EditRole)
+        del model
+
+        self.assertTrue(was_changed)
+        self.assertTrue(was_destroyed)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtCore/snake_prop_feature_test.py b/sources/pyside6/tests/QtCore/snake_prop_feature_test.py
index 4178c7a10..82087ab9a 100644
--- a/sources/pyside6/tests/QtCore/snake_prop_feature_test.py
+++ b/sources/pyside6/tests/QtCore/snake_prop_feature_test.py
@@ -60,7 +60,7 @@ class FeatureTest(unittest.TestCase):
             window.modal
 
         from __feature__ import snake_case, true_property
-        #PYSIDE-1548: Make sure that another import does not clear the features.
+        # PYSIDE-1548: Make sure that another import does not clear the features.
         import sys
 
         self.assertTrue(isinstance(QWidget.modal, property))
diff --git a/sources/pyside6/tests/QtCore/thread_signals_test.py b/sources/pyside6/tests/QtCore/thread_signals_test.py
index 80cda6b92..a453d1ac1 100644
--- a/sources/pyside6/tests/QtCore/thread_signals_test.py
+++ b/sources/pyside6/tests/QtCore/thread_signals_test.py
@@ -12,17 +12,19 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, QFile, QThread, QTimer, Qt
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import Signal, QThread
+from helper.usesqapplication import UsesQApplication
 
 
 class MyThread(QThread):
 
+    test = Signal(str)
+
     def run(self):
-        self.emit(SIGNAL("test(const QString&)"), "INdT - PySide")
+        self.test.emit("INdT - PySide")
 
 
-class TestThreadSignal(UsesQCoreApplication):
+class TestThreadSignal(UsesQApplication):
 
     __called__ = True
 
@@ -33,7 +35,7 @@ class TestThreadSignal(UsesQCoreApplication):
 
     def testThread(self):
         t = MyThread()
-        QObject.connect(t, SIGNAL("test(const QString&)"), self._callback)
+        t.test.connect(self._callback)
         t.start()
 
         self.app.exec()
diff --git a/sources/pyside6/tests/QtCore/translation_test.py b/sources/pyside6/tests/QtCore/translation_test.py
index aad0ce7c8..da09e47b6 100644
--- a/sources/pyside6/tests/QtCore/translation_test.py
+++ b/sources/pyside6/tests/QtCore/translation_test.py
@@ -15,10 +15,10 @@ init_test_paths(False)
 
 from PySide6.QtCore import QObject, QTranslator, QCoreApplication
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class TranslationTest(UsesQCoreApplication):
+class TranslationTest(UsesQApplication):
     '''Test case for Qt translation facilities.'''
 
     def setUp(self):
diff --git a/sources/pyside6/tests/QtDBus/CMakeLists.txt b/sources/pyside6/tests/QtDBus/CMakeLists.txt
index bb0e17e04..bf2d2105a 100644
--- a/sources/pyside6/tests/QtDBus/CMakeLists.txt
+++ b/sources/pyside6/tests/QtDBus/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 if(ENABLE_UNIX)
     PYSIDE_TEST(test_dbus.py)
 endif()
diff --git a/sources/pyside6/tests/QtDBus/test_dbus.py b/sources/pyside6/tests/QtDBus/test_dbus.py
index 6b6a892dd..a37db9421 100644
--- a/sources/pyside6/tests/QtDBus/test_dbus.py
+++ b/sources/pyside6/tests/QtDBus/test_dbus.py
@@ -12,7 +12,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 import sys
 from PySide6.QtCore import QCoreApplication
@@ -32,7 +32,7 @@ def service_names():
     return reply.value()
 
 
-class TestDBus(UsesQCoreApplication):
+class TestDBus(UsesQApplication):
     '''Simple Test case for QDBus'''
 
     def test_service_names(self):
diff --git a/sources/pyside6/tests/QtDataVisualization/datavisualization_test.py b/sources/pyside6/tests/QtDataVisualization/datavisualization_test.py
index 88d1bda75..98ada6d47 100644
--- a/sources/pyside6/tests/QtDataVisualization/datavisualization_test.py
+++ b/sources/pyside6/tests/QtDataVisualization/datavisualization_test.py
@@ -13,7 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QTimer
 from PySide6.QtDataVisualization import (Q3DBars, QBar3DSeries, QBarDataItem,
                                          QBarDataProxy, QCategory3DAxis,
@@ -35,7 +35,7 @@ def dataToBarDataArray(data):
     return result
 
 
-class QtDataVisualizationTestCase(UsesQGuiApplication):
+class QtDataVisualizationTestCase(UsesQApplication):
     '''Tests related to QtDataVisualization'''
 
     def testBars(self):
@@ -82,8 +82,8 @@ class QtDataVisualizationTestCase(UsesQGuiApplication):
         self.assertTrue(data_proxy.rowCount(), 4)
 
     def testDefaultSurfaceFormat(self):
-         format = qDefaultSurfaceFormat(True)
-         print(format)
+        format = qDefaultSurfaceFormat(True)
+        print(format)
 
     def testQValue3DAxisFormatter(self):
         """PYSIDE-2025: Test the added setters of QValue3DAxisFormatter."""
diff --git a/sources/pyside6/tests/QtGraphs/CMakeLists.txt b/sources/pyside6/tests/QtGraphs/CMakeLists.txt
new file mode 100644
index 000000000..2f7cb08b9
--- /dev/null
+++ b/sources/pyside6/tests/QtGraphs/CMakeLists.txt
@@ -0,0 +1 @@
+# Please add some tests, here
diff --git a/sources/pyside6/tests/QtGui/CMakeLists.txt b/sources/pyside6/tests/QtGui/CMakeLists.txt
index c5b0c473c..71a5c7eb9 100644
--- a/sources/pyside6/tests/QtGui/CMakeLists.txt
+++ b/sources/pyside6/tests/QtGui/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 #Keep this in alphabetical sort
 
 PYSIDE_TEST(bug_367.py)
diff --git a/sources/pyside6/tests/QtGui/bug_367.py b/sources/pyside6/tests/QtGui/bug_367.py
index facf9179c..771fa5a4b 100644
--- a/sources/pyside6/tests/QtGui/bug_367.py
+++ b/sources/pyside6/tests/QtGui/bug_367.py
@@ -12,11 +12,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QStandardItem, QStandardItemModel
 
 
-class BugTest(UsesQGuiApplication):
+class BugTest(UsesQApplication):
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCase(self):
         model = QStandardItemModel()
diff --git a/sources/pyside6/tests/QtGui/bug_617.py b/sources/pyside6/tests/QtGui/bug_617.py
index 59b1a9a4a..d90d1e754 100644
--- a/sources/pyside6/tests/QtGui/bug_617.py
+++ b/sources/pyside6/tests/QtGui/bug_617.py
@@ -27,8 +27,7 @@ class Bug617(unittest.TestCase):
 
     def testOutOfBounds(self):
         e = MyEvent()
-        self.assertEqual(repr(e.type()), "<Type.999: 999>"
-            if sys.pyside63_option_python_enum else "PySide6.QtCore.QEvent.Type(999)")
+        self.assertEqual(repr(e.type()), "<Type.999: 999>")
 
 
 if __name__ == "__main__":
diff --git a/sources/pyside6/tests/QtGui/bug_740.py b/sources/pyside6/tests/QtGui/bug_740.py
index c88c48069..ece314cc8 100644
--- a/sources/pyside6/tests/QtGui/bug_740.py
+++ b/sources/pyside6/tests/QtGui/bug_740.py
@@ -10,12 +10,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QSize
 from PySide6.QtGui import QBitmap, QImage
 
 
-class TestQBitmap(UsesQGuiApplication):
+class TestQBitmap(UsesQApplication):
     def testFromDataMethod(self):
         dataBits = bytes('\x38\x28\x38\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\xfe\xfe\x7c\x7c\x38\x38\x10\x10', "UTF-8")
         bim = QBitmap.fromData(QSize(8, 48), dataBits, QImage.Format_Mono)  # missing function
diff --git a/sources/pyside6/tests/QtGui/event_filter_test.py b/sources/pyside6/tests/QtGui/event_filter_test.py
index c26e74926..01d8fbc02 100644
--- a/sources/pyside6/tests/QtGui/event_filter_test.py
+++ b/sources/pyside6/tests/QtGui/event_filter_test.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QObject, QEvent
 from PySide6.QtGui import QWindow
 
@@ -22,7 +22,7 @@ class MyFilter(QObject):
         return QObject.eventFilter(self, obj, event)
 
 
-class EventFilter(UsesQGuiApplication):
+class EventFilter(UsesQApplication):
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         o = QObject()
diff --git a/sources/pyside6/tests/QtGui/float_to_int_implicit_conversion_test.py b/sources/pyside6/tests/QtGui/float_to_int_implicit_conversion_test.py
index f06c6177b..ba438f8e0 100644
--- a/sources/pyside6/tests/QtGui/float_to_int_implicit_conversion_test.py
+++ b/sources/pyside6/tests/QtGui/float_to_int_implicit_conversion_test.py
@@ -15,10 +15,10 @@ init_test_paths(False)
 
 from PySide6.QtGui import QImage, qRgb
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class SetPixelFloat(UsesQGuiApplication):
+class SetPixelFloat(UsesQApplication):
     '''Test case for calling setPixel with float as argument'''
 
     def setUp(self):
diff --git a/sources/pyside6/tests/QtGui/qbrush_test.py b/sources/pyside6/tests/QtGui/qbrush_test.py
index ca685b9b6..69262328b 100644
--- a/sources/pyside6/tests/QtGui/qbrush_test.py
+++ b/sources/pyside6/tests/QtGui/qbrush_test.py
@@ -13,12 +13,12 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import Qt
-from PySide6.QtGui import QColor, QBrush
+from PySide6.QtGui import QColor, QBrush, QConicalGradient
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class Constructor(UsesQGuiApplication):
+class Constructor(UsesQApplication):
     '''Test case for constructor of QBrush'''
 
     def testQColor(self):
@@ -30,6 +30,14 @@ class Constructor(UsesQGuiApplication):
         obj = QBrush(Qt.blue)
         self.assertEqual(obj.color(), Qt.blue)
 
+    def testGradient(self):
+        """Test type discovery on class hierarchies with non-virtual
+           destructors by specifying a polymorphic-id-expression without
+           polymorphic-name-function."""
+        gradient = QConicalGradient()
+        brush = QBrush(gradient)
+        self.assertEqual(type(brush.gradient()), type(gradient))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtGui/qcolor_test.py b/sources/pyside6/tests/QtGui/qcolor_test.py
index 336d58f8e..bbd558f10 100644
--- a/sources/pyside6/tests/QtGui/qcolor_test.py
+++ b/sources/pyside6/tests/QtGui/qcolor_test.py
@@ -41,7 +41,7 @@ class QColorGetTest(unittest.TestCase):
 
     def testGetCmykF(self):  # not supported by colorsys
         for x, y in zip(self.color.getCmykF(), (170 / 255.0, 85 / 255.0, 0, 195 / 255.0, 80 / 255.0)):
-            self.assertTrue(x - y < 1/10000.0)
+            self.assertTrue(x - y < 1 / 10000.0)
 
 
 class QColorQRgbConstructor(unittest.TestCase):
diff --git a/sources/pyside6/tests/QtGui/qcursor_test.py b/sources/pyside6/tests/QtGui/qcursor_test.py
index 6a540d73e..1494fe370 100644
--- a/sources/pyside6/tests/QtGui/qcursor_test.py
+++ b/sources/pyside6/tests/QtGui/qcursor_test.py
@@ -15,10 +15,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtGui import QBitmap, QCursor, QPixmap
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class TestQCursor(UsesQGuiApplication):
+class TestQCursor(UsesQApplication):
     def testQCursorConstructor(self):
         bmp = QBitmap(16, 16)
         cursor = QCursor(bmp, bmp, 16, 16)
diff --git a/sources/pyside6/tests/QtGui/qdatastream_gui_operators_test.py b/sources/pyside6/tests/QtGui/qdatastream_gui_operators_test.py
index 5687fba87..f2c86abf7 100644
--- a/sources/pyside6/tests/QtGui/qdatastream_gui_operators_test.py
+++ b/sources/pyside6/tests/QtGui/qdatastream_gui_operators_test.py
@@ -13,10 +13,10 @@ init_test_paths(False)
 from PySide6.QtCore import QDataStream, QByteArray, QIODevice, Qt
 from PySide6.QtGui import QPixmap, QColor
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QPixmapQDatastream(UsesQGuiApplication):
+class QPixmapQDatastream(UsesQApplication):
     '''QDataStream <<>> QPixmap'''
 
     def setUp(self):
diff --git a/sources/pyside6/tests/QtGui/qfont_test.py b/sources/pyside6/tests/QtGui/qfont_test.py
index b6eeb27f3..f81d47ec6 100644
--- a/sources/pyside6/tests/QtGui/qfont_test.py
+++ b/sources/pyside6/tests/QtGui/qfont_test.py
@@ -11,10 +11,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtGui import QFont
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QFontTest(UsesQGuiApplication):
+class QFontTest(UsesQApplication):
 
     def testStringConstruction(self):
         """PYSIDE-1685: Test that passing str to QFont works after addding
diff --git a/sources/pyside6/tests/QtGui/qfontmetrics_test.py b/sources/pyside6/tests/QtGui/qfontmetrics_test.py
index 069a41f7d..98c4c8f96 100644
--- a/sources/pyside6/tests/QtGui/qfontmetrics_test.py
+++ b/sources/pyside6/tests/QtGui/qfontmetrics_test.py
@@ -16,10 +16,10 @@ init_test_paths(False)
 
 from PySide6.QtGui import QFont, QFontMetrics, QFontMetricsF
 from PySide6.QtCore import QRect, QRectF, Qt, QSize, QSizeF
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QFontMetricsTest(UsesQGuiApplication):
+class QFontMetricsTest(UsesQApplication):
     '''Base class for QFontMetrics tests'''
 
     def setUp(self):
@@ -91,8 +91,8 @@ class BoundingRectTest(QFontMetricsTest):
         '''QFontMetrics.boundingRect(QRect, ...) - type error'''
         arg = QRect(0, 0, 100, 200)
         self.assertRaises(TypeError, self.metrics.boundingRect, arg,
-                                         Qt.TextExpandTabs | Qt.AlignLeft,
-                                         'PySide by INdT', 20, ['aaaa', 'ase'])
+                          Qt.TextExpandTabs | Qt.AlignLeft,
+                          'PySide by INdT', 20, ['aaaa', 'ase'])
 
 
 class SizeTest(QFontMetricsTest):
@@ -123,7 +123,7 @@ class SizeTest(QFontMetricsTest):
                                          'PySide by INdT', 20, ['aaaa', 'ase'])
 
 
-class QFontMetricsFTest(UsesQGuiApplication):
+class QFontMetricsFTest(UsesQApplication):
     '''Base class for QFontMetrics tests'''
 
     def setUp(self):
@@ -196,8 +196,8 @@ class FSizeTest(QFontMetricsFTest):
     def testTypeError(self):
         '''QFontMetricsF.size - type error'''
         self.assertRaises(TypeError, self.metrics.size,
-                                         Qt.TextExpandTabs | Qt.AlignLeft,
-                                         'PySide by INdT', 20, ['aaaa', 'ase'])
+                          Qt.TextExpandTabs | Qt.AlignLeft,
+                          'PySide by INdT', 20, ['aaaa', 'ase'])
 
 
 class QCharTest(QFontMetricsFTest):
diff --git a/sources/pyside6/tests/QtGui/qicon_test.py b/sources/pyside6/tests/QtGui/qicon_test.py
index 80fc5a56b..18ef3d815 100644
--- a/sources/pyside6/tests/QtGui/qicon_test.py
+++ b/sources/pyside6/tests/QtGui/qicon_test.py
@@ -26,6 +26,7 @@ class QIconCtorWithNoneTest(TimedQGuiApplication):
 PIX_PATH = os.fspath(Path(__file__).resolve().parents[2]
                      / "doc/tutorials/basictutorial/icons.png")
 
+
 class QIconAddPixmapTest(TimedQGuiApplication):
     '''PYSIDE-1669: check that addPixmap works'''
 
diff --git a/sources/pyside6/tests/QtGui/qimage_test.py b/sources/pyside6/tests/QtGui/qimage_test.py
index 595f85892..5912bf318 100644
--- a/sources/pyside6/tests/QtGui/qimage_test.py
+++ b/sources/pyside6/tests/QtGui/qimage_test.py
@@ -13,11 +13,11 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtGui import QImage
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from xpm_data import xpm
 
 
-class QImageTest(UsesQGuiApplication):
+class QImageTest(UsesQApplication):
     '''Test case for calling setPixel with float as argument'''
 
     def testQImageStringBuffer(self):
diff --git a/sources/pyside6/tests/QtGui/qimage_win_test.py b/sources/pyside6/tests/QtGui/qimage_win_test.py
index 34e4d0daf..2d9cb96f1 100644
--- a/sources/pyside6/tests/QtGui/qimage_win_test.py
+++ b/sources/pyside6/tests/QtGui/qimage_win_test.py
@@ -14,7 +14,7 @@ init_test_paths(False)
 
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QImage
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
 def create_image():
@@ -23,7 +23,7 @@ def create_image():
     return result
 
 
-class QImageWinTest(UsesQGuiApplication):
+class QImageWinTest(UsesQApplication):
 
     def test_to_hbitmap(self):
         """Test conversion to/from a Windows HBITMAP."""
diff --git a/sources/pyside6/tests/QtGui/qitemselection_test.py b/sources/pyside6/tests/QtGui/qitemselection_test.py
index 52ab589f2..179bff745 100644
--- a/sources/pyside6/tests/QtGui/qitemselection_test.py
+++ b/sources/pyside6/tests/QtGui/qitemselection_test.py
@@ -10,12 +10,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QItemSelection
 from PySide6.QtGui import QStandardItemModel
 
 
-class QItemSelectionTest(UsesQGuiApplication):
+class QItemSelectionTest(UsesQApplication):
     def testLen(self):
         model = QStandardItemModel(2, 2)
         model.insertRow(0)
diff --git a/sources/pyside6/tests/QtGui/qkeysequence_test.py b/sources/pyside6/tests/QtGui/qkeysequence_test.py
index 25743ba34..3d72fb50a 100644
--- a/sources/pyside6/tests/QtGui/qkeysequence_test.py
+++ b/sources/pyside6/tests/QtGui/qkeysequence_test.py
@@ -13,27 +13,20 @@ init_test_paths(False)
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QKeySequence, qt_set_sequence_auto_mnemonic
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QKeySequenceTest(UsesQGuiApplication):
+class QKeySequenceTest(UsesQApplication):
 
     def testGetItemOperator(self):
         # bug #774
-        if sys.pyside63_option_python_enum:
-            # PYSIDE-1735: Remapped from Qt.Modifier to Qt.KeyboardModifier
-            #              Note that Qt.(Keyboard)?Modifier will be no longer IntFlag.
-            ks = QKeySequence(Qt.ShiftModifier, Qt.ControlModifier, Qt.Key_P, Qt.Key_R)
-            self.assertEqual(ks[0].keyboardModifiers(), Qt.ShiftModifier)
-            self.assertEqual(ks[1].keyboardModifiers(), Qt.ControlModifier)
-            self.assertEqual(ks[2].key(), Qt.Key_P)
-            self.assertEqual(ks[3].key(), Qt.Key_R)
-        else:
-            ks = QKeySequence(Qt.SHIFT, Qt.CTRL, Qt.Key_P, Qt.Key_R)
-            self.assertEqual(ks[0], Qt.SHIFT)
-            self.assertEqual(ks[1], Qt.CTRL)
-            self.assertEqual(ks[2], Qt.Key_P)
-            self.assertEqual(ks[3], Qt.Key_R)
+        # PYSIDE-1735: Remapped from Qt.Modifier to Qt.KeyboardModifier
+        #              Note that Qt.(Keyboard)?Modifier will be no longer IntFlag.
+        ks = QKeySequence(Qt.ShiftModifier, Qt.ControlModifier, Qt.Key_P, Qt.Key_R)
+        self.assertEqual(ks[0].keyboardModifiers(), Qt.ShiftModifier)
+        self.assertEqual(ks[1].keyboardModifiers(), Qt.ControlModifier)
+        self.assertEqual(ks[2].key(), Qt.Key_P)
+        self.assertEqual(ks[3].key(), Qt.Key_R)
 
         def testAutoMnemonic(self):
             qt_set_sequence_auto_mnemonic(True)
diff --git a/sources/pyside6/tests/QtGui/qpainter_test.py b/sources/pyside6/tests/QtGui/qpainter_test.py
index ffba42e99..103b91ad6 100644
--- a/sources/pyside6/tests/QtGui/qpainter_test.py
+++ b/sources/pyside6/tests/QtGui/qpainter_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QPainter, QLinearGradient, QImage
 from PySide6.QtCore import QLine, QLineF, QPoint, QPointF, QRect, QRectF, Qt
 
@@ -23,7 +23,7 @@ except ModuleNotFoundError:
     HAVE_NUMPY = False
 
 
-class QPainterDrawText(UsesQGuiApplication):
+class QPainterDrawText(UsesQApplication):
     def setUp(self):
         super(QPainterDrawText, self).setUp()
         self.image = QImage(32, 32, QImage.Format_ARGB32)
@@ -100,7 +100,7 @@ class QPainterDrawText(UsesQGuiApplication):
             self.painter.drawPointsNp(x, y)
 
 
-class SetBrushWithOtherArgs(UsesQGuiApplication):
+class SetBrushWithOtherArgs(UsesQApplication):
     '''Using qpainter.setBrush with args other than QBrush'''
 
     def testSetBrushGradient(self):
diff --git a/sources/pyside6/tests/QtGui/qpdfwriter_test.py b/sources/pyside6/tests/QtGui/qpdfwriter_test.py
index 671f7acbf..2dca2aca2 100644
--- a/sources/pyside6/tests/QtGui/qpdfwriter_test.py
+++ b/sources/pyside6/tests/QtGui/qpdfwriter_test.py
@@ -10,12 +10,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QPageLayout, QPageSize, QPdfWriter, QTextDocument
 from PySide6.QtCore import QDir, QMarginsF, QTemporaryFile
 
 
-class QPdfWriterTest(UsesQGuiApplication):
+class QPdfWriterTest(UsesQApplication):
 
     def testWrite(self):
         temporaryFile = QTemporaryFile(QDir.tempPath() + "/pdfwriter_test_XXXXXX.pdf")
diff --git a/sources/pyside6/tests/QtGui/qpen_test.py b/sources/pyside6/tests/QtGui/qpen_test.py
index 06baf92b0..7e8604606 100644
--- a/sources/pyside6/tests/QtGui/qpen_test.py
+++ b/sources/pyside6/tests/QtGui/qpen_test.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QPen, QPainter, QRasterWindow
@@ -26,13 +26,13 @@ class Painting(QRasterWindow):
         with QPainter(self) as painter:
             painter.setPen(Qt.NoPen)
             self.penFromEnum = painter.pen()
-            intVal = Qt.NoPen.value if sys.pyside63_option_python_enum else int(Qt.NoPen)
+            intVal = Qt.NoPen.value
             painter.setPen(intVal)
             self.penFromInteger = painter.pen()
         QTimer.singleShot(20, self.close)
 
 
-class QPenTest(UsesQGuiApplication):
+class QPenTest(UsesQApplication):
 
     def testCtorWithCreatedEnums(self):
         '''A simple case of QPen creation using created enums.'''
diff --git a/sources/pyside6/tests/QtGui/qpixelformat_test.py b/sources/pyside6/tests/QtGui/qpixelformat_test.py
index eaf94426f..869d15952 100644
--- a/sources/pyside6/tests/QtGui/qpixelformat_test.py
+++ b/sources/pyside6/tests/QtGui/qpixelformat_test.py
@@ -12,12 +12,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QSize, Qt
 from PySide6.QtGui import QColor, QImage, QPixelFormat, qPixelFormatRgba
 
 
-class QPixelFormatTest(UsesQGuiApplication):
+class QPixelFormatTest(UsesQApplication):
     def test(self):
         image = QImage(QSize(200, 200), QImage.Format_ARGB32)
         image.fill(QColor(Qt.red))
diff --git a/sources/pyside6/tests/QtGui/qpixmap_constructor.py b/sources/pyside6/tests/QtGui/qpixmap_constructor.py
index afba18841..dd658af52 100644
--- a/sources/pyside6/tests/QtGui/qpixmap_constructor.py
+++ b/sources/pyside6/tests/QtGui/qpixmap_constructor.py
@@ -13,7 +13,7 @@ init_test_paths(False)
 
 from PySide6.QtGui import QPixmap
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 xpm = [
     "27 22 206 2",
@@ -248,7 +248,7 @@ xpm = [
 ]
 
 
-class QStringSequenceTest(UsesQGuiApplication):
+class QStringSequenceTest(UsesQApplication):
     def testQPixmapConstructor(self):
         pixmap1 = QPixmap(xpm)
         self.assertFalse(pixmap1.isNull())
diff --git a/sources/pyside6/tests/QtGui/qpixmap_test.py b/sources/pyside6/tests/QtGui/qpixmap_test.py
index d76b0a469..b80ae2ad5 100644
--- a/sources/pyside6/tests/QtGui/qpixmap_test.py
+++ b/sources/pyside6/tests/QtGui/qpixmap_test.py
@@ -10,12 +10,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QColor, QPixmap
 from PySide6.QtCore import QFile, QIODevice, QObject, QSize, Qt
 
 
-class QPixmapTest(UsesQGuiApplication):
+class QPixmapTest(UsesQApplication):
     def testQVariantConstructor(self):
         obj = QObject()
         pixmap = QPixmap()
@@ -43,7 +43,7 @@ class QPixmapTest(UsesQGuiApplication):
         self.assertTrue(pixmap.loadFromData(data))
 
 
-class QPixmapToImage(UsesQGuiApplication):
+class QPixmapToImage(UsesQApplication):
 
     def testFilledImage(self):
         '''QPixmap.fill + toImage + image.pixel'''
diff --git a/sources/pyside6/tests/QtGui/qpixmapcache_test.py b/sources/pyside6/tests/QtGui/qpixmapcache_test.py
index aa55621af..2ecb439d3 100644
--- a/sources/pyside6/tests/QtGui/qpixmapcache_test.py
+++ b/sources/pyside6/tests/QtGui/qpixmapcache_test.py
@@ -10,11 +10,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QPixmapCache, QPixmap
 
 
-class QPixmapCacheTest(UsesQGuiApplication):
+class QPixmapCacheTest(UsesQApplication):
 
     def testWithString(self):
         pm1 = QPixmap()
diff --git a/sources/pyside6/tests/QtGui/qrasterwindow_test.py b/sources/pyside6/tests/QtGui/qrasterwindow_test.py
index a2b5bcae2..4920902d5 100644
--- a/sources/pyside6/tests/QtGui/qrasterwindow_test.py
+++ b/sources/pyside6/tests/QtGui/qrasterwindow_test.py
@@ -12,13 +12,14 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
-from PySide6.QtCore import QEvent, QPoint, QRect, QSize, QTimer, Qt
-from PySide6.QtGui import QColor, QBackingStore, QPaintDevice, QPainter, QWindow, QPaintDeviceWindow, QRasterWindow, QRegion, QStaticText
+from helper.usesqapplication import UsesQApplication
+from PySide6.QtCore import QPoint, QRect, QSize, QTimer, Qt
+from PySide6.QtGui import (QColor, QPainter, QRasterWindow, QStaticText,
+                           QTextCursor, QTextDocument, QAbstractTextDocumentLayout)
 
 
 # Window using convenience class QRasterWindow
-class TestRasterWindow(QRasterWindow):
+class StaticTextRasterWindow(QRasterWindow):
     def __init__(self):
         super().__init__()
         self.text = QStaticText("QRasterWindow")
@@ -30,12 +31,44 @@ class TestRasterWindow(QRasterWindow):
             painter.drawStaticText(QPoint(10, 10), self.text)
 
 
-class QRasterWindowTest(UsesQGuiApplication):
+class TextDocumentWindow(QRasterWindow):
+    """PYSIDE-2252, drawing with QAbstractTextDocumentLayout.PaintContext"""
+
+    def __init__(self):
+        super().__init__()
+        self.m_document = QTextDocument()
+        self.m_document.setPlainText("bla bla")
+
+    def paintEvent(self, event):
+        with QPainter(self) as painter:
+            clientRect = QRect(QPoint(0, 0), self.size())
+            painter.fillRect(clientRect, QColor(Qt.white))
+            ctx = QAbstractTextDocumentLayout.PaintContext()
+            ctx.clip = clientRect
+
+            sel = QAbstractTextDocumentLayout.Selection()
+            cursor = QTextCursor(self.m_document)
+            cursor.movePosition(QTextCursor.Start)
+            cursor.movePosition(QTextCursor.NextWord, QTextCursor.KeepAnchor)
+            sel.cursor = cursor
+            sel.format.setForeground(Qt.red)
+            ctx.selections = [sel]
+
+            self.m_document.documentLayout().draw(painter, ctx)
+
+
+class QRasterWindowTest(UsesQApplication):
     def test(self):
-        rasterWindow = TestRasterWindow()
+        rasterWindow = StaticTextRasterWindow()
         rasterWindow.setFramePosition(QPoint(100, 100))
         rasterWindow.resize(QSize(400, 400))
         rasterWindow.show()
+
+        rasterWindow2 = TextDocumentWindow()
+        rasterWindow2.setFramePosition(rasterWindow.frameGeometry().topRight() + QPoint(20, 0))
+        rasterWindow2.resize(QSize(400, 400))
+        rasterWindow2.show()
+
         QTimer.singleShot(100, self.app.quit)
         self.app.exec()
 
diff --git a/sources/pyside6/tests/QtGui/qregion_test.py b/sources/pyside6/tests/QtGui/qregion_test.py
index 48da94889..df14fc3e0 100644
--- a/sources/pyside6/tests/QtGui/qregion_test.py
+++ b/sources/pyside6/tests/QtGui/qregion_test.py
@@ -12,10 +12,10 @@ init_test_paths(False)
 
 from PySide6.QtGui import QRegion
 from PySide6.QtCore import QPoint, QRect, QSize
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QRegionTest(UsesQGuiApplication):
+class QRegionTest(UsesQApplication):
 
     def testFunctionUnit(self):
         r = QRegion(0, 0, 10, 10)
diff --git a/sources/pyside6/tests/QtGui/qstandarditemmodel_test.py b/sources/pyside6/tests/QtGui/qstandarditemmodel_test.py
index 78d55d414..55aca9113 100644
--- a/sources/pyside6/tests/QtGui/qstandarditemmodel_test.py
+++ b/sources/pyside6/tests/QtGui/qstandarditemmodel_test.py
@@ -14,10 +14,10 @@ init_test_paths(False)
 from PySide6.QtCore import QObject
 from PySide6.QtGui import QStandardItemModel, QStandardItem
 from shiboken6 import Shiboken
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QStandardItemModelTest(UsesQGuiApplication):
+class QStandardItemModelTest(UsesQApplication):
 
     def setUp(self):
         super(QStandardItemModelTest, self).setUp()
@@ -43,7 +43,7 @@ class QStandardItemModelTest(UsesQGuiApplication):
         self.assertFalse(Shiboken.isValid(root))
 
 
-class QStandardItemModelRef(UsesQGuiApplication):
+class QStandardItemModelRef(UsesQApplication):
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         model = QStandardItemModel(5, 5)
diff --git a/sources/pyside6/tests/QtGui/qstring_qkeysequence_test.py b/sources/pyside6/tests/QtGui/qstring_qkeysequence_test.py
index 29dcfb34b..f68374263 100644
--- a/sources/pyside6/tests/QtGui/qstring_qkeysequence_test.py
+++ b/sources/pyside6/tests/QtGui/qstring_qkeysequence_test.py
@@ -13,12 +13,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtGui import QAction, QKeySequence
 
 
-class QStringQKeySequenceTest(UsesQGuiApplication):
+class QStringQKeySequenceTest(UsesQApplication):
     '''Tests conversions of QString to and from QKeySequence.'''
 
     def testQStringFromQKeySequence(self):
diff --git a/sources/pyside6/tests/QtGui/qstylehints_test.py b/sources/pyside6/tests/QtGui/qstylehints_test.py
index d962144b6..d2b21d30d 100644
--- a/sources/pyside6/tests/QtGui/qstylehints_test.py
+++ b/sources/pyside6/tests/QtGui/qstylehints_test.py
@@ -12,11 +12,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QStyleHints
 
 
-class QStyleHintsTest(UsesQGuiApplication):
+class QStyleHintsTest(UsesQApplication):
     def test(self):
         styleHints = self.app.styleHints()
         self.assertTrue(styleHints.startDragDistance() > 0)
diff --git a/sources/pyside6/tests/QtGui/qtextdocument_functions.py b/sources/pyside6/tests/QtGui/qtextdocument_functions.py
index 3329b1aee..2ac72df56 100644
--- a/sources/pyside6/tests/QtGui/qtextdocument_functions.py
+++ b/sources/pyside6/tests/QtGui/qtextdocument_functions.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtGui import Qt
+from PySide6.QtGui import QPageRanges, Qt
 
 
 class QTextDocumentFunctions(unittest.TestCase):
@@ -22,5 +22,16 @@ class QTextDocumentFunctions(unittest.TestCase):
         self.assertEqual(html, '<p>A &amp; B</p>')
 
 
+class QPageRangesTest(unittest.TestCase):
+    """PYSIDE-2237: Test that field QPageRanges.Range.from is properly mangled."""
+
+    def test(self):
+        pr = QPageRanges()
+        pr.addPage(1)
+        r0 = pr.toRangeList()[0]
+        self.assertEqual(r0.from_, 1)
+        self.assertEqual(r0.to, 1)
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtGui/qtextline_test.py b/sources/pyside6/tests/QtGui/qtextline_test.py
index ea39d536d..c34a4c98a 100644
--- a/sources/pyside6/tests/QtGui/qtextline_test.py
+++ b/sources/pyside6/tests/QtGui/qtextline_test.py
@@ -11,10 +11,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtGui import QTextLayout, QTextOption
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QTextLineTest(UsesQGuiApplication):
+class QTextLineTest(UsesQApplication):
 
     def testCursorToX(self):
         textLayout = QTextLayout()
diff --git a/sources/pyside6/tests/QtGui/qtransform_test.py b/sources/pyside6/tests/QtGui/qtransform_test.py
index 053f07331..dc51a74e6 100644
--- a/sources/pyside6/tests/QtGui/qtransform_test.py
+++ b/sources/pyside6/tests/QtGui/qtransform_test.py
@@ -11,7 +11,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QPointF
-from PySide6.QtGui import QTransform, QPolygonF, QPolygonF
+from PySide6.QtGui import QTransform, QPolygonF, QPolygonF, QQuaternion, QVector3D
 
 
 class QTransformTest(unittest.TestCase):
@@ -78,6 +78,12 @@ class QTransformTest(unittest.TestCase):
 
         self.assertEqual(t1, r2)
 
+    def testQQuaternion(self):
+        """Test return tuples."""
+        q = QQuaternion(1, 1, 1, 1)
+        self.assertEqual(len(q.getAxisAndAngle()), 2)
+        self.assertEqual(len(q.getEulerAngles()), 3)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/sources/pyside6/tests/QtGui/timed_app_and_patching_test.py b/sources/pyside6/tests/QtGui/timed_app_and_patching_test.py
index c45d762b5..6e9a661ce 100644
--- a/sources/pyside6/tests/QtGui/timed_app_and_patching_test.py
+++ b/sources/pyside6/tests/QtGui/timed_app_and_patching_test.py
@@ -7,13 +7,10 @@ import unittest
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
-from init_paths import init_test_paths
+from init_paths import init_test_paths  # noqa: E402
 init_test_paths(False)
 
 from helper.timedqguiapplication import TimedQGuiApplication
-from PySide6.support import deprecated
-from PySide6.support.signature import importhandler
-from PySide6 import QtGui
 
 
 class TestTimedApp(TimedQGuiApplication):
@@ -23,21 +20,7 @@ class TestTimedApp(TimedQGuiApplication):
         # Simple test of TimedQGuiApplication
         self.app.exec()
 
-
-def fix_for_QtGui(QtGui):
-    QtGui.something = 42
-
-
-class TestPatchingFramework(unittest.TestCase):
-    """Simple test that verifies that deprecated.py works"""
-
-    deprecated.fix_for_QtGui = fix_for_QtGui
-
-    def test_patch_works(self):
-        something = "something"
-        self.assertFalse(hasattr(QtGui, something))
-        importhandler.finish_import(QtGui)
-        self.assertTrue(hasattr(QtGui, something))
+# deprecated.py is no longer needed.
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtMultimedia/audio_test.py b/sources/pyside6/tests/QtMultimedia/audio_test.py
index eb144a326..af359e525 100644
--- a/sources/pyside6/tests/QtMultimedia/audio_test.py
+++ b/sources/pyside6/tests/QtMultimedia/audio_test.py
@@ -12,12 +12,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QByteArray
 from PySide6.QtMultimedia import QAudioBuffer, QAudioFormat, QMediaDevices
 
 
-class testAudioDevices(UsesQGuiApplication):
+class testAudioDevices(UsesQApplication):
 
     def setUp(self):
         super().setUp()
diff --git a/sources/pyside6/tests/QtNetwork/CMakeLists.txt b/sources/pyside6/tests/QtNetwork/CMakeLists.txt
index dd1d7c85d..bff3580a8 100644
--- a/sources/pyside6/tests/QtNetwork/CMakeLists.txt
+++ b/sources/pyside6/tests/QtNetwork/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(bug_446.py)
 PYSIDE_TEST(bug_1084.py)
 PYSIDE_TEST(accessManager_test.py)
diff --git a/sources/pyside6/tests/QtNetwork/accessManager_test.py b/sources/pyside6/tests/QtNetwork/accessManager_test.py
index 01e16bd78..87711b278 100644
--- a/sources/pyside6/tests/QtNetwork/accessManager_test.py
+++ b/sources/pyside6/tests/QtNetwork/accessManager_test.py
@@ -14,11 +14,11 @@ init_test_paths(False)
 
 from PySide6.QtCore import QUrl
 from PySide6.QtNetwork import QNetworkAccessManager, QNetworkReply, QNetworkRequest
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 from httpd import TestServer
 
 
-class AccessManagerCase(UsesQCoreApplication):
+class AccessManagerCase(UsesQApplication):
 
     def setUp(self):
         super(AccessManagerCase, self).setUp()
diff --git a/sources/pyside6/tests/QtNetwork/bug_446.py b/sources/pyside6/tests/QtNetwork/bug_446.py
index 82df4eafc..f28ddb369 100644
--- a/sources/pyside6/tests/QtNetwork/bug_446.py
+++ b/sources/pyside6/tests/QtNetwork/bug_446.py
@@ -11,10 +11,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtNetwork import QHostAddress, QTcpServer, QTcpSocket
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class HttpSignalsCase(UsesQCoreApplication):
+class HttpSignalsCase(UsesQApplication):
     '''Test case for launching QHttp signals'''
     DATA = bytes("PySide rocks", "UTF-8")
 
diff --git a/sources/pyside6/tests/QtNetwork/qhostinfo_test.py b/sources/pyside6/tests/QtNetwork/qhostinfo_test.py
index ff1a5d954..8d8d2cae4 100644
--- a/sources/pyside6/tests/QtNetwork/qhostinfo_test.py
+++ b/sources/pyside6/tests/QtNetwork/qhostinfo_test.py
@@ -12,7 +12,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import (QCoreApplication, QElapsedTimer, QObject, QThread,
                             Slot, SLOT)
 from PySide6.QtNetwork import QHostInfo
@@ -45,10 +45,10 @@ class Receiver(QObject):
         self._slot_called = True
 
 
-class QHostInfoTest(UsesQCoreApplication):
+class QHostInfoTest(UsesQApplication):
     '''Test case for QHostInfo.'''
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self._timer = QElapsedTimer()
 
     def testStringBasedLookup(self):
diff --git a/sources/pyside6/tests/QtNfc/test_nfc.py b/sources/pyside6/tests/QtNfc/test_nfc.py
index 72932a5a1..a73c52153 100644
--- a/sources/pyside6/tests/QtNfc/test_nfc.py
+++ b/sources/pyside6/tests/QtNfc/test_nfc.py
@@ -15,10 +15,10 @@ init_test_paths(False)
 
 from PySide6.QtNfc import QNearFieldManager
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class TestNfc(UsesQCoreApplication):
+class TestNfc(UsesQApplication):
 
     def test(self):
         manager = QNearFieldManager()
diff --git a/sources/pyside6/tests/QtOpenGL/qopenglbuffer_test.py b/sources/pyside6/tests/QtOpenGL/qopenglbuffer_test.py
index cac585834..e4ff6feb4 100644
--- a/sources/pyside6/tests/QtOpenGL/qopenglbuffer_test.py
+++ b/sources/pyside6/tests/QtOpenGL/qopenglbuffer_test.py
@@ -13,7 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtGui import QOffscreenSurface, QOpenGLContext, QSurface, QWindow
 from PySide6.QtOpenGL import QOpenGLBuffer
 
@@ -45,7 +45,7 @@ def createSurface(surfaceClass):
     return 0
 
 
-class QOpenGLBufferTest(UsesQGuiApplication):
+class QOpenGLBufferTest(UsesQApplication):
     def testBufferCreate(self):
         surface = createSurface(QSurface.Window)
         ctx = QOpenGLContext()
diff --git a/sources/pyside6/tests/QtOpenGL/qopenglwindow_test.py b/sources/pyside6/tests/QtOpenGL/qopenglwindow_test.py
index 3a5cd0bbe..3e6bc4c9d 100644
--- a/sources/pyside6/tests/QtOpenGL/qopenglwindow_test.py
+++ b/sources/pyside6/tests/QtOpenGL/qopenglwindow_test.py
@@ -12,18 +12,19 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import QSize, QTimer, Qt
 from PySide6.QtGui import (QColor, QGuiApplication, QImage, QOpenGLContext,
-    QSurfaceFormat)
-from PySide6.QtOpenGL import (QOpenGLTexture, QOpenGLWindow)
+                           QSurfaceFormat)
+from PySide6.QtOpenGL import QOpenGLTexture, QOpenGLWindow
 
 
 try:
     from OpenGL import GL
+    from PySide6.QtOpenGL import QOpenGLVersionProfile, QOpenGLVersionFunctionsFactory
 except ImportError:
-    print("Skipping test due to missing OpenGL module")
+    print("Skipping test due to missing OpenGL module/GLES only build")
     sys.exit(0)
 
 
@@ -41,43 +42,47 @@ class OpenGLWindow(QOpenGLWindow):
             self.context().doneCurrent()
 
     def initializeGL(self):
-        self.m_functions = self.context().functions()
+        profile = QOpenGLVersionProfile()
+        profile.setVersion(1, 3)
+        profile.setProfile(QSurfaceFormat.CompatibilityProfile)
+        self.m_functions = QOpenGLVersionFunctionsFactory.get(profile)
         self.m_functions.initializeOpenGLFunctions()
+
         print("GL_MAX_LIGHTS=", self.m_functions.glGetIntegerv(GL.GL_MAX_LIGHTS))
         image = QImage(QSize(200, 200), QImage.Format_RGBA8888)
         image.fill(QColor(Qt.red))
         self.m_texture = QOpenGLTexture(image)
 
     def paintGL(self):
-        GL.glMatrixMode(GL.GL_MODELVIEW)
-        GL.glLoadIdentity()
+        self.m_functions.glMatrixMode(GL.GL_MODELVIEW)
+        self.m_functions.glLoadIdentity()
 
-        GL.glMatrixMode(GL.GL_PROJECTION)
-        GL.glLoadIdentity()
-        GL.glOrtho(0, 1, 1, 0, -1, 1)
+        self.m_functions.glMatrixMode(GL.GL_PROJECTION)
+        self.m_functions.glLoadIdentity()
+        self.m_functions.glOrtho(0, 1, 1, 0, -1, 1)
 
         self.m_functions.glClear(GL.GL_COLOR_BUFFER_BIT)
         self.m_functions.glEnable(GL.GL_TEXTURE_2D)
         self.m_texture.bind()
 
         d = 0.5
-        GL.glBegin(GL.GL_QUADS)
-        GL.glTexCoord2f(0, 0)
-        GL.glVertex2f(0, 0)
-        GL.glTexCoord2f(d, 0)
-        GL.glVertex2f(d, 0)
-        GL.glTexCoord2f(d, d)
-        GL.glVertex2f(d, d)
-        GL.glTexCoord2f(0, d)
-        GL.glVertex2f(0, d)
-        GL.glEnd()
+        self.m_functions.glBegin(GL.GL_QUADS)
+        self.m_functions.glTexCoord2f(0, 0)
+        self.m_functions.glVertex2f(0, 0)
+        self.m_functions.glTexCoord2f(d, 0)
+        self.m_functions.glVertex2f(d, 0)
+        self.m_functions.glTexCoord2f(d, d)
+        self.m_functions.glVertex2f(d, d)
+        self.m_functions.glTexCoord2f(0, d)
+        self.m_functions.glVertex2f(0, d)
+        self.m_functions.glEnd()
         self.m_texture.release()
 
     def resizeGL(self, w, h):
         self.m_functions.glViewport(0, 0, self.width(), self.height())
 
 
-class QOpenGLWindowTest(UsesQGuiApplication):
+class QOpenGLWindowTest(UsesQApplication):
     # On macOS, glClear(), glViewport() are rejected due to GLbitfield/GLint not being resolved properly
     def test(self):
         openGlWindow = OpenGLWindow()
diff --git a/sources/pyside6/tests/QtQml/CMakeLists.txt b/sources/pyside6/tests/QtQml/CMakeLists.txt
index fc931c0f2..30bf7e786 100644
--- a/sources/pyside6/tests/QtQml/CMakeLists.txt
+++ b/sources/pyside6/tests/QtQml/CMakeLists.txt
@@ -1,8 +1,12 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(bug_451.py)
 PYSIDE_TEST(bug_456.py)
 PYSIDE_TEST(bug_557.py)
 PYSIDE_TEST(bug_726.py)
 PYSIDE_TEST(bug_814.py)
+PYSIDE_TEST(bug_825_old.py)
 PYSIDE_TEST(bug_825.py)
 PYSIDE_TEST(bug_847.py)
 PYSIDE_TEST(bug_915.py)
@@ -13,8 +17,10 @@ PYSIDE_TEST(bug_997.py)
 PYSIDE_TEST(bug_1029.py)
 PYSIDE_TEST(groupedproperty.py)
 PYSIDE_TEST(listproperty.py)
+PYSIDE_TEST(qmlregistertype_test.py)
 PYSIDE_TEST(qqmlapplicationengine_test.py)
 PYSIDE_TEST(qqmlnetwork_test.py)
+PYSIDE_TEST(qqmlcomponent_test.py)
 PYSIDE_TEST(qquickview_test.py)
 PYSIDE_TEST(connect_python_qml.py)
 PYSIDE_TEST(registerattached.py)
diff --git a/sources/pyside6/tests/QtQml/bug_451.py b/sources/pyside6/tests/QtQml/bug_451.py
index 299864ae4..d81a99d94 100644
--- a/sources/pyside6/tests/QtQml/bug_451.py
+++ b/sources/pyside6/tests/QtQml/bug_451.py
@@ -28,6 +28,7 @@ from PySide6.QtQml import QmlElement
 QML_IMPORT_NAME = "test.PythonObject"
 QML_IMPORT_MAJOR_VERSION = 1
 
+
 @QmlElement
 class PythonObject(QObject):
     def __init__(self):
diff --git a/sources/pyside6/tests/QtQml/bug_456.py b/sources/pyside6/tests/QtQml/bug_456.py
index 7148102cc..7743ee3fd 100644
--- a/sources/pyside6/tests/QtQml/bug_456.py
+++ b/sources/pyside6/tests/QtQml/bug_456.py
@@ -19,6 +19,7 @@ from PySide6.QtQml import QmlElement
 QML_IMPORT_NAME = "test.RotateValue"
 QML_IMPORT_MAJOR_VERSION = 1
 
+
 @QmlElement
 class RotateValue(QObject):
     def __init__(self):
diff --git a/sources/pyside6/tests/QtQml/bug_557.py b/sources/pyside6/tests/QtQml/bug_557.py
index cc06a4877..eb43973f6 100644
--- a/sources/pyside6/tests/QtQml/bug_557.py
+++ b/sources/pyside6/tests/QtQml/bug_557.py
@@ -23,6 +23,6 @@ component = QQmlComponent(engine)
 
 # This should segfault if the QDeclarativeComponent has not QQmlEngine
 file = Path(__file__).resolve().parent / 'foo.qml'
-assert(not file.is_file())
+assert (not file.is_file())
 component.loadUrl(QUrl.fromLocalFile(file))
 
diff --git a/sources/pyside6/tests/QtQml/bug_726.py b/sources/pyside6/tests/QtQml/bug_726.py
index 7ddc8e93b..56c1e70f1 100644
--- a/sources/pyside6/tests/QtQml/bug_726.py
+++ b/sources/pyside6/tests/QtQml/bug_726.py
@@ -18,6 +18,8 @@ from PySide6.QtQml import QmlElement
 
 QML_IMPORT_NAME = "test.ProxyObject"
 QML_IMPORT_MAJOR_VERSION = 1
+
+
 @QmlElement
 class ProxyObject(QObject):
     def __init__(self):
diff --git a/sources/pyside6/tests/QtQml/bug_814.py b/sources/pyside6/tests/QtQml/bug_814.py
index 9db6488ef..0e7858b6c 100644
--- a/sources/pyside6/tests/QtQml/bug_814.py
+++ b/sources/pyside6/tests/QtQml/bug_814.py
@@ -29,13 +29,14 @@ from PySide6.QtQml import QmlElement
 QML_IMPORT_NAME = "test.ListModel"
 QML_IMPORT_MAJOR_VERSION = 1
 
+
 @QmlElement
 class ListModel(QAbstractListModel):
     def __init__(self):
         super().__init__()
 
     def roleNames(self):
-        return { Qt.DisplayRole: b'pysideModelData' }
+        return {Qt.DisplayRole: b'pysideModelData'}
 
     def rowCount(self, parent=QModelIndex()):
         return 3
diff --git a/sources/pyside6/tests/QtQml/bug_825.py b/sources/pyside6/tests/QtQml/bug_825.py
index 9771d0634..a8bd304ec 100644
--- a/sources/pyside6/tests/QtQml/bug_825.py
+++ b/sources/pyside6/tests/QtQml/bug_825.py
@@ -1,6 +1,11 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
+"""
+This is the corrected version for Python 3.
+Unfortunately, this touches a Python 3.8 error that was fixed late.
+"""
+
 import os
 import sys
 import unittest
@@ -25,8 +30,8 @@ class MetaA(type):
     pass
 
 
-class A(object):
-    __metaclass__ = MetaA
+class A(object, metaclass=MetaA):
+    pass
 
 
 MetaB = type(QQuickPaintedItem)
@@ -37,8 +42,8 @@ class MetaC(MetaA, MetaB):
     pass
 
 
-class C(A, B):
-    __metaclass__ = MetaC
+class C(A, B, metaclass=MetaC):
+    pass
 
 
 class Bug825 (C):
diff --git a/sources/pyside6/tests/QtQml/bug_825_old.py b/sources/pyside6/tests/QtQml/bug_825_old.py
new file mode 100644
index 000000000..c44fa75f4
--- /dev/null
+++ b/sources/pyside6/tests/QtQml/bug_825_old.py
@@ -0,0 +1,80 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+"""
+This is the now incorrect old version from Python 2.
+It happens to work in another way and will be retained.
+"""
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from helper.helper import quickview_errorstring
+
+from PySide6.QtCore import Qt, QUrl, QTimer
+from PySide6.QtGui import QGuiApplication, QPen
+from PySide6.QtWidgets import QGraphicsItem
+from PySide6.QtQml import qmlRegisterType
+from PySide6.QtQuick import QQuickView, QQuickItem, QQuickPaintedItem
+
+paintCalled = False
+
+
+class MetaA(type):
+    pass
+
+
+class A(object):
+    __metaclass__ = MetaA
+
+
+MetaB = type(QQuickPaintedItem)
+B = QQuickPaintedItem
+
+
+class MetaC(MetaA, MetaB):
+    pass
+
+
+class C(A, B):
+    __metaclass__ = MetaC
+
+
+class Bug825 (C):
+    def __init__(self, parent=None):
+        QQuickPaintedItem.__init__(self, parent)
+
+    def paint(self, painter):
+        global paintCalled
+        pen = QPen(Qt.black, 2)
+        painter.setPen(pen)
+        painter.drawPie(self.boundingRect(), 0, 128)
+        paintCalled = True
+
+
+class TestBug825 (unittest.TestCase):
+    def testIt(self):
+        global paintCalled
+        app = QGuiApplication([])
+        qmlRegisterType(Bug825, 'bugs', 1, 0, 'Bug825')
+        self.assertRaises(TypeError, qmlRegisterType, A, 'bugs', 1, 0, 'A')
+
+        view = QQuickView()
+        file = Path(__file__).resolve().parent / 'bug_825.qml'
+        self.assertTrue(file.is_file())
+        view.setSource(QUrl.fromLocalFile(file))
+        self.assertTrue(view.rootObject(), quickview_errorstring(view))
+        view.show()
+        QTimer.singleShot(250, view.close)
+        app.exec()
+        self.assertTrue(paintCalled)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtQml/bug_847.py b/sources/pyside6/tests/QtQml/bug_847.py
index 8ccde82ff..947eb494e 100644
--- a/sources/pyside6/tests/QtQml/bug_847.py
+++ b/sources/pyside6/tests/QtQml/bug_847.py
@@ -17,7 +17,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.helper import quickview_errorstring
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import Slot, Signal, QUrl, QTimer, QCoreApplication
 from PySide6.QtQuick import QQuickView
@@ -34,7 +34,7 @@ class View(QQuickView):
         self.called.emit(x, y)
 
 
-class TestQML(UsesQGuiApplication):
+class TestQML(UsesQApplication):
     def done(self, x, y):
         self._sucess = True
         self.app.quit()
diff --git a/sources/pyside6/tests/QtQml/bug_926.py b/sources/pyside6/tests/QtQml/bug_926.py
index c4853b9ad..085e9a68f 100644
--- a/sources/pyside6/tests/QtQml/bug_926.py
+++ b/sources/pyside6/tests/QtQml/bug_926.py
@@ -41,7 +41,7 @@ class MyClass (QObject):
 class TestBug926 (unittest.TestCase):
     def testIt(self):
         app = QGuiApplication([])
-        qmlRegisterType(MyClass,'Example', 1, 0, 'MyClass')
+        qmlRegisterType(MyClass, 'Example', 1, 0, 'MyClass')
         view = QQuickView()
         file = Path(__file__).resolve().parent / 'bug_926.qml'
         self.assertTrue(file.is_file())
diff --git a/sources/pyside6/tests/QtQml/bug_995.py b/sources/pyside6/tests/QtQml/bug_995.py
index bd1315d52..868c584e2 100644
--- a/sources/pyside6/tests/QtQml/bug_995.py
+++ b/sources/pyside6/tests/QtQml/bug_995.py
@@ -11,7 +11,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.helper import adjust_filename
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import QUrl
 from PySide6.QtGui import QGuiApplication
@@ -19,7 +19,7 @@ from PySide6.QtQuick import QQuickView
 
 app = QGuiApplication([])
 file = Path(__file__).resolve().parent / 'bug_995.qml'
-assert(file.is_file())
+assert (file.is_file())
 view = QQuickView(QUrl.fromLocalFile(file))
 view.show()
 view.resize(200, 200)
diff --git a/sources/pyside6/tests/QtQml/bug_997.py b/sources/pyside6/tests/QtQml/bug_997.py
index cc7cf4d66..501c221c3 100644
--- a/sources/pyside6/tests/QtQml/bug_997.py
+++ b/sources/pyside6/tests/QtQml/bug_997.py
@@ -11,13 +11,13 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.helper import quickview_errorstring
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QCoreApplication, QTimer, QUrl, Slot
 from PySide6.QtQml import QQmlPropertyMap
 from PySide6.QtQuick import QQuickView
 
 
-class TestBug(UsesQGuiApplication):
+class TestBug(UsesQApplication):
 
     def setUp(self):
         super().setUp()
diff --git a/sources/pyside6/tests/QtQml/connect_python_qml.py b/sources/pyside6/tests/QtQml/connect_python_qml.py
index f0df1c83d..2e60aec4f 100644
--- a/sources/pyside6/tests/QtQml/connect_python_qml.py
+++ b/sources/pyside6/tests/QtQml/connect_python_qml.py
@@ -42,7 +42,8 @@ class TestConnectionWithInvalidSignature(TimedQGuiApplication):
         root = view.rootObject()
         self.assertTrue(root, quickview_errorstring(view))
         button = root.findChild(QObject, "buttonMouseArea")
-        self.assertRaises(TypeError, QObject.connect, [button,SIGNAL('entered()'), self.onButtonFailClicked])
+        self.assertRaises(TypeError, QObject.connect,
+                          [button, SIGNAL('entered()'), self.onButtonFailClicked])
         button.entered.connect(self.onButtonClicked)
         button.entered.emit()
         view.show()
diff --git a/sources/pyside6/tests/QtQml/javascript_exceptions.py b/sources/pyside6/tests/QtQml/javascript_exceptions.py
index ec99c930d..e2b530aaf 100644
--- a/sources/pyside6/tests/QtQml/javascript_exceptions.py
+++ b/sources/pyside6/tests/QtQml/javascript_exceptions.py
@@ -11,7 +11,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.helper import quickview_errorstring
-from helper.usesqguiapplication import UsesQGuiApplication
+from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import Slot, Property, Signal, QObject, QUrl
 from PySide6.QtQml import QJSEngine, qmlRegisterType
@@ -54,7 +54,7 @@ class TestClass(QObject):
             test_2 = True
 
 
-class JavaScriptExceptionsTest(UsesQGuiApplication):
+class JavaScriptExceptionsTest(UsesQApplication):
     def test_jsengine(self):
         engine = QJSEngine()
         test_object = TestClass()
diff --git a/sources/pyside6/tests/QtQml/listproperty.py b/sources/pyside6/tests/QtQml/listproperty.py
index 8916aefe5..884600d29 100644
--- a/sources/pyside6/tests/QtQml/listproperty.py
+++ b/sources/pyside6/tests/QtQml/listproperty.py
@@ -7,11 +7,25 @@ import unittest
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
-from init_paths import init_test_paths
+from init_paths import init_test_paths  # noqa: E402
 init_test_paths(False)
 
-from PySide6.QtCore import QObject
-from PySide6.QtQml import ListProperty
+from helper.usesqapplication import UsesQApplication  # noqa: E402, F401
+
+from PySide6.QtCore import QObject, QUrl, Property, qInstallMessageHandler  # noqa: E402
+from PySide6.QtQml import ListProperty, QmlElement  # noqa: E402
+from PySide6.QtQuick import QQuickView  # noqa: E402
+
+
+QML_IMPORT_NAME = "test.ListPropertyTest"
+QML_IMPORT_MAJOR_VERSION = 1
+
+output_messages = []
+
+
+def message_handler(mode, context, message):
+    global output_messages
+    output_messages.append(f"{message}")
 
 
 class InheritsQObject(QObject):
@@ -22,7 +36,46 @@ def dummyFunc():
     pass
 
 
-class TestListProperty(unittest.TestCase):
+@QmlElement
+class Person(QObject):
+    def __init__(self, parent=None):
+        super().__init__(parent=None)
+        self._name = ''
+        self._friends = []
+
+    def appendFriend(self, friend):
+        self._friends.append(friend)
+
+    def friendCount(self):
+        return len(self._friends)
+
+    def friend(self, index):
+        return self._friends[index]
+
+    def removeLastItem(self):
+        if len(self._friends) > 0:
+            self._friends.pop()
+
+    def replace(self, index, friend):
+        if 0 <= index < len(self._friends):
+            self._friends[index] = friend
+
+    def clear(self):
+        self._friends.clear()
+
+    @Property(str, final=True)
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    friends = ListProperty(QObject, append=appendFriend, count=friendCount, at=friend,
+                           removeLast=removeLastItem, replace=replace, clear=clear)
+
+
+class TestListProperty(UsesQApplication):
     def testIt(self):
 
         # Verify that type checking works properly
@@ -31,7 +84,7 @@ class TestListProperty(unittest.TestCase):
         try:
             ListProperty(QObject)
             ListProperty(InheritsQObject)
-        except:
+        except Exception:
             type_check_error = True
 
         self.assertFalse(type_check_error)
@@ -47,21 +100,37 @@ class TestListProperty(unittest.TestCase):
         method_check_error = False
 
         try:
-            ListProperty(QObject, append=None, at=None, count=None, replace=None, clear=None, removeLast=None)  # Explicitly setting None
+            ListProperty(QObject, append=None, at=None, count=None, replace=None, clear=None,
+                         removeLast=None)  # Explicitly setting None
             ListProperty(QObject, append=dummyFunc)
             ListProperty(QObject, count=dummyFunc, at=dummyFunc)
-        except:
+        except Exception:
             method_check_error = True
 
         self.assertFalse(method_check_error)
 
         try:
-            ListPropery(QObject, append=QObject())
-        except:
+            ListProperty(QObject, append=QObject())
+        except Exception:
             method_check_error = True
 
         self.assertTrue(method_check_error)
 
+    def testListPropParameters(self):
+        global output_messages
+        qInstallMessageHandler(message_handler)
+        view = QQuickView()
+        file = Path(__file__).resolve().parent / 'listproperty.qml'
+        self.assertTrue(file.is_file())
+        view.setSource(QUrl.fromLocalFile(file))
+        view.show()
+        self.assertEqual(output_messages[0], "List length: 3")
+        self.assertEqual(output_messages[1], "First element: Alice")
+        self.assertEqual(output_messages[2], "Removing last item: Charlie")
+        self.assertEqual(output_messages[3], "Replacing last item: Bob")
+        self.assertEqual(output_messages[4], "Replaced last item: David")
+        self.assertEqual(output_messages[5], "List length after clearing: 0")
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/QtQml/listproperty.qml b/sources/pyside6/tests/QtQml/listproperty.qml
new file mode 100644
index 000000000..7b71e30ba
--- /dev/null
+++ b/sources/pyside6/tests/QtQml/listproperty.qml
@@ -0,0 +1,50 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import QtQuick 2.0
+import test.ListPropertyTest
+
+Rectangle {
+    width: 360
+    height: 360
+
+    Person {
+        id: person
+        friends: [
+            Person{
+                name: "Alice"
+            },
+            Person{
+                name: "Bob"
+            },
+            Person{
+                name: "Charlie"
+            }
+        ]
+    }
+
+    Person{
+        id: david
+        name: "David"
+    }
+
+    Component.onCompleted: {
+        // Access the length of the list
+        console.log("List length: " + person.friends.length);
+
+        // Access the first element of the list
+        console.log("First element: " + person.friends[0].name);
+
+        // Remove the last item of the list
+        console.log("Removing last item: " + person.friends.pop().name);
+
+        // Repalce the last item of the list
+        console.log("Replacing last item: " + person.friends[person.friends.length - 1].name);
+        person.friends[person.friends.length - 1] = david;
+        console.log("Replaced last item: " + person.friends[person.friends.length - 1].name);
+
+        // Clear the list
+        person.friends = [];
+        console.log("List length after clearing: " + person.friends.length);
+    }
+}
diff --git a/sources/pyside6/tests/QtQml/qmlregistertype_test.py b/sources/pyside6/tests/QtQml/qmlregistertype_test.py
new file mode 100644
index 000000000..0042d6fd3
--- /dev/null
+++ b/sources/pyside6/tests/QtQml/qmlregistertype_test.py
@@ -0,0 +1,53 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from helper.usesqapplication import UsesQApplication
+
+
+from PySide6.QtCore import QCoreApplication, QObject  # noqa: F401
+from PySide6.QtQml import QQmlApplicationEngine, qmlRegisterType
+
+
+class BaseClass(QObject):
+    def __init__(self, p=None):
+        super().__init__(p)
+
+
+class ChildClass(BaseClass):
+    def __init__(self, p=None):
+        super().__init__(p)
+
+
+class TestQmlRegisterType(UsesQApplication):
+    """Test the legacy QML register functions."""
+
+    def test(self):
+        qmlRegisterType(BaseClass, 'test', 1, 0, 'BaseClass')
+        qmlRegisterType(ChildClass, 'test', 1, 0, 'ChildClass')
+        # PYSIDE-2709: qmlRegisterType() would set additional class info
+        # on the meta objects for registration which caused another meta
+        # object to be created, breaking inheritance.
+        child = ChildClass()
+        base = BaseClass()
+        self.assertTrue(child.metaObject().inherits(base.metaObject()))
+
+        engine = QQmlApplicationEngine()
+        file = Path(__file__).resolve().parent / 'qmlregistertype_test.qml'
+
+        engine.load(file)
+        rootObjects = engine.rootObjects()
+        self.assertTrue(rootObjects)
+        self.assertTrue(type(rootObjects[0]), ChildClass)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtQml/qmlregistertype_test.qml b/sources/pyside6/tests/QtQml/qmlregistertype_test.qml
new file mode 100644
index 000000000..108bb84b1
--- /dev/null
+++ b/sources/pyside6/tests/QtQml/qmlregistertype_test.qml
@@ -0,0 +1,7 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import test
+
+ChildClass {
+}
diff --git a/sources/pyside6/tests/QtQml/qqmlcomponent_test.py b/sources/pyside6/tests/QtQml/qqmlcomponent_test.py
new file mode 100644
index 000000000..5521c64fa
--- /dev/null
+++ b/sources/pyside6/tests/QtQml/qqmlcomponent_test.py
@@ -0,0 +1,36 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtCore import Property, QObject
+from PySide6.QtQml import QQmlComponent
+
+
+class WithComponent(QObject):
+    def get_component(self):
+        return None
+
+    component = Property(QQmlComponent, fget=get_component)
+
+
+class TestQmlSupport(unittest.TestCase):
+
+    def testMetatypeValid(self):
+        m = WithComponent.staticMetaObject
+        c = m.property(m.indexOfProperty("component"))
+
+        self.assertTrue(c.typeId() > 0)
+        self.assertTrue(c.typeName() == "QQmlComponent*")
+        self.assertTrue(c.metaType().isValid())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtQml/qquickview_test.py b/sources/pyside6/tests/QtQml/qquickview_test.py
index 5cf5550ed..226509669 100644
--- a/sources/pyside6/tests/QtQml/qquickview_test.py
+++ b/sources/pyside6/tests/QtQml/qquickview_test.py
@@ -22,6 +22,7 @@ from PySide6.QtQuick import QQuickView
 
 class MyObject(QObject):
     titleChanged = Signal()
+
     def __init__(self, text, parent=None):
         QObject.__init__(self, parent)
         self._text = text
diff --git a/sources/pyside6/tests/QtQml/registersingletontype.py b/sources/pyside6/tests/QtQml/registersingletontype.py
index f2e318e46..6beca1131 100644
--- a/sources/pyside6/tests/QtQml/registersingletontype.py
+++ b/sources/pyside6/tests/QtQml/registersingletontype.py
@@ -12,13 +12,18 @@ init_test_paths(False)
 
 from helper.helper import quickview_errorstring
 
-from PySide6.QtCore import Property, Signal, QTimer, QUrl, QObject
+from PySide6.QtCore import Property, Signal, QTimer, QUrl, QObject, Slot
 from PySide6.QtGui import QGuiApplication
 from PySide6.QtQml import (qmlRegisterSingletonType, qmlRegisterSingletonInstance,
-                           QmlElement, QmlSingleton)
+                           QmlElement, QmlSingleton, QJSValue)
 from PySide6.QtQuick import QQuickView
 
+
+URI = "Singletons"
+
+
 finalResult = 0
+qObjectQmlTypeId = 0
 
 
 class SingletonQObject(QObject):
@@ -46,9 +51,10 @@ def singletonQJSValueCallback(engine):
     return engine.evaluate("new Object({data: 50})")
 
 
-QML_IMPORT_NAME = "Singletons"
+QML_IMPORT_NAME = URI
 QML_IMPORT_MAJOR_VERSION = 1
 
+
 @QmlElement
 @QmlSingleton
 class DecoratedSingletonQObject(QObject):
@@ -65,37 +71,82 @@ class DecoratedSingletonQObject(QObject):
     data = Property(int, getData, setData)
 
 
+@QmlElement
+@QmlSingleton
+class DecoratedSingletonWithCreate(QObject):
+    def __init__(self, data, parent=None):
+        super().__init__(parent)
+        self._data = data
+
+    @staticmethod
+    def create(engine):
+        return DecoratedSingletonWithCreate(400)
+
+    def getData(self):
+        return self._data
+
+    def setData(self, data):
+        self._data = data
+
+    data = Property(int, getData, setData)
+
+
+class TestQuickView(QQuickView):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._singleton_instance_qobject_int = False
+        self._singleton_instance_qobject_str = False
+        self._singleton_instance_jsvalue_int = False
+
+    @Slot()
+    def testSlot(self):
+        engine = self.engine()
+        instance = engine.singletonInstance(qObjectQmlTypeId)
+        if instance is not None and isinstance(instance, QObject):
+            self._singleton_instance_qobject_int = True
+        instance = engine.singletonInstance(URI, 'SingletonQObjectNoCallback')
+        if instance is not None and isinstance(instance, QObject):
+            self._singleton_instance_qobject_str = True
+        instance = engine.singletonInstance(URI, 'SingletonQJSValue')
+        if instance is not None and isinstance(instance, QJSValue):
+            self._singleton_instance_jsvalue_int = True
+        self.close()
+
+
 class TestQmlSupport(unittest.TestCase):
     def testIt(self):
         app = QGuiApplication([])
 
-        qmlRegisterSingletonType(SingletonQObject, 'Singletons', 1, 0, 'SingletonQObjectNoCallback')
-        qmlRegisterSingletonType(SingletonQObject, 'Singletons', 1, 0, 'SingletonQObjectCallback',
+        qObjectQmlTypeId = qmlRegisterSingletonType(SingletonQObject, URI, 1, 0,
+                                                    'SingletonQObjectNoCallback')
+        qmlRegisterSingletonType(SingletonQObject, URI, 1, 0, 'SingletonQObjectCallback',
                                  singletonQObjectCallback)
 
-        qmlRegisterSingletonType('Singletons', 1, 0, 'SingletonQJSValue', singletonQJSValueCallback)
+        qmlRegisterSingletonType(URI, 1, 0, 'SingletonQJSValue', singletonQJSValueCallback)
 
         # Accepts only QObject derived types
         l = [1, 2]
         with self.assertRaises(TypeError):
-            qmlRegisterSingletonInstance(SingletonQObject, 'Singletons', 1, 0, 'SingletonInstance', l)
+            qmlRegisterSingletonInstance(SingletonQObject, URI, 1, 0, 'SingletonInstance', l)
 
         # Modify value on the instance
         s = SingletonQObject()
         s.setData(99)
-        qmlRegisterSingletonInstance(SingletonQObject, 'Singletons', 1, 0, 'SingletonInstance', s)
+        qmlRegisterSingletonInstance(SingletonQObject, URI, 1, 0, 'SingletonInstance', s)
 
-        view = QQuickView()
+        view = TestQuickView()
         file = Path(__file__).resolve().parent / 'registersingletontype.qml'
         self.assertTrue(file.is_file())
         view.setSource(QUrl.fromLocalFile(file))
         self.assertTrue(view.rootObject(), quickview_errorstring(view))
         view.resize(200, 200)
         view.show()
-        QTimer.singleShot(250, view.close)
+        QTimer.singleShot(250, view.testSlot)
         app.exec()
-        self.assertEqual(finalResult, 499)
+        self.assertEqual(finalResult, 899)
+        self.assertTrue(view._singleton_instance_qobject_int)
+        self.assertTrue(view._singleton_instance_qobject_str)
+        self.assertTrue(view._singleton_instance_jsvalue_int)
 
 
-if __name__ == '__main__':
-    unittest.main()
+if __name__ == '__main__':    unittest.main()
diff --git a/sources/pyside6/tests/QtQml/registersingletontype.qml b/sources/pyside6/tests/QtQml/registersingletontype.qml
index 4c45b198e..31ca7fe4d 100644
--- a/sources/pyside6/tests/QtQml/registersingletontype.qml
+++ b/sources/pyside6/tests/QtQml/registersingletontype.qml
@@ -9,6 +9,6 @@ Item {
         SingletonQObjectCallback.data += SingletonQObjectNoCallback.data
             + SingletonQJSValue.data
             + SingletonInstance.data
-            + DecoratedSingletonQObject.data;
+            + DecoratedSingletonQObject.data + DecoratedSingletonWithCreate.data;
     }
 }
diff --git a/sources/pyside6/tests/QtQml/signal_arguments.py b/sources/pyside6/tests/QtQml/signal_arguments.py
index 304c83ca3..f5b0f8bd3 100644
--- a/sources/pyside6/tests/QtQml/signal_arguments.py
+++ b/sources/pyside6/tests/QtQml/signal_arguments.py
@@ -20,6 +20,7 @@ from PySide6.QtQml import QmlElement
 QML_IMPORT_NAME = "test.Obj"
 QML_IMPORT_MAJOR_VERSION = 1
 
+
 @QmlElement
 class Obj(QObject):
     def __init__(self):
diff --git a/sources/pyside6/tests/QtQuickTest/CMakeLists.txt b/sources/pyside6/tests/QtQuickTest/CMakeLists.txt
new file mode 100644
index 000000000..49f15e447
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/CMakeLists.txt
@@ -0,0 +1,3 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+PYSIDE_TEST(quicktestmainwithsetup/tst_quicktestmainwithsetup.py)
diff --git a/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/data/tst_setup.qml b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/data/tst_setup.qml
new file mode 100644
index 000000000..2cfe936a6
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/data/tst_setup.qml
@@ -0,0 +1,20 @@
+// Copyright (C) 2018 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import QtQuick 2.0
+import QtTest 1.2
+
+import QmlRegisterTypeCppModule 1.0
+import ImportPathQmlModule 1.0
+
+TestCase {
+    name: "setup"
+
+    QmlRegisterTypeCppType {}
+    ImportPathQmlType {}
+
+    function initTestCase()
+    {
+        verify(qmlEngineAvailableCalled)
+    }
+}
diff --git a/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/ImportPathQmlType.qml b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/ImportPathQmlType.qml
new file mode 100644
index 000000000..617bdaaf6
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/ImportPathQmlType.qml
@@ -0,0 +1,3 @@
+import QtQuick 2.0
+
+Item {}
diff --git a/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/qmldir b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/qmldir
new file mode 100644
index 000000000..dea7c9a8a
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/imports/ImportPathQmlModule/qmldir
@@ -0,0 +1,2 @@
+module ImportPathQmlModule
+ImportPathQmlType 1.0 ImportPathQmlType.qml
diff --git a/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/quicktestmainwithsetup.pyproject b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/quicktestmainwithsetup.pyproject
new file mode 100644
index 000000000..61e89f4af
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/quicktestmainwithsetup.pyproject
@@ -0,0 +1,4 @@
+{
+    "files": ["tst_quicktestmainwithsetup.py", "data/tst_setup.qml",
+              "imports/ImportPathQmlModule/ImportPathQmlType.qml"]
+}
diff --git a/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/tst_quicktestmainwithsetup.py b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/tst_quicktestmainwithsetup.py
new file mode 100644
index 000000000..33b2db08f
--- /dev/null
+++ b/sources/pyside6/tests/QtQuickTest/quicktestmainwithsetup/tst_quicktestmainwithsetup.py
@@ -0,0 +1,46 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[2]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from pathlib import Path
+from PySide6.QtCore import QObject, Slot
+from PySide6.QtQml import QQmlEngine, qmlRegisterType
+from PySide6.QtQuickTest import QUICK_TEST_MAIN_WITH_SETUP
+
+
+"""Copy of the equivalent test in qtdeclarative."""
+
+
+class QmlRegisterTypeCppType(QObject):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+
+class CustomTestSetup(QObject):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+    @Slot(QQmlEngine)
+    def qmlEngineAvailable(self, qmlEngine):
+        # Test that modules are successfully imported by the TestCaseCollector
+        # that parses the QML files (but doesn't run them). For that to happen,
+        # qmlEngineAvailable() must be called before TestCaseCollector does its
+        # thing.
+        qmlRegisterType(QmlRegisterTypeCppType, "QmlRegisterTypeCppModule", 1, 0,
+                        "QmlRegisterTypeCppType")
+        import_dir = Path(__file__).parent / "imports"
+        qmlEngine.addImportPath(os.fspath(import_dir))
+        qmlEngine.rootContext().setContextProperty("qmlEngineAvailableCalled", True)
+
+
+data_dir = Path(__file__).parent / "data"
+exitCode = QUICK_TEST_MAIN_WITH_SETUP("qquicktestsetup", CustomTestSetup, sys.argv,
+                                      os.fspath(data_dir))
+sys.exit(exitCode)
diff --git a/sources/pyside6/tests/QtScxml/test_dynamic.py b/sources/pyside6/tests/QtScxml/test_dynamic.py
index 0a5cba1ee..212d6f7c1 100644
--- a/sources/pyside6/tests/QtScxml/test_dynamic.py
+++ b/sources/pyside6/tests/QtScxml/test_dynamic.py
@@ -11,25 +11,42 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.timedqapplication import TimedQApplication
-from PySide6.QtCore import QObject, SIGNAL
-from PySide6.QtScxml import QScxmlStateMachine
+from PySide6.QtCore import QCoreApplication, QObject, Slot, SIGNAL, SLOT
+from PySide6.QtScxml import QScxmlStateMachine, QScxmlEvent
+
+
+class Receiver(QObject):
+    def __init__(self):
+        super().__init__()
+        self.eventReceived = False
+        self.reachedStable = False
+
+    @Slot(QScxmlEvent)
+    def handleEvent(self, event):
+        self.eventReceived = True
+
+    @Slot()
+    def slotReachedStable(self):
+        self.reachedStable = True
 
 
 class testDynamicStateMachine(TimedQApplication):
     def setUp(self):
-        super(testDynamicStateMachine, self).setUp()
-        filePath = os.path.join(os.path.dirname(__file__), 'trafficlight.scxml')
-        self.assertTrue(os.path.exists(filePath))
-        self._machine = QScxmlStateMachine.fromFile(filePath)
-        self._machine.reachedStableState.connect(self._reachedStable())
+        super().setUp()
+        filePath = Path(__file__).parent / "trafficlight.scxml"
+        self.assertTrue(filePath.is_file())
+        self._machine = QScxmlStateMachine.fromFile(os.fspath(filePath))
+        self._receiver = Receiver()
+        self._machine.connectToEvent("*", self._receiver,
+                                     SLOT("handleEvent(QScxmlEvent)"))
+        self._machine.reachedStableState.connect(self._receiver.slotReachedStable)
         self.assertTrue(not self._machine.parseErrors())
         self.assertTrue(self._machine)
 
-    def _reachedStable(self):
-        self.app.quit()
-
     def test(self):
         self._machine.start()
+        while not self._receiver.reachedStable and not self._receiver.eventReceived:
+            QCoreApplication.processEvents()
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtSql/CMakeLists.txt b/sources/pyside6/tests/QtSql/CMakeLists.txt
index 8db3a9813..eedb31e98 100644
--- a/sources/pyside6/tests/QtSql/CMakeLists.txt
+++ b/sources/pyside6/tests/QtSql/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(bug_1013.py)
 PYSIDE_TEST(qsqldatabaseandqueries_test.py)
 PYSIDE_TEST(qvarianttype_test.py)
diff --git a/sources/pyside6/tests/QtSql/qsqldatabaseandqueries_test.py b/sources/pyside6/tests/QtSql/qsqldatabaseandqueries_test.py
index 2872696cc..a3e70a3a7 100644
--- a/sources/pyside6/tests/QtSql/qsqldatabaseandqueries_test.py
+++ b/sources/pyside6/tests/QtSql/qsqldatabaseandqueries_test.py
@@ -16,6 +16,7 @@ init_test_paths(False)
 
 from PySide6.QtSql import QSqlDatabase, QSqlQuery, QSqlTableModel
 from PySide6.QtWidgets import QApplication, QWidget
+from helper.usesqapplication import UsesQApplication
 
 
 class Foo(QWidget):
@@ -24,11 +25,12 @@ class Foo(QWidget):
         self.model = QSqlTableModel()
 
 
-class SqlDatabaseCreationDestructionAndQueries(unittest.TestCase):
+class SqlDatabaseCreationDestructionAndQueries(UsesQApplication):
     '''Test cases for QtSql database creation, destruction and queries'''
 
     def setUp(self):
         # Acquire resources
+        super().setUp()
         self.assertFalse(not QSqlDatabase.drivers(), "installed Qt has no DB drivers")
         self.assertTrue("QSQLITE" in QSqlDatabase.drivers(), "\"QSQLITE\" driver not available in this Qt version")
         self.db = QSqlDatabase.addDatabase("QSQLITE")
@@ -42,6 +44,7 @@ class SqlDatabaseCreationDestructionAndQueries(unittest.TestCase):
         del self.db
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
+        super().tearDown()
 
     def testTableCreationAndDestruction(self):
         # Test table creation and destruction
@@ -71,12 +74,9 @@ class SqlDatabaseCreationDestructionAndQueries(unittest.TestCase):
         self.assertEqual(lastname, 'Harrison')
 
     def testTableModelDeletion(self):
-        app = QApplication([])
-
         bar = Foo()
         model = bar.model
         del bar
-        del app
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
diff --git a/sources/pyside6/tests/QtSql/qvarianttype_test.py b/sources/pyside6/tests/QtSql/qvarianttype_test.py
index c2790cabf..3999be20e 100644
--- a/sources/pyside6/tests/QtSql/qvarianttype_test.py
+++ b/sources/pyside6/tests/QtSql/qvarianttype_test.py
@@ -17,8 +17,7 @@ from PySide6.QtSql import QSqlField
 
 class QVariantTypeTest(unittest.TestCase):
     def testQVariantType(self):
-        new_enum = sys.pyside63_option_python_enum
-        cmp_id = QMetaType.QString.value if new_enum else QMetaType.QString
+        cmp_id = QMetaType.QString.value
 
         f = QSqlField("name", QMetaType(QMetaType.QString))
         self.assertEqual(f.metaType().id(), cmp_id)
diff --git a/sources/pyside6/tests/QtStateMachine/CMakeLists.txt b/sources/pyside6/tests/QtStateMachine/CMakeLists.txt
index 2d41653af..e42f8cc8b 100644
--- a/sources/pyside6/tests/QtStateMachine/CMakeLists.txt
+++ b/sources/pyside6/tests/QtStateMachine/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(bug_1031.py)
 PYSIDE_TEST(qabstracttransition_test.py)
 PYSIDE_TEST(qstatemachine_test.py)
diff --git a/sources/pyside6/tests/QtStateMachine/qstatemachine_test.py b/sources/pyside6/tests/QtStateMachine/qstatemachine_test.py
index 59203a354..5e17b3a1f 100644
--- a/sources/pyside6/tests/QtStateMachine/qstatemachine_test.py
+++ b/sources/pyside6/tests/QtStateMachine/qstatemachine_test.py
@@ -15,10 +15,10 @@ from PySide6.QtCore import (QObject, QParallelAnimationGroup,
                             QPropertyAnimation, QTimer, SIGNAL)
 from PySide6.QtStateMachine import (QFinalState, QState, QStateMachine)
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class QStateMachineTest(UsesQCoreApplication):
+class QStateMachineTest(UsesQApplication):
 
     def cb(self, *args):
         self.assertEqual(self.machine.defaultAnimations(), [self.anim])
@@ -44,7 +44,7 @@ class QStateMachineTest(UsesQCoreApplication):
         self.app.exec()
 
 
-class QSetConverterTest(UsesQCoreApplication):
+class QSetConverterTest(UsesQApplication):
     '''Test converter of QSet toPython using QStateAnimation.configuration'''
 
     def testBasic(self):
diff --git a/sources/pyside6/tests/QtTest/CMakeLists.txt b/sources/pyside6/tests/QtTest/CMakeLists.txt
index c7d142dc4..21a585ea4 100644
--- a/sources/pyside6/tests/QtTest/CMakeLists.txt
+++ b/sources/pyside6/tests/QtTest/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(click_test.py)
 PYSIDE_TEST(eventfilter_test.py)
 # The test is currently permanently broken, needs to be fixed.
diff --git a/sources/pyside6/tests/QtTextToSpeech/qtexttospeech_test.py b/sources/pyside6/tests/QtTextToSpeech/qtexttospeech_test.py
index 53e0c4cc4..6ff66c047 100644
--- a/sources/pyside6/tests/QtTextToSpeech/qtexttospeech_test.py
+++ b/sources/pyside6/tests/QtTextToSpeech/qtexttospeech_test.py
@@ -16,6 +16,7 @@ init_test_paths(False)
 from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QApplication
 
 try:
     from PySide6.QtTextToSpeech import QTextToSpeech, QVoice
@@ -28,6 +29,8 @@ class QTextToSpeechTestCase(UsesQApplication):
     '''Tests related to QTextToSpeech'''
     def testSay(self):
         engines = QTextToSpeech.availableEngines()
+        if len(engines) > 1 and engines[0] == "mock":
+            engines[0], engines[1] = engines[1], engines[0]
         if not engines:
             print('No QTextToSpeech engines available')
         else:
diff --git a/sources/pyside6/tests/QtUiTools/CMakeLists.txt b/sources/pyside6/tests/QtUiTools/CMakeLists.txt
index 68ed7f134..08c6f1577 100644
--- a/sources/pyside6/tests/QtUiTools/CMakeLists.txt
+++ b/sources/pyside6/tests/QtUiTools/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(bug_360.py)
 PYSIDE_TEST(bug_376.py)
 PYSIDE_TEST(bug_392.py)
diff --git a/sources/pyside6/tests/QtUiTools/bug_1060.py b/sources/pyside6/tests/QtUiTools/bug_1060.py
index c247cf9fd..52624a2a9 100644
--- a/sources/pyside6/tests/QtUiTools/bug_1060.py
+++ b/sources/pyside6/tests/QtUiTools/bug_1060.py
@@ -27,6 +27,6 @@ if __name__ == "__main__":
     app = QApplication([])
 
     file = Path(__file__).resolve().parent / 'bug_1060.ui'
-    assert(file.is_file())
+    assert (file.is_file())
     ui = MyQUiLoader().load(file)
     ui.show()
diff --git a/sources/pyside6/tests/QtUiTools/bug_552.py b/sources/pyside6/tests/QtUiTools/bug_552.py
index ce040f4fb..06a6b72a4 100644
--- a/sources/pyside6/tests/QtUiTools/bug_552.py
+++ b/sources/pyside6/tests/QtUiTools/bug_552.py
@@ -21,7 +21,7 @@ class View_1(QWidget):
         super().__init__()
         loader = QUiLoader()
         file = Path(__file__).resolve().parent / 'bug_552.ui'
-        assert(file.is_file())
+        assert (file.is_file())
         widget = loader.load(os.fspath(file), self)
         self.children = []
         for child in widget.findChildren(QObject, None):
diff --git a/sources/pyside6/tests/QtUiTools/bug_797.py b/sources/pyside6/tests/QtUiTools/bug_797.py
index b87ca1293..3dae7afb7 100644
--- a/sources/pyside6/tests/QtUiTools/bug_797.py
+++ b/sources/pyside6/tests/QtUiTools/bug_797.py
@@ -18,7 +18,7 @@ from PySide6.QtWidgets import QApplication, QWidget
 app = QApplication([])
 loader = QUiLoader()
 file = Path(__file__).resolve().parent / 'bug_552.ui'
-assert(file.is_file())
+assert (file.is_file())
 file = QFile(file)
 w = QWidget()
 # An exception can't be thrown
diff --git a/sources/pyside6/tests/QtUiTools/bug_958.py b/sources/pyside6/tests/QtUiTools/bug_958.py
index 69f57b03e..2f8dfab62 100644
--- a/sources/pyside6/tests/QtUiTools/bug_958.py
+++ b/sources/pyside6/tests/QtUiTools/bug_958.py
@@ -23,7 +23,7 @@ class Gui_Qt(QMainWindow):
 
         # this used to cause a segfault because the old inject code used to destroy the parent layout
         file = Path(__file__).resolve().parent / 'bug_958.ui'
-        assert(file.is_file())
+        assert (file.is_file())
         self._cw = lLoader.load(file, self)
 
         self.setCentralWidget(self._cw)
diff --git a/sources/pyside6/tests/QtWidgets/CMakeLists.txt b/sources/pyside6/tests/QtWidgets/CMakeLists.txt
index 5989c0625..01b7d08ea 100644
--- a/sources/pyside6/tests/QtWidgets/CMakeLists.txt
+++ b/sources/pyside6/tests/QtWidgets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 #Keep this in alphabetical sort
 
 PYSIDE_TEST(action_clear.py)
@@ -81,6 +84,7 @@ PYSIDE_TEST(qapp_issue_585.py)
 PYSIDE_TEST(qapp_test.py)
 PYSIDE_TEST(qapplication_test.py)
 PYSIDE_TEST(qapplication_exit_segfault_test.py)
+PYSIDE_TEST(qdialog_test.py)
 PYSIDE_TEST(qdynamic_signal.py)
 # TODO: This passes, but requires manual button clicking (at least on mac)
 #PYSIDE_TEST(qfontdialog_test.py)
diff --git a/sources/pyside6/tests/QtWidgets/bug_400.py b/sources/pyside6/tests/QtWidgets/bug_400.py
index 6e99fbd05..79dfa49fc 100644
--- a/sources/pyside6/tests/QtWidgets/bug_400.py
+++ b/sources/pyside6/tests/QtWidgets/bug_400.py
@@ -27,7 +27,7 @@ class BugTest(UsesQApplication):
         treeWidget.insertTopLevelItems(0, items)
         _iter = QTreeWidgetItemIterator(treeWidget)
         index = 0
-        while(_iter.value()):
+        while (_iter.value()):
             item = _iter.value()
             self.assertTrue(item is items[index])
             index += 1
diff --git a/sources/pyside6/tests/QtWidgets/bug_662.py b/sources/pyside6/tests/QtWidgets/bug_662.py
index 9b6f1ed39..e3a3130d0 100644
--- a/sources/pyside6/tests/QtWidgets/bug_662.py
+++ b/sources/pyside6/tests/QtWidgets/bug_662.py
@@ -17,7 +17,8 @@ import sys
 
 
 class testQTextBlock(unittest.TestCase):
-    def tesIterator(self):
+
+    def testIterator(self):
         edit = QTextEdit()
         cursor = edit.textCursor()
         fmt = QTextCharFormat()
diff --git a/sources/pyside6/tests/QtWidgets/bug_667.py b/sources/pyside6/tests/QtWidgets/bug_667.py
index 414b3d829..be6700d83 100644
--- a/sources/pyside6/tests/QtWidgets/bug_667.py
+++ b/sources/pyside6/tests/QtWidgets/bug_667.py
@@ -17,7 +17,7 @@ from PySide6.QtWidgets import QApplication, QGraphicsView, QGraphicsScene, QGrap
 class Ball(QGraphicsEllipseItem):
     def __init__(self, d, parent=None):
         super().__init__(0, 0, d, d, parent)
-        self.vel = QPointF(0, 0)   #commenting this out prevents the crash
+        self.vel = QPointF(0, 0)   # commenting this out prevents the crash
 
 
 class Foo(QGraphicsView):
diff --git a/sources/pyside6/tests/QtWidgets/bug_854.py b/sources/pyside6/tests/QtWidgets/bug_854.py
index f99bf6b08..1dbfd4b3a 100644
--- a/sources/pyside6/tests/QtWidgets/bug_854.py
+++ b/sources/pyside6/tests/QtWidgets/bug_854.py
@@ -10,8 +10,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtWidgets import QTableView, QVBoxLayout, QApplication
-from PySide6.QtCore import QAbstractItemModel
+from PySide6.QtWidgets import QTableView, QApplication
+from PySide6.QtCore import QAbstractItemModel, QModelIndex
 
 from helper.usesqapplication import UsesQApplication
 
diff --git a/sources/pyside6/tests/QtWidgets/paint_event_test.py b/sources/pyside6/tests/QtWidgets/paint_event_test.py
index f63d8a565..d995c2a37 100644
--- a/sources/pyside6/tests/QtWidgets/paint_event_test.py
+++ b/sources/pyside6/tests/QtWidgets/paint_event_test.py
@@ -26,7 +26,7 @@ class MyWidget(QWidget):
 
     def __init__(self, app):
         # Creates a new widget
-        assert(app)
+        assert (app)
 
         super().__init__()
         self.app = app
diff --git a/sources/pyside6/tests/QtWidgets/qdialog_test.py b/sources/pyside6/tests/QtWidgets/qdialog_test.py
new file mode 100644
index 000000000..cb85ce7e2
--- /dev/null
+++ b/sources/pyside6/tests/QtWidgets/qdialog_test.py
@@ -0,0 +1,52 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+import weakref
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtCore import Slot, QTimer
+from PySide6.QtWidgets import QDialog, QMainWindow
+from helper.timedqapplication import TimedQApplication
+
+
+class Window(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Main")
+        self.dialog = None
+
+    @Slot()
+    def execDialog(self):
+        dialog = QDialog(self)
+        self.dialog = weakref.ref(dialog)
+        dialog.setWindowTitle("Dialog")
+        dialog.setMinimumWidth(200)
+        QTimer.singleShot(500, dialog.reject)
+        dialog.exec()
+        self.close()
+
+
+class DialogExecTest(TimedQApplication):
+    """Test whether the parent-child relationship (dialog/main window) is removed when
+       using QDialog.exec() (instead show()), preventing the dialog from leaking."""
+
+    def setUp(self):
+        super().setUp(10000)
+        self._window = Window()
+
+    def testExec(self):
+        self._window.show()
+        QTimer.singleShot(500, self._window.execDialog)
+        self.app.exec()
+        self.assertTrue(self._window.dialog() is None)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/QtWidgets/qlabel_test.py b/sources/pyside6/tests/QtWidgets/qlabel_test.py
index 4ec8cb981..aba90b7b8 100644
--- a/sources/pyside6/tests/QtWidgets/qlabel_test.py
+++ b/sources/pyside6/tests/QtWidgets/qlabel_test.py
@@ -64,7 +64,7 @@ class QLabelTest(UsesQApplication):
         # address that our QPixmap p1 because it was deleted
         # using `del ret_p`
         self.assertTrue(all(Shiboken.getCppPointer(o) != ret_p_addr
-                   for o in Shiboken.getAllValidWrappers()))
+                        for o in Shiboken.getAllValidWrappers()))
 
     # Test for PYSIDE-1673, QObject.property() returning a QFlags<> property.
     def testQObjectProperty(self):
diff --git a/sources/pyside6/tests/QtWidgets/qmenu_test.py b/sources/pyside6/tests/QtWidgets/qmenu_test.py
index 8f93c6f93..a6976a637 100644
--- a/sources/pyside6/tests/QtWidgets/qmenu_test.py
+++ b/sources/pyside6/tests/QtWidgets/qmenu_test.py
@@ -37,11 +37,11 @@ class QMenuAddAction(UsesQApplication):
     def testAddActionKeySequenceCallable(self):
         # bug #228
         action = self.menu.addAction(self.app.tr('aaa'), lambda: 1,
-                                    QKeySequence(self.app.tr('Ctrl+O')))
+                                     QKeySequence(self.app.tr('Ctrl+O')))
 
     def testAddActionKeySequenceSlot(self):
         action = self.menu.addAction('Quit', self.app, SLOT('quit()'),
-                                    QKeySequence('Ctrl+O'))
+                                     QKeySequence('Ctrl+O'))
 
 
 class QMenuAddActionWithIcon(UsesQApplication):
@@ -65,11 +65,11 @@ class QMenuAddActionWithIcon(UsesQApplication):
     def testAddActionKeySequenceCallable(self):
         # bug #228
         action = self.menu.addAction(self.icon, self.app.tr('aaa'), lambda: 1,
-                                    QKeySequence(self.app.tr('Ctrl+O')))
+                                     QKeySequence(self.app.tr('Ctrl+O')))
 
     def testAddActionKeySequenceSlot(self):
         action = self.menu.addAction(self.icon, 'Quit', self.app, SLOT('quit()'),
-                                    QKeySequence('Ctrl+O'))
+                                     QKeySequence('Ctrl+O'))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtWidgets/qstyle_test.py b/sources/pyside6/tests/QtWidgets/qstyle_test.py
index 9b8872f84..5a9b29dc6 100644
--- a/sources/pyside6/tests/QtWidgets/qstyle_test.py
+++ b/sources/pyside6/tests/QtWidgets/qstyle_test.py
@@ -15,7 +15,7 @@ from helper.usesqapplication import UsesQApplication
 
 from PySide6.QtGui import QWindow
 from PySide6.QtWidgets import (QApplication, QFontComboBox, QLabel, QProxyStyle,
-    QStyleFactory, QWidget)
+                               QStyleFactory, QWidget)
 
 
 class ProxyStyle(QProxyStyle):
diff --git a/sources/pyside6/tests/QtWidgets/qtreeview_test.py b/sources/pyside6/tests/QtWidgets/qtreeview_test.py
index 6e046e9d7..fd535bfad 100644
--- a/sources/pyside6/tests/QtWidgets/qtreeview_test.py
+++ b/sources/pyside6/tests/QtWidgets/qtreeview_test.py
@@ -13,7 +13,7 @@ init_test_paths(False)
 
 from PySide6.QtGui import QStandardItemModel
 from PySide6.QtWidgets import (QWidget, QTreeView, QVBoxLayout,
-    QStyledItemDelegate, QHeaderView)
+                               QStyledItemDelegate, QHeaderView)
 from PySide6.QtCore import Qt
 from helper.usesqapplication import UsesQApplication
 
diff --git a/sources/pyside6/tests/QtWidgets/qvariant_test.py b/sources/pyside6/tests/QtWidgets/qvariant_test.py
index edb4855c1..fe0266309 100644
--- a/sources/pyside6/tests/QtWidgets/qvariant_test.py
+++ b/sources/pyside6/tests/QtWidgets/qvariant_test.py
@@ -13,7 +13,7 @@ init_test_paths(False)
 
 from PySide6.QtCore import Qt, QObject
 from PySide6.QtWidgets import (QComboBox, QGraphicsScene,
-    QGraphicsRectItem)
+                               QGraphicsRectItem)
 
 from helper.usesqapplication import UsesQApplication
 
@@ -114,8 +114,8 @@ class QVariantConversionTest(UsesQApplication):
 
     def testContainerTypes(self):
         #list
-        self.obj.setProperty("test", [1,2,3])
-        self.assertEqual(self.obj.property("test"), [1,2,3])
+        self.obj.setProperty("test", [1, 2, 3])
+        self.assertEqual(self.obj.property("test"), [1, 2, 3])
         self.assertTrue(isinstance(self.obj.property("test"), list))
         #dict
         self.obj.setProperty("test", {1: "one"})
diff --git a/sources/pyside6/tests/QtXml/qdomdocument_test.py b/sources/pyside6/tests/QtXml/qdomdocument_test.py
index 33b395f9b..cfc1c543d 100644
--- a/sources/pyside6/tests/QtXml/qdomdocument_test.py
+++ b/sources/pyside6/tests/QtXml/qdomdocument_test.py
@@ -47,7 +47,6 @@ class QDomDocumentTest(unittest.TestCase):
         self.assertFalse(ok)
         self.assertEqual(errorStr, 'Opening and ending tag mismatch.')
         self.assertEqual(errorLine, 4)
-        self.assertEqual(errorColumn, 21)
 
     def testQDomDocumentSetContentWithGoodXmlData(self):
         '''Sets valid xml as the QDomDocument contents.'''
diff --git a/sources/pyside6/tests/manually/lazytiming.py b/sources/pyside6/tests/manually/lazytiming.py
new file mode 100644
index 000000000..59f75bc46
--- /dev/null
+++ b/sources/pyside6/tests/manually/lazytiming.py
@@ -0,0 +1,38 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+"""
+Time a repeated Python run
+--------------------------
+
+Usage: python3 lazytiming.py              # uses PySide6
+       python3 lazytiming.py <any arg>    # uses PyQt6
+
+It runs the same python for the testing.
+
+Actually comparing PySide6 and PyQt6 in action:
+
+    PYSIDE6_OPTION_LAZY=0 python3 sources/pyside6/tests/manually/lazytiming.py      # normal
+    PYSIDE6_OPTION_LAZY=1 python3 sources/pyside6/tests/manually/lazytiming.py      # faster
+                          python3 sources/pyside6/tests/manually/lazytiming.py xxx  # PyQt
+"""
+import subprocess
+import sys
+
+from timeit import default_timer as timer
+
+repeats = 100
+test1 = "PySide6"
+test2 = "PyQt6"
+
+test = test2 if sys.argv[1:] else test1
+cmd = [sys.executable, "-c", f"from {test} import QtCore, QtGui, QtWidgets"]
+
+print(f"{repeats} * {test}")
+
+subprocess.call(cmd)        # warmup
+start_time = timer()
+for idx in range(repeats):
+    subprocess.call(cmd)
+stop_time = timer()
+print(f"time per run = {(stop_time - start_time) / repeats}")
diff --git a/sources/pyside6/tests/pysidetest/CMakeLists.txt b/sources/pyside6/tests/pysidetest/CMakeLists.txt
index 76a8e02f5..38f42f342 100644
--- a/sources/pyside6/tests/pysidetest/CMakeLists.txt
+++ b/sources/pyside6/tests/pysidetest/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 project(pysidetest)
 project(testbinding)
 
@@ -17,12 +20,15 @@ add_definitions(-DRXX_ALLOCATOR_INIT_0)
 find_package(Qt6 REQUIRED COMPONENTS Widgets)
 
 set(pysidetest_SRC
-containertest.cpp
-flagstest.cpp
-testobject.cpp
-testview.cpp
-hiddenobject.cpp
-sharedpointertestbench.cpp
+containertest.cpp containertest.h
+flagstest.cpp flagstest.h
+hiddenobject.cpp hiddenobject.h
+pysidetest_global.h
+pysidetest_macros.h
+sharedpointertestbench.cpp sharedpointertestbench.h
+testobject.cpp testobject.h
+testview.cpp testview.h
+testqvariantenum.cpp testqvariantenum.h
 )
 
 set(testbinding_SRC
@@ -39,6 +45,8 @@ ${CMAKE_CURRENT_BINARY_DIR}/testbinding/qsharedpointer_int_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/testbinding/sharedpointertestbench_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/testbinding/testview_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/testbinding/testbinding_module_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/testbinding/testqvariantenum_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/testbinding/qvariantholder_wrapper.cpp
 )
 
 # Get per module include dirs.
@@ -140,6 +148,7 @@ PYSIDE_TEST(iterable_test.py)
 PYSIDE_TEST(list_signal_test.py)
 PYSIDE_TEST(mixin_signal_slots_test.py)
 PYSIDE_TEST(modelview_test.py)
+PYSIDE_TEST(multiple_inheritance_test.py)
 PYSIDE_TEST(new_inherited_functions_test.py)
 PYSIDE_TEST(notify_id.py)
 PYSIDE_TEST(properties_test.py)
diff --git a/sources/pyside6/tests/pysidetest/constructor_properties_test.py b/sources/pyside6/tests/pysidetest/constructor_properties_test.py
index 9f1a9d43c..ec6e39821 100644
--- a/sources/pyside6/tests/pysidetest/constructor_properties_test.py
+++ b/sources/pyside6/tests/pysidetest/constructor_properties_test.py
@@ -36,7 +36,7 @@ class ConstructorPropertiesTest(unittest.TestCase):
     def testCallConstructor(self):
         label = QLabel(
             frameStyle=QFrame.Panel | QFrame.Sunken,    # QFrame attr, no property
-            lineWidth = 2,                              # QFrame property
+            lineWidth=2,                                # QFrame property
             text="first line\nsecond line",             # QLabel property
             alignment=Qt.AlignBottom | Qt.AlignRight    # QLabel property
         )
@@ -52,13 +52,13 @@ class ConstructorPropertiesTest(unittest.TestCase):
 
         label = QLabel(
             frame_style=QFrame.Panel | QFrame.Sunken,   # QFrame attr, no property
-            line_width = 2,                             # QFrame property
+            line_width=2,                               # QFrame property
             text="first line\nsecond line",             # QLabel property
             alignment=Qt.AlignBottom | Qt.AlignRight    # QLabel property
         )
         self.assertEqual(label.line_width(), 2)
         self.assertRaises(AttributeError, lambda: QLabel(
-            lineWidth = 2,                              # QFrame property
+            lineWidth=2,                                # QFrame property
         ))
 
     # PYSIDE-1705: The same with true_property
@@ -68,13 +68,13 @@ class ConstructorPropertiesTest(unittest.TestCase):
 
         label = QLabel(
             frameStyle=QFrame.Panel | QFrame.Sunken,    # QFrame attr, no property
-            lineWidth = 2,                              # QFrame property
+            lineWidth=2,                                # QFrame property
             text="first line\nsecond line",             # QLabel property
             alignment=Qt.AlignBottom | Qt.AlignRight    # QLabel property
         )
         self.assertEqual(label.lineWidth, 2)
         self.assertRaises(AttributeError, lambda: QLabel(
-            line_width = 2,                             # QFrame property
+            line_width=2,                               # QFrame property
         ))
 
     # PYSIDE-1705: The same with snake_case and true_property
@@ -84,13 +84,13 @@ class ConstructorPropertiesTest(unittest.TestCase):
 
         label = QLabel(
             frame_style=QFrame.Panel | QFrame.Sunken,   # QFrame attr, no property
-            line_width = 2,                             # QFrame property
+            line_width=2,                               # QFrame property
             text="first line\nsecond line",             # QLabel property
             alignment=Qt.AlignBottom | Qt.AlignRight    # QLabel property
         )
         self.assertEqual(label.line_width, 2)
         self.assertRaises(AttributeError, lambda: QLabel(
-            lineWidth = 2,                              # QFrame property
+            lineWidth=2,                                # QFrame property
         ))
 
 
diff --git a/sources/pyside6/tests/pysidetest/container_test.py b/sources/pyside6/tests/pysidetest/container_test.py
index 68c3638cd..c83e1f26c 100644
--- a/sources/pyside6/tests/pysidetest/container_test.py
+++ b/sources/pyside6/tests/pysidetest/container_test.py
@@ -44,13 +44,13 @@ class ContainerTestTest(unittest.TestCase):
         self.assertEqual(sort_values(m2), EXPECTED_DICT)
 
     def testList(self):
-        l1 = ContainerTest.createList();
+        l1 = ContainerTest.createList()
         self.assertEqual(l1, EXPECTED_LIST)
         l2 = ContainerTest.passThroughList(l1)
         self.assertEqual(l2, EXPECTED_LIST)
 
     def testSet(self):
-        s1 = ContainerTest.createSet();  # Order is not predictable
+        s1 = ContainerTest.createSet()  # Order is not predictable
         s2 = ContainerTest.passThroughSet(s1)
         self.assertEqual(sorted(list(s1)), sorted(list(s2)))
 
diff --git a/sources/pyside6/tests/pysidetest/enum_test.py b/sources/pyside6/tests/pysidetest/enum_test.py
index 158faf37c..832834530 100644
--- a/sources/pyside6/tests/pysidetest/enum_test.py
+++ b/sources/pyside6/tests/pysidetest/enum_test.py
@@ -15,6 +15,7 @@ from testbinding import Enum1, TestObjectWithoutNamespace
 
 import dis
 
+
 class ListConnectionTest(unittest.TestCase):
 
     def testEnumVisibility(self):
@@ -45,6 +46,7 @@ class ListConnectionTest(unittest.TestCase):
         self.assertFalse(Qt.AlignBottom < Qt.AlignHCenter)
         self.assertTrue(Qt.AlignBottom > Qt.AlignHCenter)
 
+
 # PYSIDE-1735: We are testing that opcodes do what they are supposed to do.
 #              This is needed in the PyEnum forgiveness mode where we need
 #              to introspect the code if an Enum was called with no args.
@@ -68,7 +70,11 @@ class InvestigateOpcodesTest(unittest.TestCase):
             res.append((ops[idx - 1][0], ops[idx][1] - ops[idx - 1][1]))
         return sorted(res, key=lambda x: (x[1], x[0]))
 
+    _sin = sys.implementation.name
+
+    @unittest.skipIf(hasattr(sys.flags, "nogil"), f"{_sin} has different opcodes")
     def testByteCode(self):
+        import dis
         # opname, opcode, arg
         result_1 = [('LOAD_GLOBAL', 116, 0),
                     ('LOAD_ATTR',   106, 1),
@@ -92,7 +98,7 @@ class InvestigateOpcodesTest(unittest.TestCase):
                         ('LOAD_CONST',    100, 0),
                         ('RETURN_VALUE',   83, None)]
 
-        if sys.version_info[:2] >= (3, 11):
+        if sys.version_info[:2] == (3, 11):
             # Note: Python 3.11 is a bit more complex because it can optimize itself.
             # Opcodes are a bit different, and a hidden second code object is used.
             # We investigate this a bit, because we want to be warned when things change.
@@ -131,7 +137,7 @@ class InvestigateOpcodesTest(unittest.TestCase):
                 for _ in range(times):
                     f()
 
-            code_quicken(self.probe_function2, QUICKENING_WARMUP_DELAY-1)
+            code_quicken(self.probe_function2, QUICKENING_WARMUP_DELAY - 1)
             self.assertEqual(self.read_code(self.probe_function2, adaptive=True), result_2)
             self.assertEqual(self.get_sizes(self.probe_function2, adaptive=True), sizes_2)
 
@@ -156,6 +162,21 @@ class InvestigateOpcodesTest(unittest.TestCase):
             self.assertEqual(self.read_code(self.probe_function2, adaptive=True), result_3)
             self.assertEqual(self.get_sizes(self.probe_function2, adaptive=True), sizes_3)
 
+        if sys.version_info[:2] >= (3, 12):
+
+            result_1 = [('RESUME', 151, 0),
+                        ('LOAD_GLOBAL', 116, 0),
+                        ('LOAD_ATTR', 106, 2),
+                        ('STORE_FAST', 125, 1),
+                        ('RETURN_CONST', 121, 0)]
+
+            result_2 = [('RESUME', 151, 0),
+                        ('LOAD_GLOBAL', 116, 1),
+                        ('LOAD_ATTR', 106, 2),
+                        ('CALL', 171, 0),
+                        ('STORE_FAST', 125, 1),
+                        ('RETURN_CONST', 121, 0)]
+
         self.assertEqual(self.read_code(self.probe_function1), result_1)
         self.assertEqual(self.read_code(self.probe_function2), result_2)
 
diff --git a/sources/pyside6/tests/pysidetest/flagstest.h b/sources/pyside6/tests/pysidetest/flagstest.h
index 9058561f6..b5c73c9bd 100644
--- a/sources/pyside6/tests/pysidetest/flagstest.h
+++ b/sources/pyside6/tests/pysidetest/flagstest.h
@@ -23,8 +23,10 @@ class PYSIDETEST_API ClassForEnum : public QObject
 {
     Q_OBJECT
 public:
+    Q_DISABLE_COPY_MOVE(ClassForEnum)
+
     ClassForEnum(FlagsNamespace::Options opt = FlagsNamespace::Option::NoOptions);
-    virtual ~ClassForEnum();
+    virtual ~ClassForEnum() override;
 };
 
 } // namespace FlagsNamespace
diff --git a/sources/pyside6/tests/pysidetest/hiddenobject.cpp b/sources/pyside6/tests/pysidetest/hiddenobject.cpp
index bba0de2ee..d4feabb66 100644
--- a/sources/pyside6/tests/pysidetest/hiddenobject.cpp
+++ b/sources/pyside6/tests/pysidetest/hiddenobject.cpp
@@ -8,7 +8,7 @@ void HiddenObject::callMe()
     m_called = true;
 }
 
-bool HiddenObject::wasCalled()
+bool HiddenObject::wasCalled() const
 {
     return m_called;
 }
diff --git a/sources/pyside6/tests/pysidetest/hiddenobject.h b/sources/pyside6/tests/pysidetest/hiddenobject.h
index e3d0abbef..f399be985 100644
--- a/sources/pyside6/tests/pysidetest/hiddenobject.h
+++ b/sources/pyside6/tests/pysidetest/hiddenobject.h
@@ -13,12 +13,12 @@ class HiddenObject : public QObject
 {
     Q_OBJECT
 public:
-    HiddenObject() : m_called(false) {}
+    HiddenObject() noexcept = default;
     Q_INVOKABLE void callMe();
 public Q_SLOTS:
-    bool wasCalled();
+    bool wasCalled() const;
 private:
-    bool m_called;
+    bool m_called = false;
 };
 
 // Return a instance of HiddenObject
diff --git a/sources/pyside6/tests/pysidetest/homonymoussignalandmethod_test.py b/sources/pyside6/tests/pysidetest/homonymoussignalandmethod_test.py
index 52c65e541..b58232a1b 100644
--- a/sources/pyside6/tests/pysidetest/homonymoussignalandmethod_test.py
+++ b/sources/pyside6/tests/pysidetest/homonymoussignalandmethod_test.py
@@ -99,8 +99,8 @@ class HomonymousMultipleInheritanceTest(unittest.TestCase):
 
     def testHomonymousMultipleInheritance(self):
         c = C()
-        self.assertEqual(c.method(), "M::method") # okay
-        self.assertEqual(c.signal(), "M::signal") # problem on PySide6 6.2.2
+        self.assertEqual(c.method(), "M::method")  # okay
+        self.assertEqual(c.signal(), "M::signal")  # problem on PySide6 6.2.2
         self.assertEqual(type(c.signal), SignalInstance)
 
 
diff --git a/sources/pyside6/tests/pysidetest/multiple_inheritance_test.py b/sources/pyside6/tests/pysidetest/multiple_inheritance_test.py
new file mode 100644
index 000000000..49550ba55
--- /dev/null
+++ b/sources/pyside6/tests/pysidetest/multiple_inheritance_test.py
@@ -0,0 +1,189 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from helper.usesqapplication import UsesQApplication
+from PySide6 import QtCore, QtGui, QtWidgets
+from PySide6.QtWidgets import QMainWindow, QLabel, QWidget
+
+
+def xprint(*args, **kw):
+    if "-v" in sys.argv:
+        print(*args, **kw)
+
+
+# This is the original testcase of PYSIDE-1564
+class Age(object):
+    def __init__(self, age=0, **kwds):
+        super().__init__(**kwds)
+
+        self.age = age
+
+
+class Person(QtCore.QObject, Age):
+    def __init__(self, name, **kwds):
+        super().__init__(**kwds)
+
+        self.name = name
+
+
+class OriginalMultipleInheritanceTest(unittest.TestCase):
+
+    def testIt(self):
+        xprint()
+        p = Person("Joe", age=38)
+        xprint(f"p.age = {p.age}")
+        # This would crash if MI does not work.
+
+# More tests follow:
+
+
+# mro ('C', 'A', 'QObject', 'Object', 'B', 'object')
+class A(QtCore.QObject):
+    def __init__(self, anna=77, **kw):
+        xprint(f'A: before init kw = {kw}')
+        super().__init__(**kw)
+        xprint('A: after init')
+
+
+class B:
+    def __init__(self, otto=6, age=7, **kw):
+        xprint(f'B: before init kw = {kw}')
+        if "killme" in kw:
+            raise AssertionError("asdf")
+        super().__init__(**kw)
+        self.age = age
+        xprint('B: after init')
+
+
+class C(A, B):
+    def __init__(self, **kw):
+        xprint(f'C: before init kw = {kw}')
+        super().__init__(**kw)
+        xprint('C: after init')
+
+
+# mro ('F', 'D', 'QCursor', 'E', 'QLabel', 'QFrame', 'QWidget', 'QObject',
+#      'QPaintDevice', 'Object', 'object')
+class D(QtGui.QCursor):
+    def __init__(self, anna=77, **kw):
+        xprint(f'D: before init kw = {kw}')
+        super().__init__(**kw)
+        xprint('D: after init')
+
+
+class E:
+    def __init__(self, age=7, **kw):
+        xprint(f'E: before init kw = {kw}')
+        super().__init__(**kw)
+        self.age = age
+        xprint('E: after init')
+
+
+class F(D, E, QtWidgets.QLabel):
+    def __init__(self, **kw):
+        xprint(f'F: before init kw = {kw}')
+        super().__init__(**kw)
+        xprint('F: after init')
+
+
+# mro ('I', 'G', 'QTextDocument', 'H', 'QLabel', 'QFrame', 'QWidget', 'QObject',
+#      'QPaintDevice', 'Object', 'object')
+# Similar, but this time we want to reach `H` without support from `super`.
+class G(QtGui.QTextDocument):
+    pass
+
+
+class H:
+    def __init__(self, age=7, **kw):
+        xprint(f'H: before init kw = {kw}')
+        super().__init__(**kw)
+        self.age = age
+        xprint('H: after init')
+
+
+class II(G, H, QtWidgets.QLabel):
+    pass
+
+
+# PYSIDE-2294: Friedemann's test adapted.
+#              We need to ignore positional args in mixin classes.
+class Ui_X_MainWindow(object):  # Emulating uic
+    def setupUi(self, MainWindow):
+        MainWindow.resize(400, 300)
+        self.lbl = QLabel(self)
+
+
+class MainWindow(QMainWindow, Ui_X_MainWindow):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setupUi(self)
+
+
+class AdditionalMultipleInheritanceTest(UsesQApplication):
+
+    def testABC(self):
+        xprint()
+        res = C(otto=3, anna=5)
+        self.assertEqual(res.age, 7)
+        xprint()
+        with self.assertRaises(AssertionError):
+            res = C(killme=42)
+        xprint()
+
+    def testDEF(self):
+        xprint()
+        res = F(anna=5)
+        self.assertEqual(res.age, 7)
+        xprint()
+
+    def testGHI(self):
+        xprint()
+        res = II(age=7)
+        self.assertEqual(res.age, 7)
+        xprint()
+
+    def testParentDoesNotCrash(self):
+        # This crashed with
+        # TypeError: object.__init__() takes exactly one argument (the instance to initialize)
+        MainWindow()
+
+
+# PYSIDE-2654: Additional missing init test.
+#              This must work if no __init__ is defined (Ui_Form)
+class Ui_Form(object):
+    pass
+
+
+class Mixin:
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+
+class Card(Mixin, QWidget):
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent=parent)
+
+
+class Demo(Card, Ui_Form):
+    def __init__(self) -> None:
+        super().__init__()
+
+
+class MissingInitFunctionTest(UsesQApplication):
+    def testMissing(self):
+        Demo()
+        # Tests if this works. Would crash without the extra
+        # check for object.__init__
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/pysidetest/pyenum_relax_options_test.py b/sources/pyside6/tests/pysidetest/pyenum_relax_options_test.py
index 0dcec5a4c..625f9cdc5 100644
--- a/sources/pyside6/tests/pysidetest/pyenum_relax_options_test.py
+++ b/sources/pyside6/tests/pysidetest/pyenum_relax_options_test.py
@@ -49,46 +49,52 @@ def runtest(program):
         finally:
             os.unlink(fp.name)
 
+
 def testprog2(option):
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         from enum import IntEnum
         assert(issubclass(QtCore.Qt.DateFormat, IntEnum))
         """))
 
+
 def testprog4(option):
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         QtCore.QtDebugMsg
         """))
 
+
 def testprog8_16(option):
     # this test needs flag 16, or the effect would be hidden by forgiving mode
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         QtCore.Qt.AlignTop
         """))
 
+
 def testprog32(option):
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         QtCore.Qt.Alignment
         """))
 
+
 def testprog64(option):
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         QtCore.Qt.AlignmentFlag()
         """))
 
+
 def testprog128(option):
     return runtest(dedent(f"""
-        sys.pyside63_option_python_enum = {option}
+        sys.pyside6_option_python_enum = {option}
         from PySide6 import QtCore
         QtCore.Qt.Key(1234567)
         """))
@@ -110,8 +116,8 @@ class TestPyEnumRelaxOption(unittest.TestCase):
         self.assertTrue(testprog4(12))
 
     def test_localDefault(self):
-        self.assertTrue(testprog8_16(8+16))
-        self.assertFalse(testprog8_16(0+16))
+        self.assertTrue(testprog8_16(8 + 16))
+        self.assertFalse(testprog8_16(0 + 16))
 
     def test_fakeRenames(self):
         self.assertTrue(testprog32(1))
diff --git a/sources/pyside6/tests/pysidetest/pysidetest_global.h b/sources/pyside6/tests/pysidetest/pysidetest_global.h
index 461b6f56f..6f784dc58 100644
--- a/sources/pyside6/tests/pysidetest/pysidetest_global.h
+++ b/sources/pyside6/tests/pysidetest/pysidetest_global.h
@@ -11,5 +11,6 @@
 #include "flagstest.h"
 #include "hiddenobject.h"
 #include "sharedpointertestbench.h"
+#include "testqvariantenum.h"
 
 #endif // PYSIDETEST_GLOBAL_H
diff --git a/sources/pyside6/tests/pysidetest/qvariant_test.py b/sources/pyside6/tests/pysidetest/qvariant_test.py
index 5addb00e0..faefc8169 100644
--- a/sources/pyside6/tests/pysidetest/qvariant_test.py
+++ b/sources/pyside6/tests/pysidetest/qvariant_test.py
@@ -1,6 +1,7 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
+import enum
 import os
 import sys
 import unittest
@@ -10,13 +11,25 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(True)
 
-from testbinding import TestObject
+from testbinding import TestObject, TestQVariantEnum
 from PySide6.QtCore import Qt, QKeyCombination
 from PySide6.QtGui import QKeySequence, QAction
 
 from helper.usesqapplication import UsesQApplication
 
 
+class PyTestQVariantEnum(TestQVariantEnum):
+    def __init__(self, var_enum):
+        super().__init__(var_enum)
+
+    def getRValEnum(self):
+        return Qt.Orientation.Vertical
+
+    def channelingEnum(self, rval_enum):
+        return (isinstance(rval_enum, enum.Enum)
+                and rval_enum == Qt.Orientation.Vertical)
+
+
 class QVariantTest(UsesQApplication):
 
     def testQKeySequenceQVariantOperator(self):
@@ -24,16 +37,30 @@ class QVariantTest(UsesQApplication):
         ks = QKeySequence(Qt.ShiftModifier, Qt.ControlModifier, Qt.Key_P, Qt.Key_R)
         self.assertEqual(TestObject.checkType(ks), 4107)
 
-    # PYSIDE-1735: Test the new way to address QKeyCombination after moving IntEnum to Enum
-    @unittest.skipUnless(sys.pyside63_option_python_enum, "only implemented for new enums")
     def testQKeySequenceMoreVariations(self):
         QAction().setShortcut(Qt.CTRL | Qt.Key_B)
         QAction().setShortcut(Qt.CTRL | Qt.ALT | Qt.Key_B)
         QAction().setShortcut(Qt.CTRL | Qt.AltModifier | Qt.Key_B)
         QAction().setShortcut(QKeySequence(QKeyCombination(Qt.CTRL | Qt.Key_B)))
         QKeySequence(Qt.CTRL | Qt.Key_Q)
-        # Issues a warning but works as well
-        QKeySequence(Qt.CTRL + Qt.Key_Q)
+
+    def testEnum(self):
+        # Testing C++ class
+        testqvariant = TestQVariantEnum(Qt.CheckState.Checked)
+        self.assertEqual(testqvariant.getLValEnum(), Qt.CheckState.Checked)
+        self.assertIsInstance(testqvariant.getLValEnum(), enum.Enum)
+        # in the case where we return a QVariant of C++ enum, it returns a
+        # QVariant(int) to Python unless explicitly handled manually by Shiboken
+        self.assertEqual(testqvariant.getRValEnum(), 1)
+        self.assertEqual(testqvariant.isEnumChanneled(), False)
+
+        # Testing Python child class
+        pytestqvariant = PyTestQVariantEnum(Qt.CheckState.Checked)
+        self.assertEqual(pytestqvariant.isEnumChanneled(), True)
+        # check toInt() conversion works for PyObjectWrapper
+        self.assertEqual(PyTestQVariantEnum.getNumberFromQVarEnum(Qt.Orientation.Vertical), 2)
+        # check toInt() conversion for IntEnum
+        self.assertEqual(PyTestQVariantEnum.getNumberFromQVarEnum(Qt.GestureType.TapGesture), 1)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/pysidetest/repr_test.py b/sources/pyside6/tests/pysidetest/repr_test.py
index 01cc36b37..863f17657 100644
--- a/sources/pyside6/tests/pysidetest/repr_test.py
+++ b/sources/pyside6/tests/pysidetest/repr_test.py
@@ -49,6 +49,15 @@ class QObjectDerivedReprTest(unittest.TestCase):
         # __repr__ should use the operator<<(QDebug,...) implementation
         self.assertEqual(str(t), "TestObject2WithNamespace(injected_repr)")
 
+    def testLatin1StringField(self):
+        self.assertEqual(TestObject.LATIN1_TEST_FIELD, "test")
+
+    def testLatin1Setter(self):
+        to = TestObject(123)
+        value = "test"
+        to.setQLatin1String(value)
+        self.assertEqual(to.qLatin1String(), value)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/pysidetest/signalinstance_equality_test.py b/sources/pyside6/tests/pysidetest/signalinstance_equality_test.py
index 732420c4d..5faaa38d4 100644
--- a/sources/pyside6/tests/pysidetest/signalinstance_equality_test.py
+++ b/sources/pyside6/tests/pysidetest/signalinstance_equality_test.py
@@ -12,7 +12,7 @@ init_test_paths(False)
 
 from helper.usesqapplication import UsesQApplication
 
-from PySide6.QtCore import QFile, QObject, QTimer, Signal, Slot
+from PySide6.QtCore import QFile, QObject, QTimer, Signal, SignalInstance, Slot
 from PySide6.QtWidgets import QSlider
 
 
@@ -41,6 +41,17 @@ class TestSignalInstance(unittest.TestCase):
         o = D()
         self.assertTrue(o.custom_signal == o.custom_signal)
 
+    # additional tests of old errors from 2010 or so
+    def test_uninitialized_SignalInstance(self):
+        # This will no longer crash
+        print(SignalInstance())
+        with self.assertRaises(RuntimeError):
+            SignalInstance().connect(lambda: None)
+        with self.assertRaises(RuntimeError):
+            SignalInstance().disconnect()
+        with self.assertRaises(RuntimeError):
+            SignalInstance().emit()
+
 
 class MyWidget(QSlider):
     valueChanged = Signal(tuple)
diff --git a/sources/pyside6/tests/pysidetest/signalwithdefaultvalue_test.py b/sources/pyside6/tests/pysidetest/signalwithdefaultvalue_test.py
index cf09b2964..744b8c503 100644
--- a/sources/pyside6/tests/pysidetest/signalwithdefaultvalue_test.py
+++ b/sources/pyside6/tests/pysidetest/signalwithdefaultvalue_test.py
@@ -13,7 +13,7 @@ from init_paths import init_test_paths
 init_test_paths(True)
 
 from testbinding import TestObject
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import Qt
 
 '''Tests the behaviour of signals with default values.'''
 
@@ -56,6 +56,17 @@ class SignalWithDefaultValueTest(unittest.TestCase):
         self.assertTrue(self.void_called)
         self.assertTrue(self.bool_called)
 
+    def testFlagsSignal(self):
+        test_value = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignBottom
+
+        def callbackAlignmentFlags(alignment):
+            self.alignment_flags_called = alignment
+
+        self.obj.flagsSignal.connect(callbackAlignmentFlags)
+        self.obj.emitFlagsSignal(test_value)
+        self.assertTrue(self.alignment_flags_called)
+        self.assertEqual(self.alignment_flags_called, test_value)
+
     def testConnectOldStyleEmitVoidSignal(self):
         def callbackVoid():
             self.void_called = True
@@ -83,4 +94,3 @@ class SignalWithDefaultValueTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/pysidetest/snake_case_sub.py b/sources/pyside6/tests/pysidetest/snake_case_sub.py
index 5056d50bb..4a482c35a 100644
--- a/sources/pyside6/tests/pysidetest/snake_case_sub.py
+++ b/sources/pyside6/tests/pysidetest/snake_case_sub.py
@@ -16,6 +16,7 @@ PYSIDE-2029: Tests that snake_case is isolated from imported modules
 
 from PySide6.QtWidgets import QWidget
 
+
 def test_no_snake_case():
     print(__name__)
     widget = QWidget()
diff --git a/sources/pyside6/tests/pysidetest/snake_case_test.py b/sources/pyside6/tests/pysidetest/snake_case_test.py
index aaa3d3f2a..14e035773 100644
--- a/sources/pyside6/tests/pysidetest/snake_case_test.py
+++ b/sources/pyside6/tests/pysidetest/snake_case_test.py
@@ -13,14 +13,17 @@ init_test_paths(False)
 """
 PYSIDE-2029: Tests that snake_case is isolated from imported modules
 """
+is_pypy = hasattr(sys, "pypy_version_info")
 
 from PySide6.QtCore import QSize
 from PySide6.QtWidgets import QWidget, QSpinBox
-from __feature__ import snake_case
+if not is_pypy:
+    from __feature__ import snake_case
 from helper.usesqapplication import UsesQApplication
 
 import snake_case_sub
 
+@unittest.skipIf(is_pypy, "__feature__ cannot yet be used with PyPy")
 class SnakeCaseNoPropagateTest(UsesQApplication):
 
     def testSnakeCase(self):
@@ -30,5 +33,6 @@ class SnakeCaseNoPropagateTest(UsesQApplication):
 
         snake_case_sub.test_no_snake_case()
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/pysidetest/testobject.cpp b/sources/pyside6/tests/pysidetest/testobject.cpp
index 2233bad62..fe4ec98f7 100644
--- a/sources/pyside6/tests/pysidetest/testobject.cpp
+++ b/sources/pyside6/tests/pysidetest/testobject.cpp
@@ -30,6 +30,26 @@ void TestObject::emitSignalWithTypedefValue(int value)
     emit signalWithTypedefValue(TypedefValue(value));
 }
 
+void TestObject::emitSignalWithContainerTypedefValue(const IntList &il)
+{
+    emit signalWithContainerTypedefValue(il);
+}
+
+void TestObject::emitFlagsSignal(Qt::Alignment alignment)
+{
+    emit flagsSignal(alignment);
+}
+
+void TestObject::setQLatin1String(QLatin1String v)
+{
+    m_qLatin1String = v;
+}
+
+QString TestObject::qLatin1String() const
+{
+    return m_qLatin1String;
+}
+
 QDebug operator<<(QDebug dbg, TestObject& testObject)
 {
     QDebugStateSaver saver(dbg);
diff --git a/sources/pyside6/tests/pysidetest/testobject.h b/sources/pyside6/tests/pysidetest/testobject.h
index 88652bcca..a095a382e 100644
--- a/sources/pyside6/tests/pysidetest/testobject.h
+++ b/sources/pyside6/tests/pysidetest/testobject.h
@@ -8,12 +8,15 @@
 
 #include <QtWidgets/QApplication>
 
+#include <QtCore/QList>
 #include <QtCore/QObject>
 #include <QtCore/QMetaType>
 #include <QtCore/QVariant>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
+using IntList = QList<int>;
+
 class IntValue
 {
 public:
@@ -23,16 +26,16 @@ public:
     int value;
 };
 
-typedef IntValue TypedefValue;
+using TypedefValue = IntValue;
 
 class PYSIDETEST_API TestObject : public QObject
 {
     Q_OBJECT
 public:
-    static void createApp() { int argc=0; new QApplication(argc, 0); };
+    static void createApp() { int argc=0; new QApplication(argc, nullptr); };
     static int checkType(const QVariant& var) { return var.metaType().id(); }
 
-    TestObject(int idValue, QObject* parent = 0) : QObject(parent), m_idValue(idValue) {}
+    TestObject(int idValue, QObject* parent = nullptr) : QObject(parent), m_idValue(idValue) {}
     int idValue() const { return m_idValue; }
     static int staticMethodDouble(int value) { return value * 2; }
     void addChild(QObject* c) { m_children.append(c); emit childrenChanged(m_children); }
@@ -44,6 +47,14 @@ public:
     void emitSignalWithDefaultValue_bool();
 
     void emitSignalWithTypedefValue(int value);
+    void emitSignalWithContainerTypedefValue(const IntList &il);
+
+    void emitFlagsSignal(Qt::Alignment alignment);
+
+    static constexpr auto LATIN1_TEST_FIELD = QLatin1StringView("test");
+
+    void setQLatin1String(QLatin1String v);
+    QString qLatin1String() const;
 
 signals:
     void idValue(int newValue);
@@ -52,16 +63,18 @@ signals:
     void childrenChanged(const QList<QObject*>&);
     void signalWithDefaultValue(bool value = false);
     void signalWithTypedefValue(TypedefValue value);
+    void signalWithContainerTypedefValue(const IntList &il);
+    void flagsSignal(Qt::Alignment alignment);
 
 private:
     int m_idValue;
     QList<QObject*> m_children;
+    QString m_qLatin1String;
 };
 
 PYSIDETEST_API QDebug operator<<(QDebug dbg, TestObject &testObject);
 
-typedef int PySideInt;
-
+using PySideInt = int;
 
 namespace PySideCPP {
 
@@ -100,8 +113,7 @@ namespace PySideCPP2 {
 
 enum Enum1 { Option1 = 1, Option2 = 2 };
 
-
-typedef long PySideLong;
+using PySideLong = long;
 
 class PYSIDETEST_API TestObjectWithoutNamespace :  public QObject
 {
diff --git a/sources/pyside6/tests/pysidetest/testqvariantenum.cpp b/sources/pyside6/tests/pysidetest/testqvariantenum.cpp
new file mode 100644
index 000000000..7135e422a
--- /dev/null
+++ b/sources/pyside6/tests/pysidetest/testqvariantenum.cpp
@@ -0,0 +1,29 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "testqvariantenum.h"
+
+QVariant TestQVariantEnum::getLValEnum() const
+{
+    return this->m_enum;
+}
+
+QVariant TestQVariantEnum::getRValEnum() const
+{
+    return QVariant(Qt::Orientation::Horizontal);
+}
+
+int TestQVariantEnum::getNumberFromQVarEnum(QVariant variantEnum)
+{
+    return variantEnum.toInt();
+}
+
+bool TestQVariantEnum::channelingEnum([[maybe_unused]] QVariant rvalEnum) const
+{
+   return false;
+}
+
+bool TestQVariantEnum::isEnumChanneled() const
+{
+    return this->channelingEnum(this->getRValEnum());
+}
diff --git a/sources/pyside6/tests/pysidetest/testqvariantenum.h b/sources/pyside6/tests/pysidetest/testqvariantenum.h
new file mode 100644
index 000000000..4b729e3dd
--- /dev/null
+++ b/sources/pyside6/tests/pysidetest/testqvariantenum.h
@@ -0,0 +1,35 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef TESTQVARIANT_H
+#define TESTQVARIANT_H
+
+#include "pysidetest_macros.h"
+
+#include <QtCore/QVariant>
+
+class PYSIDETEST_API TestQVariantEnum
+{
+public:
+    TestQVariantEnum(QVariant lvalue_enum) : m_enum(lvalue_enum) {}
+    QVariant getLValEnum() const;
+    static int getNumberFromQVarEnum(QVariant variantEnum = QVariant());
+    bool isEnumChanneled() const;
+    virtual QVariant getRValEnum() const;
+    virtual bool channelingEnum(QVariant rvalEnum) const;
+    virtual ~TestQVariantEnum() = default;
+private:
+    QVariant m_enum;
+};
+
+class PYSIDETEST_API QVariantHolder // modeled after Q3DParameter, test QVariant conversion
+{
+public:
+    void setValue(QVariant v) { m_variant = v; }
+    QVariant value() const { return m_variant; }
+
+private:
+    QVariant m_variant;
+};
+
+#endif // TESTQVARIANT_H
diff --git a/sources/pyside6/tests/pysidetest/testview.cpp b/sources/pyside6/tests/pysidetest/testview.cpp
index ade60682f..362239112 100644
--- a/sources/pyside6/tests/pysidetest/testview.cpp
+++ b/sources/pyside6/tests/pysidetest/testview.cpp
@@ -18,7 +18,7 @@ TestView::getData()
 QWidget*
 TestView::getEditorWidgetFromItemDelegate() const
 {
-    if (!m_delegate)
+    if (m_delegate == nullptr)
         return nullptr;
 
     QModelIndex index;
diff --git a/sources/pyside6/tests/pysidetest/testview.h b/sources/pyside6/tests/pysidetest/testview.h
index ee9ca9ce0..746def83e 100644
--- a/sources/pyside6/tests/pysidetest/testview.h
+++ b/sources/pyside6/tests/pysidetest/testview.h
@@ -18,7 +18,8 @@ class PYSIDETEST_API TestView : public QObject
 {
     Q_OBJECT
 public:
-    TestView(QAbstractListModel* model, QObject* parent = 0) : QObject(parent), m_model(model) {}
+    TestView(QAbstractListModel* model, QObject* parent = nullptr) :
+        QObject(parent), m_model(model) {}
     QAbstractListModel* model() { return m_model; }
     QVariant getData();
 
@@ -27,7 +28,7 @@ public:
 
 private:
     QAbstractListModel* m_model;
-    QAbstractItemDelegate* m_delegate;
+    QAbstractItemDelegate* m_delegate = nullptr;
 };
 
 #endif // TESTVIEW_H
diff --git a/sources/pyside6/tests/pysidetest/true_property_test.py b/sources/pyside6/tests/pysidetest/true_property_test.py
index 671cc4571..62f6505dc 100644
--- a/sources/pyside6/tests/pysidetest/true_property_test.py
+++ b/sources/pyside6/tests/pysidetest/true_property_test.py
@@ -13,13 +13,16 @@ init_test_paths(False)
 """
 PYSIDE-2042: Tests true_property with inheritance
 """
+is_pypy = hasattr(sys, "pypy_version_info")
 
 from PySide6.QtCore import QSize
 from PySide6.QtWidgets import QWidget, QSpinBox
-from __feature__ import true_property
+if not is_pypy:
+    from __feature__ import true_property
 from helper.usesqapplication import UsesQApplication
 
 
+@unittest.skipIf(is_pypy, "__feature__ cannot yet be used with PyPy")
 class TruePropertyInheritanceTest(UsesQApplication):
 
     def testTrueProperty(self):
@@ -33,6 +36,23 @@ class TruePropertyInheritanceTest(UsesQApplication):
         check = spin_box.sizeHint
         self.assertEqual(type(check), QSize)
 
+    def testHiddenMethods(self):
+        # PYSIDE-1889: setVisible is no longer a meta function but comes from the Property
+        widget = QWidget()
+        self.assertTrue("visible" in QWidget.__dict__)
+        self.assertFalse("isVisible" in QWidget.__dict__)
+        self.assertFalse("setVisible" in QWidget.__dict__)
+        self.assertTrue(hasattr(widget, "isVisible"))
+        self.assertTrue(hasattr(widget, "setVisible"))
+        self.assertEqual(widget.isVisible, QWidget.visible.fget)
+        self.assertEqual(widget.setVisible, QWidget.visible.fset)
+
+        # This works with inheritance as well:
+        class SubClass(QWidget):
+            pass
+        sub_widget = SubClass()
+        self.assertEqual(sub_widget.isVisible, QWidget.visible.fget)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/pysidetest/typedef_signal_test.py b/sources/pyside6/tests/pysidetest/typedef_signal_test.py
index dfe5311e8..d0bdc880b 100644
--- a/sources/pyside6/tests/pysidetest/typedef_signal_test.py
+++ b/sources/pyside6/tests/pysidetest/typedef_signal_test.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(True)
 
-from PySide6.QtCore import QObject
+from PySide6.QtCore import QObject, Slot
 from testbinding import TestObject
 
 
@@ -23,6 +23,10 @@ class Receiver(QObject):
     def slot(self, value):
         self.received = value
 
+    @Slot("IntList")
+    def containerSlot(self, value):
+        self.received = value
+
 
 class TypedefSignal(unittest.TestCase):
 
@@ -34,6 +38,15 @@ class TypedefSignal(unittest.TestCase):
         obj.emitSignalWithTypedefValue(2)
         self.assertEqual(receiver.received.value, 2)
 
+    def testContainerTypedef(self):
+        obj = TestObject(0)
+        receiver = Receiver()
+
+        test_list = [1, 2]
+        obj.signalWithContainerTypedefValue.connect(receiver.containerSlot)
+        obj.emitSignalWithContainerTypedefValue(test_list)
+        self.assertEqual(receiver.received, test_list)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/pysidetest/typesystem_pysidetest.xml b/sources/pyside6/tests/pysidetest/typesystem_pysidetest.xml
index 7f1170466..592d90a83 100644
--- a/sources/pyside6/tests/pysidetest/typesystem_pysidetest.xml
+++ b/sources/pyside6/tests/pysidetest/typesystem_pysidetest.xml
@@ -63,6 +63,8 @@
         </modify-function>
     </object-type>
 
+    <value-type name="TestQVariantEnum"/>
+
     <namespace-type name="FlagsNamespace" visible="no">
         <enum-type name="Option" flags="Options"/>
         <object-type name="ClassForEnum" />
@@ -70,15 +72,9 @@
 
     <object-type name="SharedPointerTestbench"/>
 
+    <value-type name="QVariantHolder"/>
+
     <smart-pointer-type name="QSharedPointer" type="shared" getter="data"
                         reset-method="reset"/>
 
-    <suppress-warning text="type 'QPyTextObject' is specified in typesystem, but not defined. This could potentially lead to compilation errors." />
-    <!-- Qt5: I never really understood this warning. Probably it is because there
-        is no way to instantiate the class. Anyway, why must this class emit this warning?
-        I am not a C++ warrior, so I'd prefer if it would say "it is ok if you see this warning!".
-        Well, maybe somebody will enlighten me, and I'll change this comment.
-        I'd actually prefer an implementation that avoids generating this message, but I still failed
-        doing so :-(
-    -->
 </typesystem>
diff --git a/sources/pyside6/tests/registry/exists_darwin_5_14_2_ci.py b/sources/pyside6/tests/registry/exists_darwin_5_14_2_ci.py
deleted file mode 100644
index 2dddc2482..000000000
--- a/sources/pyside6/tests/registry/exists_darwin_5_14_2_ci.py
+++ /dev/null
@@ -1,37697 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-"""
-This file contains the simplified signatures for all functions in PySide
-for module 'exists_darwin_5_14_2_ci' using
-Python 2.7.16 (v2.7.16:413a49145e, Mar  2 2019, 15:28:37)  [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)]
-Qt 5.14.2 (x86_64-little_endian-lp64 shared (dynamic) release build; by Clang 10.0.0 (clang-1000.11.45.5) (Apple))
-There are no default values, no variable names and no self
-parameter. Only types are present after simplification. The
-functions 'next' resp. '__next__' are removed to make the output
-identical for Python 2 and 3. '__div__' is also removed,
-since it exists in Python 2, only.
-"""
-import sys
-sig_dict = {}
-# Module PySide2.QtCore
-sig_dict.update({
-# class PySide2.QtCore.ClassInfo:
-    "PySide2.QtCore.ClassInfo.__init__": ('typing.Dict[str, str]',),
-# class PySide2.QtCore.MetaFunction:
-    "PySide2.QtCore.MetaFunction.__call__": ('typing.Any',),
-# class PySide2.QtCore.MetaSignal:
-    "PySide2.QtCore.MetaSignal.__instancecheck__": ('object',),
-# class PySide2.QtCore.Property:
-    "PySide2.QtCore.Property.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'str', 'typing.Callable', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool'),
-    "PySide2.QtCore.Property.getter": ('typing.Callable',),
-    "PySide2.QtCore.Property.read": ('typing.Callable',),
-    "PySide2.QtCore.Property.setter": ('typing.Callable',),
-    "PySide2.QtCore.Property.write": ('typing.Callable',),
-# class PySide2.QtCore.QAbstractAnimation:
-# class PySide2.QtCore.QAbstractAnimation.DeletionPolicy:
-# class PySide2.QtCore.QAbstractAnimation.Direction:
-# class PySide2.QtCore.QAbstractAnimation.State:
-    "PySide2.QtCore.QAbstractAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractAnimation.currentLoop": (),
-    "PySide2.QtCore.QAbstractAnimation.currentLoopTime": (),
-    "PySide2.QtCore.QAbstractAnimation.currentTime": (),
-    "PySide2.QtCore.QAbstractAnimation.direction": (),
-    "PySide2.QtCore.QAbstractAnimation.duration": (),
-    "PySide2.QtCore.QAbstractAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractAnimation.group": (),
-    "PySide2.QtCore.QAbstractAnimation.loopCount": (),
-    "PySide2.QtCore.QAbstractAnimation.pause": (),
-    "PySide2.QtCore.QAbstractAnimation.resume": (),
-    "PySide2.QtCore.QAbstractAnimation.setCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.setLoopCount": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setPaused": ('bool',),
-    "PySide2.QtCore.QAbstractAnimation.start": ('PySide2.QtCore.QAbstractAnimation.DeletionPolicy',),
-    "PySide2.QtCore.QAbstractAnimation.state": (),
-    "PySide2.QtCore.QAbstractAnimation.stop": (),
-    "PySide2.QtCore.QAbstractAnimation.totalDuration": (),
-    "PySide2.QtCore.QAbstractAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QAbstractEventDispatcher:
-# class PySide2.QtCore.QAbstractEventDispatcher.TimerInfo:
-    "PySide2.QtCore.QAbstractEventDispatcher.TimerInfo.__init__": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QAbstractEventDispatcher.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.closingDown": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.filterNativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QAbstractEventDispatcher.flush": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.hasPendingEvents": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.instance": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QAbstractEventDispatcher.interrupt": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.processEvents": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerTimer": [('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject'), ('int', 'int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QAbstractEventDispatcher.registeredTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.remainingTime": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.startingUp": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimer": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.wakeUp": (),
-# class PySide2.QtCore.QAbstractItemModel:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOption:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOptions:
-# class PySide2.QtCore.QAbstractItemModel.LayoutChangeHint:
-    "PySide2.QtCore.QAbstractItemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndexList": ('typing.List[int]', 'typing.List[int]'),
-    "PySide2.QtCore.QAbstractItemModel.checkIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QAbstractItemModel.CheckIndexOptions'),
-    "PySide2.QtCore.QAbstractItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object')],
-    "PySide2.QtCore.QAbstractItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.decodeData": ('int', 'int', 'PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.encodeData": ('typing.List[int]', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.endInsertColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endInsertRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasIndex": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QAbstractItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractItemModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractItemModel.moveColumn": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRow": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractItemModel.persistentIndexList": (),
-    "PySide2.QtCore.QAbstractItemModel.removeColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractItemModel.revert": (),
-    "PySide2.QtCore.QAbstractItemModel.roleNames": (),
-    "PySide2.QtCore.QAbstractItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractItemModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.submit": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractListModel:
-    "PySide2.QtCore.QAbstractListModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractListModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractNativeEventFilter:
-    "PySide2.QtCore.QAbstractNativeEventFilter.__init__": (),
-    "PySide2.QtCore.QAbstractNativeEventFilter.nativeEventFilter": ('PySide2.QtCore.QByteArray', 'int'),
-# class PySide2.QtCore.QAbstractProxyModel:
-    "PySide2.QtCore.QAbstractProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractProxyModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractProxyModel.revert": (),
-    "PySide2.QtCore.QAbstractProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QAbstractProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractProxyModel.sourceModel": (),
-    "PySide2.QtCore.QAbstractProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.submit": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractState:
-    "PySide2.QtCore.QAbstractState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractState.active": (),
-    "PySide2.QtCore.QAbstractState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.machine": (),
-    "PySide2.QtCore.QAbstractState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.parentState": (),
-# class PySide2.QtCore.QAbstractTableModel:
-    "PySide2.QtCore.QAbstractTableModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractTableModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractTableModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractTransition:
-# class PySide2.QtCore.QAbstractTransition.TransitionType:
-    "PySide2.QtCore.QAbstractTransition.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractTransition.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.animations": (),
-    "PySide2.QtCore.QAbstractTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.machine": (),
-    "PySide2.QtCore.QAbstractTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.setTargetState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QAbstractTransition.setTargetStates": ('typing.Sequence[PySide2.QtCore.QAbstractState]',),
-    "PySide2.QtCore.QAbstractTransition.setTransitionType": ('PySide2.QtCore.QAbstractTransition.TransitionType',),
-    "PySide2.QtCore.QAbstractTransition.sourceState": (),
-    "PySide2.QtCore.QAbstractTransition.targetState": (),
-    "PySide2.QtCore.QAbstractTransition.targetStates": (),
-    "PySide2.QtCore.QAbstractTransition.transitionType": (),
-# class PySide2.QtCore.QAnimationGroup:
-    "PySide2.QtCore.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAnimationGroup.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.animationAt": ('int',),
-    "PySide2.QtCore.QAnimationGroup.animationCount": (),
-    "PySide2.QtCore.QAnimationGroup.clear": (),
-    "PySide2.QtCore.QAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAnimationGroup.indexOfAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.insertAnimation": ('int', 'PySide2.QtCore.QAbstractAnimation'),
-    "PySide2.QtCore.QAnimationGroup.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.takeAnimation": ('int',),
-# class PySide2.QtCore.QBasicMutex:
-    "PySide2.QtCore.QBasicMutex.__init__": (),
-    "PySide2.QtCore.QBasicMutex.isRecursive": (),
-    "PySide2.QtCore.QBasicMutex.lock": (),
-    "PySide2.QtCore.QBasicMutex.tryLock": (),
-    "PySide2.QtCore.QBasicMutex.try_lock": (),
-    "PySide2.QtCore.QBasicMutex.unlock": (),
-# class PySide2.QtCore.QBasicTimer:
-    "PySide2.QtCore.QBasicTimer.__init__": [(), ('PySide2.QtCore.QBasicTimer',)],
-    "PySide2.QtCore.QBasicTimer.__copy__": (),
-    "PySide2.QtCore.QBasicTimer.isActive": (),
-    "PySide2.QtCore.QBasicTimer.start": [('int', 'PySide2.QtCore.QObject'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QBasicTimer.stop": (),
-    "PySide2.QtCore.QBasicTimer.swap": ('PySide2.QtCore.QBasicTimer',),
-    "PySide2.QtCore.QBasicTimer.timerId": (),
-# class PySide2.QtCore.QBitArray:
-    "PySide2.QtCore.QBitArray.__init__": [(), ('PySide2.QtCore.QBitArray',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.__and__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__copy__": (),
-    "PySide2.QtCore.QBitArray.__iand__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__invert__": (),
-    "PySide2.QtCore.QBitArray.__ior__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__ixor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__or__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__xor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.at": ('int',),
-    "PySide2.QtCore.QBitArray.bits": (),
-    "PySide2.QtCore.QBitArray.clear": (),
-    "PySide2.QtCore.QBitArray.clearBit": ('int',),
-    "PySide2.QtCore.QBitArray.count": [(), ('bool',)],
-    "PySide2.QtCore.QBitArray.fill": [('bool', 'int'), ('bool', 'int', 'int')],
-    "PySide2.QtCore.QBitArray.fromBits": ('str', 'int'),
-    "PySide2.QtCore.QBitArray.isEmpty": (),
-    "PySide2.QtCore.QBitArray.isNull": (),
-    "PySide2.QtCore.QBitArray.resize": ('int',),
-    "PySide2.QtCore.QBitArray.setBit": [('int',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.size": (),
-    "PySide2.QtCore.QBitArray.swap": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.testBit": ('int',),
-    "PySide2.QtCore.QBitArray.toggleBit": ('int',),
-    "PySide2.QtCore.QBitArray.truncate": ('int',),
-# class PySide2.QtCore.QBuffer:
-    "PySide2.QtCore.QBuffer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QBuffer.atEnd": (),
-    "PySide2.QtCore.QBuffer.buffer": (),
-    "PySide2.QtCore.QBuffer.canReadLine": (),
-    "PySide2.QtCore.QBuffer.close": (),
-    "PySide2.QtCore.QBuffer.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.data": (),
-    "PySide2.QtCore.QBuffer.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QBuffer.pos": (),
-    "PySide2.QtCore.QBuffer.readData": ('str', 'int'),
-    "PySide2.QtCore.QBuffer.seek": ('int',),
-    "PySide2.QtCore.QBuffer.setBuffer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.size": (),
-    "PySide2.QtCore.QBuffer.writeData": ('str', 'int'),
-# class PySide2.QtCore.QByteArray:
-# class PySide2.QtCore.QByteArray.Base64Option:
-# class PySide2.QtCore.QByteArray.Base64Options:
-    "PySide2.QtCore.QByteArray.__init__": [(), ('PySide2.QtCore.QByteArray',), ('bytearray',), ('int', 'int'), ('str',)],
-    "PySide2.QtCore.QByteArray.__add__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',), ('str',)],
-    "PySide2.QtCore.QByteArray.__copy__": (),
-    "PySide2.QtCore.QByteArray.__iadd__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',)],
-    "PySide2.QtCore.QByteArray.__reduce__": (),
-    "PySide2.QtCore.QByteArray.__repr__": (),
-    "PySide2.QtCore.QByteArray.__str__": (),
-    "PySide2.QtCore.QByteArray.append": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.at": ('int',),
-    "PySide2.QtCore.QByteArray.back": (),
-    "PySide2.QtCore.QByteArray.capacity": (),
-    "PySide2.QtCore.QByteArray.cbegin": (),
-    "PySide2.QtCore.QByteArray.cend": (),
-    "PySide2.QtCore.QByteArray.chop": ('int',),
-    "PySide2.QtCore.QByteArray.chopped": ('int',),
-    "PySide2.QtCore.QByteArray.clear": (),
-    "PySide2.QtCore.QByteArray.compare": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.Qt.CaseSensitivity'), ('str', 'PySide2.QtCore.Qt.CaseSensitivity')],
-    "PySide2.QtCore.QByteArray.contains": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.count": [(), ('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.data": (),
-    "PySide2.QtCore.QByteArray.endsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.fill": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.fromBase64": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray.Base64Options')],
-    "PySide2.QtCore.QByteArray.fromHex": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.fromPercentEncoding": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.fromRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.front": (),
-    "PySide2.QtCore.QByteArray.indexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.insert": [('int', 'PySide2.QtCore.QByteArray'), ('int', 'int', 'int')],
-    "PySide2.QtCore.QByteArray.isEmpty": (),
-    "PySide2.QtCore.QByteArray.isLower": (),
-    "PySide2.QtCore.QByteArray.isNull": (),
-    "PySide2.QtCore.QByteArray.isSharedWith": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.isUpper": (),
-    "PySide2.QtCore.QByteArray.lastIndexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.left": ('int',),
-    "PySide2.QtCore.QByteArray.leftJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.length": (),
-    "PySide2.QtCore.QByteArray.mid": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.number": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.prepend": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.remove": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.repeated": ('int',),
-    "PySide2.QtCore.QByteArray.replace": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('int', 'PySide2.QtCore.QByteArray'), ('int', 'int'), ('int', 'int', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtCore.QByteArray.reserve": ('int',),
-    "PySide2.QtCore.QByteArray.resize": ('int',),
-    "PySide2.QtCore.QByteArray.right": ('int',),
-    "PySide2.QtCore.QByteArray.rightJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.setNum": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.setRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.shrink_to_fit": (),
-    "PySide2.QtCore.QByteArray.simplified": (),
-    "PySide2.QtCore.QByteArray.size": (),
-    "PySide2.QtCore.QByteArray.split": ('int',),
-    "PySide2.QtCore.QByteArray.squeeze": (),
-    "PySide2.QtCore.QByteArray.startsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.swap": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.toBase64": [(), ('PySide2.QtCore.QByteArray.Base64Options',)],
-    "PySide2.QtCore.QByteArray.toDouble": (),
-    "PySide2.QtCore.QByteArray.toFloat": (),
-    "PySide2.QtCore.QByteArray.toHex": [(), ('int',)],
-    "PySide2.QtCore.QByteArray.toInt": ('int',),
-    "PySide2.QtCore.QByteArray.toLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLower": (),
-    "PySide2.QtCore.QByteArray.toPercentEncoding": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.toShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUInt": ('int',),
-    "PySide2.QtCore.QByteArray.toULong": ('int',),
-    "PySide2.QtCore.QByteArray.toULongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toUShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUpper": (),
-    "PySide2.QtCore.QByteArray.trimmed": (),
-    "PySide2.QtCore.QByteArray.truncate": ('int',),
-# class PySide2.QtCore.QByteArrayMatcher:
-    "PySide2.QtCore.QByteArrayMatcher.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArrayMatcher',), ('str', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.__copy__": (),
-    "PySide2.QtCore.QByteArrayMatcher.indexIn": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.pattern": (),
-    "PySide2.QtCore.QByteArrayMatcher.setPattern": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QCalendar:
-# class PySide2.QtCore.QCalendar.System:
-# class PySide2.QtCore.QCalendar.YearMonthDay:
-    "PySide2.QtCore.QCalendar.YearMonthDay.__init__": [(), ('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.YearMonthDay.__copy__": (),
-    "PySide2.QtCore.QCalendar.YearMonthDay.isValid": (),
-    "PySide2.QtCore.QCalendar.__init__": [(), ('PySide2.QtCore.QCalendar.System',)],
-    "PySide2.QtCore.QCalendar.__copy__": (),
-    "PySide2.QtCore.QCalendar.availableCalendars": (),
-    "PySide2.QtCore.QCalendar.dateFromParts": [('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.dayOfWeek": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.daysInMonth": ('int', 'int'),
-    "PySide2.QtCore.QCalendar.daysInYear": ('int',),
-    "PySide2.QtCore.QCalendar.hasYearZero": (),
-    "PySide2.QtCore.QCalendar.isDateValid": ('int', 'int', 'int'),
-    "PySide2.QtCore.QCalendar.isGregorian": (),
-    "PySide2.QtCore.QCalendar.isLeapYear": ('int',),
-    "PySide2.QtCore.QCalendar.isLunar": (),
-    "PySide2.QtCore.QCalendar.isLuniSolar": (),
-    "PySide2.QtCore.QCalendar.isProleptic": (),
-    "PySide2.QtCore.QCalendar.isSolar": (),
-    "PySide2.QtCore.QCalendar.isValid": (),
-    "PySide2.QtCore.QCalendar.maximumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.maximumMonthsInYear": (),
-    "PySide2.QtCore.QCalendar.minimumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.monthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.monthsInYear": ('int',),
-    "PySide2.QtCore.QCalendar.name": (),
-    "PySide2.QtCore.QCalendar.partsFromDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.standaloneMonthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.standaloneWeekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.weekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-# class PySide2.QtCore.QCborArray:
-    "PySide2.QtCore.QCborArray.__init__": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborArray.__add__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__copy__": (),
-    "PySide2.QtCore.QCborArray.__iadd__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__lshift__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.append": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.at": ('int',),
-    "PySide2.QtCore.QCborArray.clear": (),
-    "PySide2.QtCore.QCborArray.compare": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.contains": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.empty": (),
-    "PySide2.QtCore.QCborArray.first": (),
-    "PySide2.QtCore.QCborArray.fromJsonArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QCborArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCborArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QCborArray.insert": ('int', 'PySide2.QtCore.QCborValue'),
-    "PySide2.QtCore.QCborArray.isEmpty": (),
-    "PySide2.QtCore.QCborArray.last": (),
-    "PySide2.QtCore.QCborArray.pop_back": (),
-    "PySide2.QtCore.QCborArray.pop_front": (),
-    "PySide2.QtCore.QCborArray.prepend": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_back": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_front": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.removeAt": ('int',),
-    "PySide2.QtCore.QCborArray.removeFirst": (),
-    "PySide2.QtCore.QCborArray.removeLast": (),
-    "PySide2.QtCore.QCborArray.size": (),
-    "PySide2.QtCore.QCborArray.swap": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.takeAt": ('int',),
-    "PySide2.QtCore.QCborArray.takeFirst": (),
-    "PySide2.QtCore.QCborArray.takeLast": (),
-    "PySide2.QtCore.QCborArray.toCborValue": (),
-    "PySide2.QtCore.QCborArray.toJsonArray": (),
-    "PySide2.QtCore.QCborArray.toVariantList": (),
-# class PySide2.QtCore.QCborError:
-# class PySide2.QtCore.QCborError.Code:
-    "PySide2.QtCore.QCborError.__init__": [(), ('PySide2.QtCore.QCborError',)],
-    "PySide2.QtCore.QCborError.__copy__": (),
-    "PySide2.QtCore.QCborError.toString": (),
-# class PySide2.QtCore.QCborKnownTags:
-# class PySide2.QtCore.QCborMap:
-    "PySide2.QtCore.QCborMap.__init__": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborMap.__copy__": (),
-    "PySide2.QtCore.QCborMap.clear": (),
-    "PySide2.QtCore.QCborMap.compare": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.contains": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.empty": (),
-    "PySide2.QtCore.QCborMap.fromJsonObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QCborMap.fromVariantHash": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.fromVariantMap": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.isEmpty": (),
-    "PySide2.QtCore.QCborMap.keys": (),
-    "PySide2.QtCore.QCborMap.remove": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.size": (),
-    "PySide2.QtCore.QCborMap.swap": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.take": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.toCborValue": (),
-    "PySide2.QtCore.QCborMap.toJsonObject": (),
-    "PySide2.QtCore.QCborMap.toVariantHash": (),
-    "PySide2.QtCore.QCborMap.toVariantMap": (),
-    "PySide2.QtCore.QCborMap.value": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-# class PySide2.QtCore.QCborParserError:
-    "PySide2.QtCore.QCborParserError.__init__": [(), ('PySide2.QtCore.QCborParserError',)],
-    "PySide2.QtCore.QCborParserError.__copy__": (),
-    "PySide2.QtCore.QCborParserError.errorString": (),
-# class PySide2.QtCore.QCborSimpleType:
-# class PySide2.QtCore.QCborStreamReader:
-# class PySide2.QtCore.QCborStreamReader.StringResultCode:
-# class PySide2.QtCore.QCborStreamReader.Type:
-    "PySide2.QtCore.QCborStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.clear": (),
-    "PySide2.QtCore.QCborStreamReader.containerDepth": (),
-    "PySide2.QtCore.QCborStreamReader.currentOffset": (),
-    "PySide2.QtCore.QCborStreamReader.currentStringChunkSize": (),
-    "PySide2.QtCore.QCborStreamReader.device": (),
-    "PySide2.QtCore.QCborStreamReader.enterContainer": (),
-    "PySide2.QtCore.QCborStreamReader.hasNext": (),
-    "PySide2.QtCore.QCborStreamReader.isArray": (),
-    "PySide2.QtCore.QCborStreamReader.isBool": (),
-    "PySide2.QtCore.QCborStreamReader.isByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.isContainer": (),
-    "PySide2.QtCore.QCborStreamReader.isDouble": (),
-    "PySide2.QtCore.QCborStreamReader.isFalse": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat16": (),
-    "PySide2.QtCore.QCborStreamReader.isInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isInvalid": (),
-    "PySide2.QtCore.QCborStreamReader.isLengthKnown": (),
-    "PySide2.QtCore.QCborStreamReader.isMap": (),
-    "PySide2.QtCore.QCborStreamReader.isNegativeInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isNull": (),
-    "PySide2.QtCore.QCborStreamReader.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborStreamReader.isString": (),
-    "PySide2.QtCore.QCborStreamReader.isTag": (),
-    "PySide2.QtCore.QCborStreamReader.isTrue": (),
-    "PySide2.QtCore.QCborStreamReader.isUndefined": (),
-    "PySide2.QtCore.QCborStreamReader.isUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isValid": (),
-    "PySide2.QtCore.QCborStreamReader.lastError": (),
-    "PySide2.QtCore.QCborStreamReader.leaveContainer": (),
-    "PySide2.QtCore.QCborStreamReader.length": (),
-    "PySide2.QtCore.QCborStreamReader.parentContainerType": (),
-    "PySide2.QtCore.QCborStreamReader.readByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.readString": (),
-    "PySide2.QtCore.QCborStreamReader.reparse": (),
-    "PySide2.QtCore.QCborStreamReader.reset": (),
-    "PySide2.QtCore.QCborStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamReader.toBool": (),
-    "PySide2.QtCore.QCborStreamReader.toDouble": (),
-    "PySide2.QtCore.QCborStreamReader.toFloat": (),
-    "PySide2.QtCore.QCborStreamReader.toInteger": (),
-    "PySide2.QtCore.QCborStreamReader.toSimpleType": (),
-    "PySide2.QtCore.QCborStreamReader.toUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.type": (),
-# class PySide2.QtCore.QCborStreamWriter:
-    "PySide2.QtCore.QCborStreamWriter.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QCborStreamWriter.append": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborKnownTags',), ('PySide2.QtCore.QCborSimpleType',), ('bool',), ('float',), ('int',), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamWriter.appendByteString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendNull": (),
-    "PySide2.QtCore.QCborStreamWriter.appendTextString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendUndefined": (),
-    "PySide2.QtCore.QCborStreamWriter.device": (),
-    "PySide2.QtCore.QCborStreamWriter.endArray": (),
-    "PySide2.QtCore.QCborStreamWriter.endMap": (),
-    "PySide2.QtCore.QCborStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamWriter.startArray": [(), ('int',)],
-    "PySide2.QtCore.QCborStreamWriter.startMap": [(), ('int',)],
-# class PySide2.QtCore.QCborStringResultByteArray:
-    "PySide2.QtCore.QCborStringResultByteArray.__init__": [(), ('PySide2.QtCore.QCborStringResultByteArray',)],
-    "PySide2.QtCore.QCborStringResultByteArray.__copy__": (),
-# class PySide2.QtCore.QCborStringResultString:
-    "PySide2.QtCore.QCborStringResultString.__init__": [(), ('PySide2.QtCore.QCborStringResultString',)],
-    "PySide2.QtCore.QCborStringResultString.__copy__": (),
-# class PySide2.QtCore.QCborValue:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOption:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOptions:
-# class PySide2.QtCore.QCborValue.EncodingOption:
-# class PySide2.QtCore.QCborValue.EncodingOptions:
-# class PySide2.QtCore.QCborValue.Type:
-    "PySide2.QtCore.QCborValue.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborKnownTags', 'PySide2.QtCore.QCborValue'), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborSimpleType',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QCborValue.Type',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborValue.__copy__": (),
-    "PySide2.QtCore.QCborValue.compare": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.fromCbor": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCborParserError'), ('PySide2.QtCore.QCborStreamReader',), ('bytearray', 'int', 'PySide2.QtCore.QCborParserError'), ('str', 'int', 'PySide2.QtCore.QCborParserError')],
-    "PySide2.QtCore.QCborValue.fromJsonValue": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QCborValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QCborValue.isArray": (),
-    "PySide2.QtCore.QCborValue.isBool": (),
-    "PySide2.QtCore.QCborValue.isByteArray": (),
-    "PySide2.QtCore.QCborValue.isContainer": (),
-    "PySide2.QtCore.QCborValue.isDateTime": (),
-    "PySide2.QtCore.QCborValue.isDouble": (),
-    "PySide2.QtCore.QCborValue.isFalse": (),
-    "PySide2.QtCore.QCborValue.isInteger": (),
-    "PySide2.QtCore.QCborValue.isInvalid": (),
-    "PySide2.QtCore.QCborValue.isMap": (),
-    "PySide2.QtCore.QCborValue.isNull": (),
-    "PySide2.QtCore.QCborValue.isRegularExpression": (),
-    "PySide2.QtCore.QCborValue.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborValue.isString": (),
-    "PySide2.QtCore.QCborValue.isTag": (),
-    "PySide2.QtCore.QCborValue.isTrue": (),
-    "PySide2.QtCore.QCborValue.isUndefined": (),
-    "PySide2.QtCore.QCborValue.isUrl": (),
-    "PySide2.QtCore.QCborValue.isUuid": (),
-    "PySide2.QtCore.QCborValue.swap": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.taggedValue": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.toArray": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborValue.toBool": ('bool',),
-    "PySide2.QtCore.QCborValue.toByteArray": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QCborValue.toCbor": [('PySide2.QtCore.QCborStreamWriter', 'PySide2.QtCore.QCborValue.EncodingOptions'), ('PySide2.QtCore.QCborValue.EncodingOptions',)],
-    "PySide2.QtCore.QCborValue.toDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QCborValue.toDiagnosticNotation": ('PySide2.QtCore.QCborValue.DiagnosticNotationOptions',),
-    "PySide2.QtCore.QCborValue.toDouble": ('float',),
-    "PySide2.QtCore.QCborValue.toInteger": ('int',),
-    "PySide2.QtCore.QCborValue.toJsonValue": (),
-    "PySide2.QtCore.QCborValue.toMap": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborValue.toRegularExpression": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QCborValue.toSimpleType": ('PySide2.QtCore.QCborSimpleType',),
-    "PySide2.QtCore.QCborValue.toString": ('str',),
-    "PySide2.QtCore.QCborValue.toUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QCborValue.toUuid": ('PySide2.QtCore.QUuid',),
-    "PySide2.QtCore.QCborValue.toVariant": (),
-    "PySide2.QtCore.QCborValue.type": (),
-# class PySide2.QtCore.QChildEvent:
-    "PySide2.QtCore.QChildEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QChildEvent.added": (),
-    "PySide2.QtCore.QChildEvent.child": (),
-    "PySide2.QtCore.QChildEvent.polished": (),
-    "PySide2.QtCore.QChildEvent.removed": (),
-# class PySide2.QtCore.QCollator:
-    "PySide2.QtCore.QCollator.__init__": [(), ('PySide2.QtCore.QCollator',), ('PySide2.QtCore.QLocale',)],
-    "PySide2.QtCore.QCollator.__call__": ('str', 'str'),
-    "PySide2.QtCore.QCollator.caseSensitivity": (),
-    "PySide2.QtCore.QCollator.compare": [('str', 'int', 'str', 'int'), ('str', 'str')],
-    "PySide2.QtCore.QCollator.ignorePunctuation": (),
-    "PySide2.QtCore.QCollator.locale": (),
-    "PySide2.QtCore.QCollator.numericMode": (),
-    "PySide2.QtCore.QCollator.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QCollator.setIgnorePunctuation": ('bool',),
-    "PySide2.QtCore.QCollator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QCollator.setNumericMode": ('bool',),
-    "PySide2.QtCore.QCollator.sortKey": ('str',),
-    "PySide2.QtCore.QCollator.swap": ('PySide2.QtCore.QCollator',),
-# class PySide2.QtCore.QCollatorSortKey:
-    "PySide2.QtCore.QCollatorSortKey.__init__": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.compare": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.swap": ('PySide2.QtCore.QCollatorSortKey',),
-# class PySide2.QtCore.QCommandLineOption:
-# class PySide2.QtCore.QCommandLineOption.Flag:
-# class PySide2.QtCore.QCommandLineOption.Flags:
-    "PySide2.QtCore.QCommandLineOption.__init__": [('PySide2.QtCore.QCommandLineOption',), ('str',), ('str', 'str', 'str', 'str'), ('typing.Sequence[str]',), ('typing.Sequence[str]', 'str', 'str', 'str')],
-    "PySide2.QtCore.QCommandLineOption.defaultValues": (),
-    "PySide2.QtCore.QCommandLineOption.description": (),
-    "PySide2.QtCore.QCommandLineOption.flags": (),
-    "PySide2.QtCore.QCommandLineOption.isHidden": (),
-    "PySide2.QtCore.QCommandLineOption.names": (),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValue": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValues": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineOption.setDescription": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setFlags": ('PySide2.QtCore.QCommandLineOption.Flags',),
-    "PySide2.QtCore.QCommandLineOption.setHidden": ('bool',),
-    "PySide2.QtCore.QCommandLineOption.setValueName": ('str',),
-    "PySide2.QtCore.QCommandLineOption.swap": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineOption.valueName": (),
-# class PySide2.QtCore.QCommandLineParser:
-# class PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode:
-# class PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode:
-    "PySide2.QtCore.QCommandLineParser.__init__": (),
-    "PySide2.QtCore.QCommandLineParser.addHelpOption": (),
-    "PySide2.QtCore.QCommandLineParser.addOption": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineParser.addOptions": ('typing.Sequence[PySide2.QtCore.QCommandLineOption]',),
-    "PySide2.QtCore.QCommandLineParser.addPositionalArgument": ('str', 'str', 'str'),
-    "PySide2.QtCore.QCommandLineParser.addVersionOption": (),
-    "PySide2.QtCore.QCommandLineParser.applicationDescription": (),
-    "PySide2.QtCore.QCommandLineParser.clearPositionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.errorText": (),
-    "PySide2.QtCore.QCommandLineParser.helpText": (),
-    "PySide2.QtCore.QCommandLineParser.isSet": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.optionNames": (),
-    "PySide2.QtCore.QCommandLineParser.parse": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineParser.positionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.process": [('PySide2.QtCore.QCoreApplication',), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCommandLineParser.setApplicationDescription": ('str',),
-    "PySide2.QtCore.QCommandLineParser.setOptionsAfterPositionalArgumentsMode": ('PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode',),
-    "PySide2.QtCore.QCommandLineParser.setSingleDashWordOptionMode": ('PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode',),
-    "PySide2.QtCore.QCommandLineParser.showHelp": ('int',),
-    "PySide2.QtCore.QCommandLineParser.showVersion": (),
-    "PySide2.QtCore.QCommandLineParser.unknownOptionNames": (),
-    "PySide2.QtCore.QCommandLineParser.value": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.values": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-# class PySide2.QtCore.QConcatenateTablesProxyModel:
-    "PySide2.QtCore.QConcatenateTablesProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.addSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QConcatenateTablesProxyModel.removeSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QCoreApplication:
-    "PySide2.QtCore.QCoreApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCoreApplication.addLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.applicationDirPath": (),
-    "PySide2.QtCore.QCoreApplication.applicationFilePath": (),
-    "PySide2.QtCore.QCoreApplication.applicationName": (),
-    "PySide2.QtCore.QCoreApplication.applicationPid": (),
-    "PySide2.QtCore.QCoreApplication.applicationVersion": (),
-    "PySide2.QtCore.QCoreApplication.arguments": (),
-    "PySide2.QtCore.QCoreApplication.closingDown": (),
-    "PySide2.QtCore.QCoreApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QCoreApplication.eventDispatcher": (),
-    "PySide2.QtCore.QCoreApplication.exec_": (),
-    "PySide2.QtCore.QCoreApplication.exit": ('int',),
-    "PySide2.QtCore.QCoreApplication.flush": (),
-    "PySide2.QtCore.QCoreApplication.hasPendingEvents": (),
-    "PySide2.QtCore.QCoreApplication.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.installTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.instance": (),
-    "PySide2.QtCore.QCoreApplication.isQuitLockEnabled": (),
-    "PySide2.QtCore.QCoreApplication.isSetuidAllowed": (),
-    "PySide2.QtCore.QCoreApplication.libraryPaths": (),
-    "PySide2.QtCore.QCoreApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.organizationDomain": (),
-    "PySide2.QtCore.QCoreApplication.organizationName": (),
-    "PySide2.QtCore.QCoreApplication.postEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QCoreApplication.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QCoreApplication.quit": (),
-    "PySide2.QtCore.QCoreApplication.removeLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.removePostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.removeTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.sendEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.sendPostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.setApplicationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setApplicationVersion": ('str',),
-    "PySide2.QtCore.QCoreApplication.setAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute', 'bool'),
-    "PySide2.QtCore.QCoreApplication.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QCoreApplication.setLibraryPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationDomain": ('str',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setQuitLockEnabled": ('bool',),
-    "PySide2.QtCore.QCoreApplication.setSetuidAllowed": ('bool',),
-    "PySide2.QtCore.QCoreApplication.shutdown": (),
-    "PySide2.QtCore.QCoreApplication.startingUp": (),
-    "PySide2.QtCore.QCoreApplication.testAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute',),
-    "PySide2.QtCore.QCoreApplication.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QCryptographicHash:
-# class PySide2.QtCore.QCryptographicHash.Algorithm:
-    "PySide2.QtCore.QCryptographicHash.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QCryptographicHash.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QCryptographicHash.hashLength": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.reset": (),
-    "PySide2.QtCore.QCryptographicHash.result": (),
-# class PySide2.QtCore.QDataStream:
-# class PySide2.QtCore.QDataStream.ByteOrder:
-# class PySide2.QtCore.QDataStream.FloatingPointPrecision:
-# class PySide2.QtCore.QDataStream.Status:
-# class PySide2.QtCore.QDataStream.Version:
-    "PySide2.QtCore.QDataStream.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QDataStream.__lshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',), ('str',)],
-    "PySide2.QtCore.QDataStream.__rshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',)],
-    "PySide2.QtCore.QDataStream.abortTransaction": (),
-    "PySide2.QtCore.QDataStream.atEnd": (),
-    "PySide2.QtCore.QDataStream.byteOrder": (),
-    "PySide2.QtCore.QDataStream.commitTransaction": (),
-    "PySide2.QtCore.QDataStream.device": (),
-    "PySide2.QtCore.QDataStream.floatingPointPrecision": (),
-    "PySide2.QtCore.QDataStream.readBool": (),
-    "PySide2.QtCore.QDataStream.readDouble": (),
-    "PySide2.QtCore.QDataStream.readFloat": (),
-    "PySide2.QtCore.QDataStream.readInt16": (),
-    "PySide2.QtCore.QDataStream.readInt32": (),
-    "PySide2.QtCore.QDataStream.readInt64": (),
-    "PySide2.QtCore.QDataStream.readInt8": (),
-    "PySide2.QtCore.QDataStream.readQChar": (),
-    "PySide2.QtCore.QDataStream.readQString": (),
-    "PySide2.QtCore.QDataStream.readQStringList": (),
-    "PySide2.QtCore.QDataStream.readQVariant": (),
-    "PySide2.QtCore.QDataStream.readRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.readString": (),
-    "PySide2.QtCore.QDataStream.readUInt16": (),
-    "PySide2.QtCore.QDataStream.readUInt32": (),
-    "PySide2.QtCore.QDataStream.readUInt64": (),
-    "PySide2.QtCore.QDataStream.readUInt8": (),
-    "PySide2.QtCore.QDataStream.resetStatus": (),
-    "PySide2.QtCore.QDataStream.rollbackTransaction": (),
-    "PySide2.QtCore.QDataStream.setByteOrder": ('PySide2.QtCore.QDataStream.ByteOrder',),
-    "PySide2.QtCore.QDataStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QDataStream.setFloatingPointPrecision": ('PySide2.QtCore.QDataStream.FloatingPointPrecision',),
-    "PySide2.QtCore.QDataStream.setStatus": ('PySide2.QtCore.QDataStream.Status',),
-    "PySide2.QtCore.QDataStream.setVersion": ('int',),
-    "PySide2.QtCore.QDataStream.skipRawData": ('int',),
-    "PySide2.QtCore.QDataStream.startTransaction": (),
-    "PySide2.QtCore.QDataStream.status": (),
-    "PySide2.QtCore.QDataStream.unsetDevice": (),
-    "PySide2.QtCore.QDataStream.version": (),
-    "PySide2.QtCore.QDataStream.writeBool": ('bool',),
-    "PySide2.QtCore.QDataStream.writeDouble": ('float',),
-    "PySide2.QtCore.QDataStream.writeFloat": ('float',),
-    "PySide2.QtCore.QDataStream.writeInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt8": ('int',),
-    "PySide2.QtCore.QDataStream.writeQChar": ('str',),
-    "PySide2.QtCore.QDataStream.writeQString": ('str',),
-    "PySide2.QtCore.QDataStream.writeQStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDataStream.writeQVariant": ('typing.Any',),
-    "PySide2.QtCore.QDataStream.writeRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.writeString": ('str',),
-    "PySide2.QtCore.QDataStream.writeUInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt8": ('int',),
-# class PySide2.QtCore.QDate:
-# class PySide2.QtCore.QDate.MonthNameType:
-    "PySide2.QtCore.QDate.__init__": [(), ('PySide2.QtCore.QDate',), ('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.__copy__": (),
-    "PySide2.QtCore.QDate.__reduce__": (),
-    "PySide2.QtCore.QDate.__repr__": (),
-    "PySide2.QtCore.QDate.addDays": ('int',),
-    "PySide2.QtCore.QDate.addMonths": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.addYears": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.currentDate": (),
-    "PySide2.QtCore.QDate.day": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfWeek": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInMonth": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysTo": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDate.endOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.fromJulianDay": ('int',),
-    "PySide2.QtCore.QDate.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.getDate": (),
-    "PySide2.QtCore.QDate.isLeapYear": ('int',),
-    "PySide2.QtCore.QDate.isNull": (),
-    "PySide2.QtCore.QDate.isValid": [(), ('int', 'int', 'int')],
-    "PySide2.QtCore.QDate.longDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.longMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.month": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.setDate": [('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.shortDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.shortMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.startOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.toJulianDay": (),
-    "PySide2.QtCore.QDate.toPython": (),
-    "PySide2.QtCore.QDate.toString": [('PySide2.QtCore.Qt.DateFormat',), ('PySide2.QtCore.Qt.DateFormat', 'PySide2.QtCore.QCalendar'), ('str',), ('str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.weekNumber": (),
-    "PySide2.QtCore.QDate.year": [(), ('PySide2.QtCore.QCalendar',)],
-# class PySide2.QtCore.QDateTime:
-# class PySide2.QtCore.QDateTime.YearRange:
-    "PySide2.QtCore.QDateTime.__init__": [(), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.QTimeZone'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec', 'int'), ('PySide2.QtCore.QDateTime',), ('int', 'int', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QDateTime.__copy__": (),
-    "PySide2.QtCore.QDateTime.__reduce__": (),
-    "PySide2.QtCore.QDateTime.__repr__": (),
-    "PySide2.QtCore.QDateTime.addDays": ('int',),
-    "PySide2.QtCore.QDateTime.addMSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addMonths": ('int',),
-    "PySide2.QtCore.QDateTime.addSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addYears": ('int',),
-    "PySide2.QtCore.QDateTime.currentDateTime": (),
-    "PySide2.QtCore.QDateTime.currentDateTimeUtc": (),
-    "PySide2.QtCore.QDateTime.currentMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.currentSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.date": (),
-    "PySide2.QtCore.QDateTime.daysTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.fromMSecsSinceEpoch": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromSecsSinceEpoch": [('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDateTime.fromTime_t": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.isDaylightTime": (),
-    "PySide2.QtCore.QDateTime.isNull": (),
-    "PySide2.QtCore.QDateTime.isValid": (),
-    "PySide2.QtCore.QDateTime.msecsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.offsetFromUtc": (),
-    "PySide2.QtCore.QDateTime.secsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDateTime.setMSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.setSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QDateTime.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.setTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.setTime_t": ('int',),
-    "PySide2.QtCore.QDateTime.setUtcOffset": ('int',),
-    "PySide2.QtCore.QDateTime.swap": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.time": (),
-    "PySide2.QtCore.QDateTime.timeSpec": (),
-    "PySide2.QtCore.QDateTime.timeZone": (),
-    "PySide2.QtCore.QDateTime.timeZoneAbbreviation": (),
-    "PySide2.QtCore.QDateTime.toLocalTime": (),
-    "PySide2.QtCore.QDateTime.toMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.toPython": (),
-    "PySide2.QtCore.QDateTime.toSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-    "PySide2.QtCore.QDateTime.toTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.toTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.toTime_t": (),
-    "PySide2.QtCore.QDateTime.toUTC": (),
-    "PySide2.QtCore.QDateTime.utcOffset": (),
-# class PySide2.QtCore.QDeadlineTimer:
-# class PySide2.QtCore.QDeadlineTimer.ForeverConstant:
-    "PySide2.QtCore.QDeadlineTimer.__init__": [('PySide2.QtCore.QDeadlineTimer',), ('PySide2.QtCore.QDeadlineTimer.ForeverConstant', 'PySide2.QtCore.Qt.TimerType'), ('PySide2.QtCore.Qt.TimerType',), ('int', 'PySide2.QtCore.Qt.TimerType')],
-    "PySide2.QtCore.QDeadlineTimer.__copy__": (),
-    "PySide2.QtCore.QDeadlineTimer.__iadd__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer.__isub__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer._q_data": (),
-    "PySide2.QtCore.QDeadlineTimer.addNSecs": ('PySide2.QtCore.QDeadlineTimer', 'int'),
-    "PySide2.QtCore.QDeadlineTimer.current": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.deadline": (),
-    "PySide2.QtCore.QDeadlineTimer.deadlineNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.hasExpired": (),
-    "PySide2.QtCore.QDeadlineTimer.isForever": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTime": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTimeNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.setDeadline": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseDeadline": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseRemainingTime": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setRemainingTime": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.swap": ('PySide2.QtCore.QDeadlineTimer',),
-    "PySide2.QtCore.QDeadlineTimer.timerType": (),
-# class PySide2.QtCore.QDir:
-# class PySide2.QtCore.QDir.Filter:
-# class PySide2.QtCore.QDir.Filters:
-# class PySide2.QtCore.QDir.SortFlag:
-# class PySide2.QtCore.QDir.SortFlags:
-    "PySide2.QtCore.QDir.__init__": [('PySide2.QtCore.QDir',), ('str',), ('str', 'str', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QDir.Filters')],
-    "PySide2.QtCore.QDir.__copy__": (),
-    "PySide2.QtCore.QDir.__reduce__": (),
-    "PySide2.QtCore.QDir.absoluteFilePath": ('str',),
-    "PySide2.QtCore.QDir.absolutePath": (),
-    "PySide2.QtCore.QDir.addResourceSearchPath": ('str',),
-    "PySide2.QtCore.QDir.addSearchPath": ('str', 'str'),
-    "PySide2.QtCore.QDir.canonicalPath": (),
-    "PySide2.QtCore.QDir.cd": ('str',),
-    "PySide2.QtCore.QDir.cdUp": (),
-    "PySide2.QtCore.QDir.cleanPath": ('str',),
-    "PySide2.QtCore.QDir.count": (),
-    "PySide2.QtCore.QDir.current": (),
-    "PySide2.QtCore.QDir.currentPath": (),
-    "PySide2.QtCore.QDir.dirName": (),
-    "PySide2.QtCore.QDir.drives": (),
-    "PySide2.QtCore.QDir.entryInfoList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.entryList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.exists": [(), ('str',)],
-    "PySide2.QtCore.QDir.filePath": ('str',),
-    "PySide2.QtCore.QDir.filter": (),
-    "PySide2.QtCore.QDir.fromNativeSeparators": ('str',),
-    "PySide2.QtCore.QDir.home": (),
-    "PySide2.QtCore.QDir.homePath": (),
-    "PySide2.QtCore.QDir.isAbsolute": (),
-    "PySide2.QtCore.QDir.isAbsolutePath": ('str',),
-    "PySide2.QtCore.QDir.isEmpty": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.isReadable": (),
-    "PySide2.QtCore.QDir.isRelative": (),
-    "PySide2.QtCore.QDir.isRelativePath": ('str',),
-    "PySide2.QtCore.QDir.isRoot": (),
-    "PySide2.QtCore.QDir.listSeparator": (),
-    "PySide2.QtCore.QDir.makeAbsolute": (),
-    "PySide2.QtCore.QDir.match": [('str', 'str'), ('typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QDir.mkdir": ('str',),
-    "PySide2.QtCore.QDir.mkpath": ('str',),
-    "PySide2.QtCore.QDir.nameFilters": (),
-    "PySide2.QtCore.QDir.nameFiltersFromString": ('str',),
-    "PySide2.QtCore.QDir.path": (),
-    "PySide2.QtCore.QDir.refresh": (),
-    "PySide2.QtCore.QDir.relativeFilePath": ('str',),
-    "PySide2.QtCore.QDir.remove": ('str',),
-    "PySide2.QtCore.QDir.removeRecursively": (),
-    "PySide2.QtCore.QDir.rename": ('str', 'str'),
-    "PySide2.QtCore.QDir.rmdir": ('str',),
-    "PySide2.QtCore.QDir.rmpath": ('str',),
-    "PySide2.QtCore.QDir.root": (),
-    "PySide2.QtCore.QDir.rootPath": (),
-    "PySide2.QtCore.QDir.searchPaths": ('str',),
-    "PySide2.QtCore.QDir.separator": (),
-    "PySide2.QtCore.QDir.setCurrent": ('str',),
-    "PySide2.QtCore.QDir.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDir.setPath": ('str',),
-    "PySide2.QtCore.QDir.setSearchPaths": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QDir.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtCore.QDir.sorting": (),
-    "PySide2.QtCore.QDir.swap": ('PySide2.QtCore.QDir',),
-    "PySide2.QtCore.QDir.temp": (),
-    "PySide2.QtCore.QDir.tempPath": (),
-    "PySide2.QtCore.QDir.toNativeSeparators": ('str',),
-# class PySide2.QtCore.QDirIterator:
-# class PySide2.QtCore.QDirIterator.IteratorFlag:
-# class PySide2.QtCore.QDirIterator.IteratorFlags:
-    "PySide2.QtCore.QDirIterator.__init__": [('PySide2.QtCore.QDir', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags')],
-    "PySide2.QtCore.QDirIterator.fileInfo": (),
-    "PySide2.QtCore.QDirIterator.fileName": (),
-    "PySide2.QtCore.QDirIterator.filePath": (),
-    "PySide2.QtCore.QDirIterator.hasNext": (),
-    "PySide2.QtCore.QDirIterator.path": (),
-# class PySide2.QtCore.QDynamicPropertyChangeEvent:
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.__init__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.propertyName": (),
-# class PySide2.QtCore.QEasingCurve:
-# class PySide2.QtCore.QEasingCurve.Type:
-    "PySide2.QtCore.QEasingCurve.__init__": [('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QEasingCurve.Type',)],
-    "PySide2.QtCore.QEasingCurve.__copy__": (),
-    "PySide2.QtCore.QEasingCurve.addCubicBezierSegment": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QEasingCurve.addTCBSegment": ('PySide2.QtCore.QPointF', 'float', 'float', 'float'),
-    "PySide2.QtCore.QEasingCurve.amplitude": (),
-    "PySide2.QtCore.QEasingCurve.customType": (),
-    "PySide2.QtCore.QEasingCurve.overshoot": (),
-    "PySide2.QtCore.QEasingCurve.period": (),
-    "PySide2.QtCore.QEasingCurve.setAmplitude": ('float',),
-    "PySide2.QtCore.QEasingCurve.setCustomType": ('object',),
-    "PySide2.QtCore.QEasingCurve.setOvershoot": ('float',),
-    "PySide2.QtCore.QEasingCurve.setPeriod": ('float',),
-    "PySide2.QtCore.QEasingCurve.setType": ('PySide2.QtCore.QEasingCurve.Type',),
-    "PySide2.QtCore.QEasingCurve.swap": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QEasingCurve.toCubicSpline": (),
-    "PySide2.QtCore.QEasingCurve.type": (),
-    "PySide2.QtCore.QEasingCurve.valueForProgress": ('float',),
-# class PySide2.QtCore.QElapsedTimer:
-# class PySide2.QtCore.QElapsedTimer.ClockType:
-    "PySide2.QtCore.QElapsedTimer.__init__": [(), ('PySide2.QtCore.QElapsedTimer',)],
-    "PySide2.QtCore.QElapsedTimer.__copy__": (),
-    "PySide2.QtCore.QElapsedTimer.clockType": (),
-    "PySide2.QtCore.QElapsedTimer.elapsed": (),
-    "PySide2.QtCore.QElapsedTimer.hasExpired": ('int',),
-    "PySide2.QtCore.QElapsedTimer.invalidate": (),
-    "PySide2.QtCore.QElapsedTimer.isMonotonic": (),
-    "PySide2.QtCore.QElapsedTimer.isValid": (),
-    "PySide2.QtCore.QElapsedTimer.msecsSinceReference": (),
-    "PySide2.QtCore.QElapsedTimer.msecsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.nsecsElapsed": (),
-    "PySide2.QtCore.QElapsedTimer.restart": (),
-    "PySide2.QtCore.QElapsedTimer.secsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.start": (),
-# class PySide2.QtCore.QEvent:
-# class PySide2.QtCore.QEvent.Type:
-    "PySide2.QtCore.QEvent.__init__": [('PySide2.QtCore.QEvent',), ('PySide2.QtCore.QEvent.Type',)],
-    "PySide2.QtCore.QEvent.accept": (),
-    "PySide2.QtCore.QEvent.ignore": (),
-    "PySide2.QtCore.QEvent.isAccepted": (),
-    "PySide2.QtCore.QEvent.registerEventType": ('int',),
-    "PySide2.QtCore.QEvent.setAccepted": ('bool',),
-    "PySide2.QtCore.QEvent.spontaneous": (),
-    "PySide2.QtCore.QEvent.type": (),
-# class PySide2.QtCore.QEventLoop:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlag:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlags:
-    "PySide2.QtCore.QEventLoop.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventLoop.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventLoop.exec_": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QEventLoop.exit": ('int',),
-    "PySide2.QtCore.QEventLoop.isRunning": (),
-    "PySide2.QtCore.QEventLoop.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QEventLoop.quit": (),
-    "PySide2.QtCore.QEventLoop.wakeUp": (),
-# class PySide2.QtCore.QEventTransition:
-    "PySide2.QtCore.QEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QEventTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventSource": (),
-    "PySide2.QtCore.QEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventType": (),
-    "PySide2.QtCore.QEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.setEventSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventTransition.setEventType": ('PySide2.QtCore.QEvent.Type',),
-# class PySide2.QtCore.QFactoryInterface:
-    "PySide2.QtCore.QFactoryInterface.__init__": (),
-    "PySide2.QtCore.QFactoryInterface.keys": (),
-# class PySide2.QtCore.QFile:
-    "PySide2.QtCore.QFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFile.copy": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.decodeName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QFile.encodeName": ('str',),
-    "PySide2.QtCore.QFile.exists": [(), ('str',)],
-    "PySide2.QtCore.QFile.fileName": (),
-    "PySide2.QtCore.QFile.link": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.open": [('PySide2.QtCore.QIODevice.OpenMode',), ('int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtCore.QFileDevice.FileHandleFlags')],
-    "PySide2.QtCore.QFile.permissions": [(), ('str',)],
-    "PySide2.QtCore.QFile.readLink": [(), ('str',)],
-    "PySide2.QtCore.QFile.remove": [(), ('str',)],
-    "PySide2.QtCore.QFile.rename": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.resize": [('int',), ('str', 'int')],
-    "PySide2.QtCore.QFile.setFileName": ('str',),
-    "PySide2.QtCore.QFile.setPermissions": [('PySide2.QtCore.QFileDevice.Permissions',), ('str', 'PySide2.QtCore.QFileDevice.Permissions')],
-    "PySide2.QtCore.QFile.size": (),
-    "PySide2.QtCore.QFile.symLinkTarget": [(), ('str',)],
-# class PySide2.QtCore.QFileDevice:
-# class PySide2.QtCore.QFileDevice.FileError:
-# class PySide2.QtCore.QFileDevice.FileHandleFlag:
-# class PySide2.QtCore.QFileDevice.FileHandleFlags:
-# class PySide2.QtCore.QFileDevice.FileTime:
-# class PySide2.QtCore.QFileDevice.MemoryMapFlags:
-# class PySide2.QtCore.QFileDevice.Permission:
-# class PySide2.QtCore.QFileDevice.Permissions:
-    "PySide2.QtCore.QFileDevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QFileDevice.atEnd": (),
-    "PySide2.QtCore.QFileDevice.close": (),
-    "PySide2.QtCore.QFileDevice.error": (),
-    "PySide2.QtCore.QFileDevice.fileName": (),
-    "PySide2.QtCore.QFileDevice.fileTime": ('PySide2.QtCore.QFileDevice.FileTime',),
-    "PySide2.QtCore.QFileDevice.flush": (),
-    "PySide2.QtCore.QFileDevice.handle": (),
-    "PySide2.QtCore.QFileDevice.isSequential": (),
-    "PySide2.QtCore.QFileDevice.map": ('int', 'int', 'PySide2.QtCore.QFileDevice.MemoryMapFlags'),
-    "PySide2.QtCore.QFileDevice.permissions": (),
-    "PySide2.QtCore.QFileDevice.pos": (),
-    "PySide2.QtCore.QFileDevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.resize": ('int',),
-    "PySide2.QtCore.QFileDevice.seek": ('int',),
-    "PySide2.QtCore.QFileDevice.setFileTime": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QFileDevice.FileTime'),
-    "PySide2.QtCore.QFileDevice.setPermissions": ('PySide2.QtCore.QFileDevice.Permissions',),
-    "PySide2.QtCore.QFileDevice.size": (),
-    "PySide2.QtCore.QFileDevice.unmap": ('str',),
-    "PySide2.QtCore.QFileDevice.unsetError": (),
-    "PySide2.QtCore.QFileDevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QFileInfo:
-    "PySide2.QtCore.QFileInfo.__init__": [(), ('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('PySide2.QtCore.QFileInfo',), ('str',)],
-    "PySide2.QtCore.QFileInfo.__copy__": (),
-    "PySide2.QtCore.QFileInfo.__reduce__": (),
-    "PySide2.QtCore.QFileInfo.absoluteDir": (),
-    "PySide2.QtCore.QFileInfo.absoluteFilePath": (),
-    "PySide2.QtCore.QFileInfo.absolutePath": (),
-    "PySide2.QtCore.QFileInfo.baseName": (),
-    "PySide2.QtCore.QFileInfo.birthTime": (),
-    "PySide2.QtCore.QFileInfo.bundleName": (),
-    "PySide2.QtCore.QFileInfo.caching": (),
-    "PySide2.QtCore.QFileInfo.canonicalFilePath": (),
-    "PySide2.QtCore.QFileInfo.canonicalPath": (),
-    "PySide2.QtCore.QFileInfo.completeBaseName": (),
-    "PySide2.QtCore.QFileInfo.completeSuffix": (),
-    "PySide2.QtCore.QFileInfo.created": (),
-    "PySide2.QtCore.QFileInfo.dir": (),
-    "PySide2.QtCore.QFileInfo.exists": [(), ('str',)],
-    "PySide2.QtCore.QFileInfo.fileName": (),
-    "PySide2.QtCore.QFileInfo.filePath": (),
-    "PySide2.QtCore.QFileInfo.group": (),
-    "PySide2.QtCore.QFileInfo.groupId": (),
-    "PySide2.QtCore.QFileInfo.isAbsolute": (),
-    "PySide2.QtCore.QFileInfo.isBundle": (),
-    "PySide2.QtCore.QFileInfo.isDir": (),
-    "PySide2.QtCore.QFileInfo.isExecutable": (),
-    "PySide2.QtCore.QFileInfo.isFile": (),
-    "PySide2.QtCore.QFileInfo.isHidden": (),
-    "PySide2.QtCore.QFileInfo.isNativePath": (),
-    "PySide2.QtCore.QFileInfo.isReadable": (),
-    "PySide2.QtCore.QFileInfo.isRelative": (),
-    "PySide2.QtCore.QFileInfo.isRoot": (),
-    "PySide2.QtCore.QFileInfo.isShortcut": (),
-    "PySide2.QtCore.QFileInfo.isSymLink": (),
-    "PySide2.QtCore.QFileInfo.isSymbolicLink": (),
-    "PySide2.QtCore.QFileInfo.isWritable": (),
-    "PySide2.QtCore.QFileInfo.lastModified": (),
-    "PySide2.QtCore.QFileInfo.lastRead": (),
-    "PySide2.QtCore.QFileInfo.makeAbsolute": (),
-    "PySide2.QtCore.QFileInfo.metadataChangeTime": (),
-    "PySide2.QtCore.QFileInfo.owner": (),
-    "PySide2.QtCore.QFileInfo.ownerId": (),
-    "PySide2.QtCore.QFileInfo.path": (),
-    "PySide2.QtCore.QFileInfo.readLink": (),
-    "PySide2.QtCore.QFileInfo.refresh": (),
-    "PySide2.QtCore.QFileInfo.setCaching": ('bool',),
-    "PySide2.QtCore.QFileInfo.setFile": [('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QFileInfo.size": (),
-    "PySide2.QtCore.QFileInfo.suffix": (),
-    "PySide2.QtCore.QFileInfo.swap": ('PySide2.QtCore.QFileInfo',),
-    "PySide2.QtCore.QFileInfo.symLinkTarget": (),
-# class PySide2.QtCore.QFileSelector:
-    "PySide2.QtCore.QFileSelector.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QFileSelector.allSelectors": (),
-    "PySide2.QtCore.QFileSelector.extraSelectors": (),
-    "PySide2.QtCore.QFileSelector.select": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtCore.QFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFileSystemWatcher:
-    "PySide2.QtCore.QFileSystemWatcher.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFileSystemWatcher.addPath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.addPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QFileSystemWatcher.directories": (),
-    "PySide2.QtCore.QFileSystemWatcher.files": (),
-    "PySide2.QtCore.QFileSystemWatcher.removePath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.removePaths": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFinalState:
-    "PySide2.QtCore.QFinalState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QFinalState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onExit": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtCore.QGenericArgument:
-    "PySide2.QtCore.QGenericArgument.__init__": [('PySide2.QtCore.QGenericArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericArgument.__copy__": (),
-    "PySide2.QtCore.QGenericArgument.data": (),
-    "PySide2.QtCore.QGenericArgument.name": (),
-# class PySide2.QtCore.QGenericReturnArgument:
-    "PySide2.QtCore.QGenericReturnArgument.__init__": [('PySide2.QtCore.QGenericReturnArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericReturnArgument.__copy__": (),
-# class PySide2.QtCore.QHistoryState:
-# class PySide2.QtCore.QHistoryState.HistoryType:
-    "PySide2.QtCore.QHistoryState.__init__": [('PySide2.QtCore.QHistoryState.HistoryType', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QHistoryState.defaultState": (),
-    "PySide2.QtCore.QHistoryState.defaultTransition": (),
-    "PySide2.QtCore.QHistoryState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.historyType": (),
-    "PySide2.QtCore.QHistoryState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.setDefaultState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QHistoryState.setDefaultTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QHistoryState.setHistoryType": ('PySide2.QtCore.QHistoryState.HistoryType',),
-# class PySide2.QtCore.QIODevice:
-# class PySide2.QtCore.QIODevice.OpenMode:
-# class PySide2.QtCore.QIODevice.OpenModeFlag:
-    "PySide2.QtCore.QIODevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QIODevice.atEnd": (),
-    "PySide2.QtCore.QIODevice.bytesAvailable": (),
-    "PySide2.QtCore.QIODevice.bytesToWrite": (),
-    "PySide2.QtCore.QIODevice.canReadLine": (),
-    "PySide2.QtCore.QIODevice.close": (),
-    "PySide2.QtCore.QIODevice.commitTransaction": (),
-    "PySide2.QtCore.QIODevice.currentReadChannel": (),
-    "PySide2.QtCore.QIODevice.currentWriteChannel": (),
-    "PySide2.QtCore.QIODevice.errorString": (),
-    "PySide2.QtCore.QIODevice.getChar": ('str',),
-    "PySide2.QtCore.QIODevice.isOpen": (),
-    "PySide2.QtCore.QIODevice.isReadable": (),
-    "PySide2.QtCore.QIODevice.isSequential": (),
-    "PySide2.QtCore.QIODevice.isTextModeEnabled": (),
-    "PySide2.QtCore.QIODevice.isTransactionStarted": (),
-    "PySide2.QtCore.QIODevice.isWritable": (),
-    "PySide2.QtCore.QIODevice.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.openMode": (),
-    "PySide2.QtCore.QIODevice.peek": ('int',),
-    "PySide2.QtCore.QIODevice.pos": (),
-    "PySide2.QtCore.QIODevice.putChar": ('int',),
-    "PySide2.QtCore.QIODevice.read": ('int',),
-    "PySide2.QtCore.QIODevice.readAll": (),
-    "PySide2.QtCore.QIODevice.readChannelCount": (),
-    "PySide2.QtCore.QIODevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.readLine": ('int',),
-    "PySide2.QtCore.QIODevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.reset": (),
-    "PySide2.QtCore.QIODevice.rollbackTransaction": (),
-    "PySide2.QtCore.QIODevice.seek": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentReadChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentWriteChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setErrorString": ('str',),
-    "PySide2.QtCore.QIODevice.setOpenMode": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.setTextModeEnabled": ('bool',),
-    "PySide2.QtCore.QIODevice.size": (),
-    "PySide2.QtCore.QIODevice.skip": ('int',),
-    "PySide2.QtCore.QIODevice.startTransaction": (),
-    "PySide2.QtCore.QIODevice.ungetChar": ('int',),
-    "PySide2.QtCore.QIODevice.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QIODevice.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QIODevice.write": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QIODevice.writeChannelCount": (),
-    "PySide2.QtCore.QIODevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QIdentityProxyModel:
-    "PySide2.QtCore.QIdentityProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QIdentityProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QIdentityProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QIdentityProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QIdentityProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QIdentityProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QItemSelection:
-    "PySide2.QtCore.QItemSelection.__init__": [(), ('PySide2.QtCore.QItemSelection',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelection.__add__": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.__copy__": (),
-    "PySide2.QtCore.QItemSelection.__iadd__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.__lshift__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.append": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.at": ('int',),
-    "PySide2.QtCore.QItemSelection.back": (),
-    "PySide2.QtCore.QItemSelection.clear": (),
-    "PySide2.QtCore.QItemSelection.constFirst": (),
-    "PySide2.QtCore.QItemSelection.constLast": (),
-    "PySide2.QtCore.QItemSelection.contains": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelection.count": [(), ('PySide2.QtCore.QItemSelectionRange',)],
-    "PySide2.QtCore.QItemSelection.detachShared": (),
-    "PySide2.QtCore.QItemSelection.empty": (),
-    "PySide2.QtCore.QItemSelection.endsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.first": (),
-    "PySide2.QtCore.QItemSelection.fromSet": ('typing.Set[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.fromVector": ('typing.List[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.front": (),
-    "PySide2.QtCore.QItemSelection.indexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.indexes": (),
-    "PySide2.QtCore.QItemSelection.insert": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.isEmpty": (),
-    "PySide2.QtCore.QItemSelection.isSharedWith": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.last": (),
-    "PySide2.QtCore.QItemSelection.lastIndexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.length": (),
-    "PySide2.QtCore.QItemSelection.merge": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelection.mid": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.move": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.pop_back": (),
-    "PySide2.QtCore.QItemSelection.pop_front": (),
-    "PySide2.QtCore.QItemSelection.prepend": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_back": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_front": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAll": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.removeFirst": (),
-    "PySide2.QtCore.QItemSelection.removeLast": (),
-    "PySide2.QtCore.QItemSelection.removeOne": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.replace": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.reserve": ('int',),
-    "PySide2.QtCore.QItemSelection.select": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelection.setSharable": ('bool',),
-    "PySide2.QtCore.QItemSelection.size": (),
-    "PySide2.QtCore.QItemSelection.split": ('PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelection.startsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.swap": [('int', 'int'), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.takeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.takeFirst": (),
-    "PySide2.QtCore.QItemSelection.takeLast": (),
-    "PySide2.QtCore.QItemSelection.toSet": (),
-    "PySide2.QtCore.QItemSelection.toVector": (),
-    "PySide2.QtCore.QItemSelection.value": [('int',), ('int', 'PySide2.QtCore.QItemSelectionRange')],
-# class PySide2.QtCore.QItemSelectionModel:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlag:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlags:
-    "PySide2.QtCore.QItemSelectionModel.__init__": [('PySide2.QtCore.QAbstractItemModel',), ('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QItemSelectionModel.clear": (),
-    "PySide2.QtCore.QItemSelectionModel.clearCurrentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.clearSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.columnIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.currentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.emitSelectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelectionModel.hasSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.isColumnSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isRowSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isSelected": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelectionModel.model": (),
-    "PySide2.QtCore.QItemSelectionModel.reset": (),
-    "PySide2.QtCore.QItemSelectionModel.rowIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.select": [('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtCore.QItemSelectionModel.selectedColumns": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selectedIndexes": (),
-    "PySide2.QtCore.QItemSelectionModel.selectedRows": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selection": (),
-    "PySide2.QtCore.QItemSelectionModel.setCurrentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelectionModel.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-# class PySide2.QtCore.QItemSelectionRange:
-    "PySide2.QtCore.QItemSelectionRange.__init__": [(), ('PySide2.QtCore.QItemSelectionRange',), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.__copy__": (),
-    "PySide2.QtCore.QItemSelectionRange.bottom": (),
-    "PySide2.QtCore.QItemSelectionRange.bottomRight": (),
-    "PySide2.QtCore.QItemSelectionRange.contains": [('PySide2.QtCore.QModelIndex',), ('int', 'int', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.height": (),
-    "PySide2.QtCore.QItemSelectionRange.indexes": (),
-    "PySide2.QtCore.QItemSelectionRange.intersected": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.intersects": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.isEmpty": (),
-    "PySide2.QtCore.QItemSelectionRange.isValid": (),
-    "PySide2.QtCore.QItemSelectionRange.left": (),
-    "PySide2.QtCore.QItemSelectionRange.model": (),
-    "PySide2.QtCore.QItemSelectionRange.parent": (),
-    "PySide2.QtCore.QItemSelectionRange.right": (),
-    "PySide2.QtCore.QItemSelectionRange.swap": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.top": (),
-    "PySide2.QtCore.QItemSelectionRange.topLeft": (),
-    "PySide2.QtCore.QItemSelectionRange.width": (),
-# class PySide2.QtCore.QJsonArray:
-    "PySide2.QtCore.QJsonArray.__init__": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonArray.__add__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__copy__": (),
-    "PySide2.QtCore.QJsonArray.__iadd__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__lshift__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.append": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.at": ('int',),
-    "PySide2.QtCore.QJsonArray.contains": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.count": (),
-    "PySide2.QtCore.QJsonArray.empty": (),
-    "PySide2.QtCore.QJsonArray.first": (),
-    "PySide2.QtCore.QJsonArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QJsonArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QJsonArray.insert": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.isEmpty": (),
-    "PySide2.QtCore.QJsonArray.last": (),
-    "PySide2.QtCore.QJsonArray.pop_back": (),
-    "PySide2.QtCore.QJsonArray.pop_front": (),
-    "PySide2.QtCore.QJsonArray.prepend": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_back": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_front": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.removeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.removeFirst": (),
-    "PySide2.QtCore.QJsonArray.removeLast": (),
-    "PySide2.QtCore.QJsonArray.replace": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.size": (),
-    "PySide2.QtCore.QJsonArray.swap": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonArray.takeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.toVariantList": (),
-# class PySide2.QtCore.QJsonDocument:
-# class PySide2.QtCore.QJsonDocument.DataValidation:
-# class PySide2.QtCore.QJsonDocument.JsonFormat:
-    "PySide2.QtCore.QJsonDocument.__init__": [(), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonDocument.__copy__": (),
-    "PySide2.QtCore.QJsonDocument.array": (),
-    "PySide2.QtCore.QJsonDocument.fromBinaryData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromJson": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonParseError'),
-    "PySide2.QtCore.QJsonDocument.fromRawData": ('str', 'int', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonDocument.isArray": (),
-    "PySide2.QtCore.QJsonDocument.isEmpty": (),
-    "PySide2.QtCore.QJsonDocument.isNull": (),
-    "PySide2.QtCore.QJsonDocument.isObject": (),
-    "PySide2.QtCore.QJsonDocument.object": (),
-    "PySide2.QtCore.QJsonDocument.rawData": (),
-    "PySide2.QtCore.QJsonDocument.setArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonDocument.setObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QJsonDocument.swap": ('PySide2.QtCore.QJsonDocument',),
-    "PySide2.QtCore.QJsonDocument.toBinaryData": (),
-    "PySide2.QtCore.QJsonDocument.toJson": [(), ('PySide2.QtCore.QJsonDocument.JsonFormat',)],
-    "PySide2.QtCore.QJsonDocument.toVariant": (),
-# class PySide2.QtCore.QJsonParseError:
-# class PySide2.QtCore.QJsonParseError.ParseError:
-    "PySide2.QtCore.QJsonParseError.__init__": [(), ('PySide2.QtCore.QJsonParseError',)],
-    "PySide2.QtCore.QJsonParseError.__copy__": (),
-    "PySide2.QtCore.QJsonParseError.errorString": (),
-# class PySide2.QtCore.QJsonValue:
-# class PySide2.QtCore.QJsonValue.Type:
-    "PySide2.QtCore.QJsonValue.__init__": [('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QJsonValue.Type',), ('bool',), ('float',), ('int',), ('str',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.__copy__": (),
-    "PySide2.QtCore.QJsonValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonValue.isArray": (),
-    "PySide2.QtCore.QJsonValue.isBool": (),
-    "PySide2.QtCore.QJsonValue.isDouble": (),
-    "PySide2.QtCore.QJsonValue.isNull": (),
-    "PySide2.QtCore.QJsonValue.isObject": (),
-    "PySide2.QtCore.QJsonValue.isString": (),
-    "PySide2.QtCore.QJsonValue.isUndefined": (),
-    "PySide2.QtCore.QJsonValue.swap": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonValue.toArray": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonValue.toBool": ('bool',),
-    "PySide2.QtCore.QJsonValue.toDouble": ('float',),
-    "PySide2.QtCore.QJsonValue.toInt": ('int',),
-    "PySide2.QtCore.QJsonValue.toObject": [(), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.toString": [(), ('str',)],
-    "PySide2.QtCore.QJsonValue.toVariant": (),
-    "PySide2.QtCore.QJsonValue.type": (),
-# class PySide2.QtCore.QLibraryInfo:
-# class PySide2.QtCore.QLibraryInfo.LibraryLocation:
-    "PySide2.QtCore.QLibraryInfo.build": (),
-    "PySide2.QtCore.QLibraryInfo.buildDate": (),
-    "PySide2.QtCore.QLibraryInfo.isDebugBuild": (),
-    "PySide2.QtCore.QLibraryInfo.licensedProducts": (),
-    "PySide2.QtCore.QLibraryInfo.licensee": (),
-    "PySide2.QtCore.QLibraryInfo.location": ('PySide2.QtCore.QLibraryInfo.LibraryLocation',),
-    "PySide2.QtCore.QLibraryInfo.platformPluginArguments": ('str',),
-    "PySide2.QtCore.QLibraryInfo.version": (),
-# class PySide2.QtCore.QLine:
-    "PySide2.QtCore.QLine.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QLine.__copy__": (),
-    "PySide2.QtCore.QLine.__reduce__": (),
-    "PySide2.QtCore.QLine.__repr__": (),
-    "PySide2.QtCore.QLine.center": (),
-    "PySide2.QtCore.QLine.dx": (),
-    "PySide2.QtCore.QLine.dy": (),
-    "PySide2.QtCore.QLine.isNull": (),
-    "PySide2.QtCore.QLine.p1": (),
-    "PySide2.QtCore.QLine.p2": (),
-    "PySide2.QtCore.QLine.setLine": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QLine.setP1": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setP2": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setPoints": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QLine.toTuple": (),
-    "PySide2.QtCore.QLine.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.x1": (),
-    "PySide2.QtCore.QLine.x2": (),
-    "PySide2.QtCore.QLine.y1": (),
-    "PySide2.QtCore.QLine.y2": (),
-# class PySide2.QtCore.QLineF:
-# class PySide2.QtCore.QLineF.IntersectType:
-    "PySide2.QtCore.QLineF.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QLineF.__copy__": (),
-    "PySide2.QtCore.QLineF.__reduce__": (),
-    "PySide2.QtCore.QLineF.__repr__": (),
-    "PySide2.QtCore.QLineF.angle": [(), ('PySide2.QtCore.QLineF',)],
-    "PySide2.QtCore.QLineF.angleTo": ('PySide2.QtCore.QLineF',),
-    "PySide2.QtCore.QLineF.center": (),
-    "PySide2.QtCore.QLineF.dx": (),
-    "PySide2.QtCore.QLineF.dy": (),
-    "PySide2.QtCore.QLineF.fromPolar": ('float', 'float'),
-    "PySide2.QtCore.QLineF.intersect": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.intersects": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.isNull": (),
-    "PySide2.QtCore.QLineF.length": (),
-    "PySide2.QtCore.QLineF.normalVector": (),
-    "PySide2.QtCore.QLineF.p1": (),
-    "PySide2.QtCore.QLineF.p2": (),
-    "PySide2.QtCore.QLineF.pointAt": ('float',),
-    "PySide2.QtCore.QLineF.setAngle": ('float',),
-    "PySide2.QtCore.QLineF.setLength": ('float',),
-    "PySide2.QtCore.QLineF.setLine": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QLineF.setP1": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setP2": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setPoints": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.toLine": (),
-    "PySide2.QtCore.QLineF.toTuple": (),
-    "PySide2.QtCore.QLineF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.unitVector": (),
-    "PySide2.QtCore.QLineF.x1": (),
-    "PySide2.QtCore.QLineF.x2": (),
-    "PySide2.QtCore.QLineF.y1": (),
-    "PySide2.QtCore.QLineF.y2": (),
-# class PySide2.QtCore.QLocale:
-# class PySide2.QtCore.QLocale.Country:
-# class PySide2.QtCore.QLocale.CurrencySymbolFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormats:
-# class PySide2.QtCore.QLocale.FloatingPointPrecisionOption:
-# class PySide2.QtCore.QLocale.FormatType:
-# class PySide2.QtCore.QLocale.Language:
-# class PySide2.QtCore.QLocale.MeasurementSystem:
-# class PySide2.QtCore.QLocale.NumberOption:
-# class PySide2.QtCore.QLocale.NumberOptions:
-# class PySide2.QtCore.QLocale.QuotationStyle:
-# class PySide2.QtCore.QLocale.Script:
-    "PySide2.QtCore.QLocale.__init__": [(), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Country'), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'), ('str',)],
-    "PySide2.QtCore.QLocale.__copy__": (),
-    "PySide2.QtCore.QLocale.amText": (),
-    "PySide2.QtCore.QLocale.bcp47Name": (),
-    "PySide2.QtCore.QLocale.c": (),
-    "PySide2.QtCore.QLocale.collation": (),
-    "PySide2.QtCore.QLocale.countriesForLanguage": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.country": (),
-    "PySide2.QtCore.QLocale.countryToString": ('PySide2.QtCore.QLocale.Country',),
-    "PySide2.QtCore.QLocale.createSeparatedList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QLocale.currencySymbol": ('PySide2.QtCore.QLocale.CurrencySymbolFormat',),
-    "PySide2.QtCore.QLocale.dateFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dateTimeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.decimalPoint": (),
-    "PySide2.QtCore.QLocale.exponential": (),
-    "PySide2.QtCore.QLocale.firstDayOfWeek": (),
-    "PySide2.QtCore.QLocale.formattedDataSize": ('int', 'int', 'PySide2.QtCore.QLocale.DataSizeFormats'),
-    "PySide2.QtCore.QLocale.groupSeparator": (),
-    "PySide2.QtCore.QLocale.language": (),
-    "PySide2.QtCore.QLocale.languageToString": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.matchingLocales": ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'),
-    "PySide2.QtCore.QLocale.measurementSystem": (),
-    "PySide2.QtCore.QLocale.monthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.name": (),
-    "PySide2.QtCore.QLocale.nativeCountryName": (),
-    "PySide2.QtCore.QLocale.nativeLanguageName": (),
-    "PySide2.QtCore.QLocale.negativeSign": (),
-    "PySide2.QtCore.QLocale.numberOptions": (),
-    "PySide2.QtCore.QLocale.percent": (),
-    "PySide2.QtCore.QLocale.pmText": (),
-    "PySide2.QtCore.QLocale.positiveSign": (),
-    "PySide2.QtCore.QLocale.quoteString": ('str', 'PySide2.QtCore.QLocale.QuotationStyle'),
-    "PySide2.QtCore.QLocale.script": (),
-    "PySide2.QtCore.QLocale.scriptToString": ('PySide2.QtCore.QLocale.Script',),
-    "PySide2.QtCore.QLocale.setDefault": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.setNumberOptions": ('PySide2.QtCore.QLocale.NumberOptions',),
-    "PySide2.QtCore.QLocale.standaloneDayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.standaloneMonthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.swap": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.system": (),
-    "PySide2.QtCore.QLocale.textDirection": (),
-    "PySide2.QtCore.QLocale.timeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.toCurrencyString": [('float', 'str'), ('float', 'str', 'int'), ('int', 'str')],
-    "PySide2.QtCore.QLocale.toDate": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDateTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDouble": ('str',),
-    "PySide2.QtCore.QLocale.toFloat": ('str',),
-    "PySide2.QtCore.QLocale.toInt": ('str',),
-    "PySide2.QtCore.QLocale.toLong": ('str',),
-    "PySide2.QtCore.QLocale.toLongLong": ('str',),
-    "PySide2.QtCore.QLocale.toLower": ('str',),
-    "PySide2.QtCore.QLocale.toShort": ('str',),
-    "PySide2.QtCore.QLocale.toString": [('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDate', 'str'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDateTime', 'str'), ('PySide2.QtCore.QTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QTime', 'str'), ('float', 'int', 'int'), ('int',)],
-    "PySide2.QtCore.QLocale.toTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toUInt": ('str',),
-    "PySide2.QtCore.QLocale.toULong": ('str',),
-    "PySide2.QtCore.QLocale.toULongLong": ('str',),
-    "PySide2.QtCore.QLocale.toUShort": ('str',),
-    "PySide2.QtCore.QLocale.toUpper": ('str',),
-    "PySide2.QtCore.QLocale.uiLanguages": (),
-    "PySide2.QtCore.QLocale.weekdays": (),
-    "PySide2.QtCore.QLocale.zeroDigit": (),
-# class PySide2.QtCore.QLockFile:
-# class PySide2.QtCore.QLockFile.LockError:
-    "PySide2.QtCore.QLockFile.__init__": ('str',),
-    "PySide2.QtCore.QLockFile.error": (),
-    "PySide2.QtCore.QLockFile.getLockInfo": (),
-    "PySide2.QtCore.QLockFile.isLocked": (),
-    "PySide2.QtCore.QLockFile.lock": (),
-    "PySide2.QtCore.QLockFile.removeStaleLockFile": (),
-    "PySide2.QtCore.QLockFile.setStaleLockTime": ('int',),
-    "PySide2.QtCore.QLockFile.staleLockTime": (),
-    "PySide2.QtCore.QLockFile.tryLock": ('int',),
-    "PySide2.QtCore.QLockFile.unlock": (),
-# class PySide2.QtCore.QMargins:
-    "PySide2.QtCore.QMargins.__init__": [(), ('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QMargins.__add__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__copy__": (),
-    "PySide2.QtCore.QMargins.__iadd__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__isub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__neg__": (),
-    "PySide2.QtCore.QMargins.__pos__": (),
-    "PySide2.QtCore.QMargins.__sub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.bottom": (),
-    "PySide2.QtCore.QMargins.isNull": (),
-    "PySide2.QtCore.QMargins.left": (),
-    "PySide2.QtCore.QMargins.right": (),
-    "PySide2.QtCore.QMargins.setBottom": ('int',),
-    "PySide2.QtCore.QMargins.setLeft": ('int',),
-    "PySide2.QtCore.QMargins.setRight": ('int',),
-    "PySide2.QtCore.QMargins.setTop": ('int',),
-    "PySide2.QtCore.QMargins.top": (),
-# class PySide2.QtCore.QMarginsF:
-    "PySide2.QtCore.QMarginsF.__init__": [(), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QMarginsF.__add__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__copy__": (),
-    "PySide2.QtCore.QMarginsF.__iadd__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__imul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__isub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__mul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__neg__": (),
-    "PySide2.QtCore.QMarginsF.__pos__": (),
-    "PySide2.QtCore.QMarginsF.__sub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.bottom": (),
-    "PySide2.QtCore.QMarginsF.isNull": (),
-    "PySide2.QtCore.QMarginsF.left": (),
-    "PySide2.QtCore.QMarginsF.right": (),
-    "PySide2.QtCore.QMarginsF.setBottom": ('float',),
-    "PySide2.QtCore.QMarginsF.setLeft": ('float',),
-    "PySide2.QtCore.QMarginsF.setRight": ('float',),
-    "PySide2.QtCore.QMarginsF.setTop": ('float',),
-    "PySide2.QtCore.QMarginsF.toMargins": (),
-    "PySide2.QtCore.QMarginsF.top": (),
-# class PySide2.QtCore.QMessageAuthenticationCode:
-    "PySide2.QtCore.QMessageAuthenticationCode.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMessageAuthenticationCode.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QMessageAuthenticationCode.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QMessageAuthenticationCode.reset": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.result": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.setKey": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QMessageLogContext:
-    "PySide2.QtCore.QMessageLogContext.__init__": [(), ('str', 'int', 'str', 'str')],
-# class PySide2.QtCore.QMetaClassInfo:
-    "PySide2.QtCore.QMetaClassInfo.__init__": [(), ('PySide2.QtCore.QMetaClassInfo',)],
-    "PySide2.QtCore.QMetaClassInfo.__copy__": (),
-    "PySide2.QtCore.QMetaClassInfo.name": (),
-    "PySide2.QtCore.QMetaClassInfo.value": (),
-# class PySide2.QtCore.QMetaEnum:
-    "PySide2.QtCore.QMetaEnum.__init__": [(), ('PySide2.QtCore.QMetaEnum',)],
-    "PySide2.QtCore.QMetaEnum.__copy__": (),
-    "PySide2.QtCore.QMetaEnum.enumName": (),
-    "PySide2.QtCore.QMetaEnum.isFlag": (),
-    "PySide2.QtCore.QMetaEnum.isScoped": (),
-    "PySide2.QtCore.QMetaEnum.isValid": (),
-    "PySide2.QtCore.QMetaEnum.key": ('int',),
-    "PySide2.QtCore.QMetaEnum.keyCount": (),
-    "PySide2.QtCore.QMetaEnum.keyToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.keysToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.name": (),
-    "PySide2.QtCore.QMetaEnum.scope": (),
-    "PySide2.QtCore.QMetaEnum.value": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKey": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKeys": ('int',),
-# class PySide2.QtCore.QMetaMethod:
-# class PySide2.QtCore.QMetaMethod.Access:
-# class PySide2.QtCore.QMetaMethod.MethodType:
-    "PySide2.QtCore.QMetaMethod.__init__": [(), ('PySide2.QtCore.QMetaMethod',)],
-    "PySide2.QtCore.QMetaMethod.__copy__": (),
-    "PySide2.QtCore.QMetaMethod.access": (),
-    "PySide2.QtCore.QMetaMethod.enclosingMetaObject": (),
-    "PySide2.QtCore.QMetaMethod.invoke": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.invokeOnGadget": [('int', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('int', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.isValid": (),
-    "PySide2.QtCore.QMetaMethod.methodIndex": (),
-    "PySide2.QtCore.QMetaMethod.methodSignature": (),
-    "PySide2.QtCore.QMetaMethod.methodType": (),
-    "PySide2.QtCore.QMetaMethod.name": (),
-    "PySide2.QtCore.QMetaMethod.parameterCount": (),
-    "PySide2.QtCore.QMetaMethod.parameterNames": (),
-    "PySide2.QtCore.QMetaMethod.parameterType": ('int',),
-    "PySide2.QtCore.QMetaMethod.parameterTypes": (),
-    "PySide2.QtCore.QMetaMethod.returnType": (),
-    "PySide2.QtCore.QMetaMethod.revision": (),
-    "PySide2.QtCore.QMetaMethod.tag": (),
-    "PySide2.QtCore.QMetaMethod.typeName": (),
-# class PySide2.QtCore.QMetaObject:
-# class PySide2.QtCore.QMetaObject.Call:
-# class PySide2.QtCore.QMetaObject.Connection:
-    "PySide2.QtCore.QMetaObject.Connection.__init__": [(), ('PySide2.QtCore.QMetaObject.Connection',)],
-    "PySide2.QtCore.QMetaObject.__init__": (),
-    "PySide2.QtCore.QMetaObject.cast": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.checkConnectArgs": [('PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QMetaMethod'), ('str', 'str')],
-    "PySide2.QtCore.QMetaObject.classInfo": ('int',),
-    "PySide2.QtCore.QMetaObject.classInfoCount": (),
-    "PySide2.QtCore.QMetaObject.classInfoOffset": (),
-    "PySide2.QtCore.QMetaObject.className": (),
-    "PySide2.QtCore.QMetaObject.connectSlotsByName": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.constructor": ('int',),
-    "PySide2.QtCore.QMetaObject.constructorCount": (),
-    "PySide2.QtCore.QMetaObject.disconnect": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.disconnectOne": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.enumerator": ('int',),
-    "PySide2.QtCore.QMetaObject.enumeratorCount": (),
-    "PySide2.QtCore.QMetaObject.enumeratorOffset": (),
-    "PySide2.QtCore.QMetaObject.indexOfClassInfo": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfConstructor": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfEnumerator": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfMethod": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfProperty": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSignal": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSlot": ('str',),
-    "PySide2.QtCore.QMetaObject.inherits": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtCore.QMetaObject.invokeMethod": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaObject.method": ('int',),
-    "PySide2.QtCore.QMetaObject.methodCount": (),
-    "PySide2.QtCore.QMetaObject.methodOffset": (),
-    "PySide2.QtCore.QMetaObject.newInstance": ('PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'),
-    "PySide2.QtCore.QMetaObject.normalizedSignature": ('str',),
-    "PySide2.QtCore.QMetaObject.normalizedType": ('str',),
-    "PySide2.QtCore.QMetaObject.property": ('int',),
-    "PySide2.QtCore.QMetaObject.propertyCount": (),
-    "PySide2.QtCore.QMetaObject.propertyOffset": (),
-    "PySide2.QtCore.QMetaObject.superClass": (),
-    "PySide2.QtCore.QMetaObject.userProperty": (),
-# class PySide2.QtCore.QMetaProperty:
-    "PySide2.QtCore.QMetaProperty.__init__": [(), ('PySide2.QtCore.QMetaProperty',)],
-    "PySide2.QtCore.QMetaProperty.__copy__": (),
-    "PySide2.QtCore.QMetaProperty.enumerator": (),
-    "PySide2.QtCore.QMetaProperty.hasNotifySignal": (),
-    "PySide2.QtCore.QMetaProperty.hasStdCppSet": (),
-    "PySide2.QtCore.QMetaProperty.isConstant": (),
-    "PySide2.QtCore.QMetaProperty.isDesignable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEditable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEnumType": (),
-    "PySide2.QtCore.QMetaProperty.isFinal": (),
-    "PySide2.QtCore.QMetaProperty.isFlagType": (),
-    "PySide2.QtCore.QMetaProperty.isReadable": (),
-    "PySide2.QtCore.QMetaProperty.isResettable": (),
-    "PySide2.QtCore.QMetaProperty.isScriptable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isStored": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isUser": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isValid": (),
-    "PySide2.QtCore.QMetaProperty.isWritable": (),
-    "PySide2.QtCore.QMetaProperty.name": (),
-    "PySide2.QtCore.QMetaProperty.notifySignal": (),
-    "PySide2.QtCore.QMetaProperty.notifySignalIndex": (),
-    "PySide2.QtCore.QMetaProperty.propertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.read": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.readOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.relativePropertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.reset": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.resetOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.revision": (),
-    "PySide2.QtCore.QMetaProperty.type": (),
-    "PySide2.QtCore.QMetaProperty.typeName": (),
-    "PySide2.QtCore.QMetaProperty.userType": (),
-    "PySide2.QtCore.QMetaProperty.write": ('PySide2.QtCore.QObject', 'typing.Any'),
-    "PySide2.QtCore.QMetaProperty.writeOnGadget": ('int', 'typing.Any'),
-# class PySide2.QtCore.QMimeData:
-    "PySide2.QtCore.QMimeData.__init__": (),
-    "PySide2.QtCore.QMimeData.clear": (),
-    "PySide2.QtCore.QMimeData.colorData": (),
-    "PySide2.QtCore.QMimeData.data": ('str',),
-    "PySide2.QtCore.QMimeData.formats": (),
-    "PySide2.QtCore.QMimeData.hasColor": (),
-    "PySide2.QtCore.QMimeData.hasFormat": ('str',),
-    "PySide2.QtCore.QMimeData.hasHtml": (),
-    "PySide2.QtCore.QMimeData.hasImage": (),
-    "PySide2.QtCore.QMimeData.hasText": (),
-    "PySide2.QtCore.QMimeData.hasUrls": (),
-    "PySide2.QtCore.QMimeData.html": (),
-    "PySide2.QtCore.QMimeData.imageData": (),
-    "PySide2.QtCore.QMimeData.removeFormat": ('str',),
-    "PySide2.QtCore.QMimeData.retrieveData": ('str', 'type'),
-    "PySide2.QtCore.QMimeData.setColorData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setData": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMimeData.setHtml": ('str',),
-    "PySide2.QtCore.QMimeData.setImageData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setText": ('str',),
-    "PySide2.QtCore.QMimeData.setUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtCore.QMimeData.text": (),
-    "PySide2.QtCore.QMimeData.urls": (),
-# class PySide2.QtCore.QMimeDatabase:
-# class PySide2.QtCore.QMimeDatabase.MatchMode:
-    "PySide2.QtCore.QMimeDatabase.__init__": (),
-    "PySide2.QtCore.QMimeDatabase.allMimeTypes": (),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFile": [('PySide2.QtCore.QFileInfo', 'PySide2.QtCore.QMimeDatabase.MatchMode'), ('str', 'PySide2.QtCore.QMimeDatabase.MatchMode')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFileNameAndData": [('str', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QIODevice')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypesForFileName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.suffixForFileName": ('str',),
-# class PySide2.QtCore.QMimeType:
-    "PySide2.QtCore.QMimeType.__init__": [(), ('PySide2.QtCore.QMimeType',)],
-    "PySide2.QtCore.QMimeType.__copy__": (),
-    "PySide2.QtCore.QMimeType.aliases": (),
-    "PySide2.QtCore.QMimeType.allAncestors": (),
-    "PySide2.QtCore.QMimeType.comment": (),
-    "PySide2.QtCore.QMimeType.filterString": (),
-    "PySide2.QtCore.QMimeType.genericIconName": (),
-    "PySide2.QtCore.QMimeType.globPatterns": (),
-    "PySide2.QtCore.QMimeType.iconName": (),
-    "PySide2.QtCore.QMimeType.inherits": ('str',),
-    "PySide2.QtCore.QMimeType.isDefault": (),
-    "PySide2.QtCore.QMimeType.isValid": (),
-    "PySide2.QtCore.QMimeType.name": (),
-    "PySide2.QtCore.QMimeType.parentMimeTypes": (),
-    "PySide2.QtCore.QMimeType.preferredSuffix": (),
-    "PySide2.QtCore.QMimeType.suffixes": (),
-    "PySide2.QtCore.QMimeType.swap": ('PySide2.QtCore.QMimeType',),
-# class PySide2.QtCore.QModelIndex:
-    "PySide2.QtCore.QModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QModelIndex.__copy__": (),
-    "PySide2.QtCore.QModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.column": (),
-    "PySide2.QtCore.QModelIndex.data": ('int',),
-    "PySide2.QtCore.QModelIndex.flags": (),
-    "PySide2.QtCore.QModelIndex.internalId": (),
-    "PySide2.QtCore.QModelIndex.internalPointer": (),
-    "PySide2.QtCore.QModelIndex.isValid": (),
-    "PySide2.QtCore.QModelIndex.model": (),
-    "PySide2.QtCore.QModelIndex.parent": (),
-    "PySide2.QtCore.QModelIndex.row": (),
-    "PySide2.QtCore.QModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.siblingAtColumn": ('int',),
-    "PySide2.QtCore.QModelIndex.siblingAtRow": ('int',),
-# class PySide2.QtCore.QMutex:
-# class PySide2.QtCore.QMutex.RecursionMode:
-    "PySide2.QtCore.QMutex.__init__": [(), ('PySide2.QtCore.QMutex.RecursionMode',)],
-    "PySide2.QtCore.QMutex.isRecursive": (),
-    "PySide2.QtCore.QMutex.lock": (),
-    "PySide2.QtCore.QMutex.tryLock": [(), ('int',)],
-    "PySide2.QtCore.QMutex.try_lock": (),
-    "PySide2.QtCore.QMutex.unlock": (),
-# class PySide2.QtCore.QMutexLocker:
-    "PySide2.QtCore.QMutexLocker.__init__": [('PySide2.QtCore.QBasicMutex',), ('PySide2.QtCore.QRecursiveMutex',)],
-    "PySide2.QtCore.QMutexLocker.__enter__": (),
-    "PySide2.QtCore.QMutexLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QMutexLocker.mutex": (),
-    "PySide2.QtCore.QMutexLocker.relock": (),
-    "PySide2.QtCore.QMutexLocker.unlock": (),
-# class PySide2.QtCore.QObject:
-    "PySide2.QtCore.QObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.blockSignals": ('bool',),
-    "PySide2.QtCore.QObject.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtCore.QObject.children": (),
-    "PySide2.QtCore.QObject.connect": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType')],
-    "PySide2.QtCore.QObject.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.customEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.deleteLater": (),
-    "PySide2.QtCore.QObject.disconnect": [('PySide2.QtCore.QMetaObject.Connection',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable'), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'typing.Callable')],
-    "PySide2.QtCore.QObject.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.dumpObjectInfo": (),
-    "PySide2.QtCore.QObject.dumpObjectTree": (),
-    "PySide2.QtCore.QObject.dynamicPropertyNames": (),
-    "PySide2.QtCore.QObject.emit": ('str', 'None'),
-    "PySide2.QtCore.QObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QObject.findChild": ('type', 'str'),
-    "PySide2.QtCore.QObject.findChildren": [('type', 'PySide2.QtCore.QRegExp'), ('type', 'str')],
-    "PySide2.QtCore.QObject.inherits": ('str',),
-    "PySide2.QtCore.QObject.installEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.isSignalConnected": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.isWidgetType": (),
-    "PySide2.QtCore.QObject.isWindowType": (),
-    "PySide2.QtCore.QObject.killTimer": ('int',),
-    "PySide2.QtCore.QObject.metaObject": (),
-    "PySide2.QtCore.QObject.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QObject.objectName": (),
-    "PySide2.QtCore.QObject.parent": (),
-    "PySide2.QtCore.QObject.property": ('str',),
-    "PySide2.QtCore.QObject.receivers": ('str',),
-    "PySide2.QtCore.QObject.registerUserData": (),
-    "PySide2.QtCore.QObject.removeEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.sender": (),
-    "PySide2.QtCore.QObject.senderSignalIndex": (),
-    "PySide2.QtCore.QObject.setObjectName": ('str',),
-    "PySide2.QtCore.QObject.setParent": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtCore.QObject.signalsBlocked": (),
-    "PySide2.QtCore.QObject.startTimer": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QObject.thread": (),
-    "PySide2.QtCore.QObject.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QObject.tr": ('str', 'str', 'int'),
-# class PySide2.QtCore.QOperatingSystemVersion:
-# class PySide2.QtCore.QOperatingSystemVersion.OSType:
-    "PySide2.QtCore.QOperatingSystemVersion.__init__": [('PySide2.QtCore.QOperatingSystemVersion',), ('PySide2.QtCore.QOperatingSystemVersion.OSType', 'int', 'int', 'int')],
-    "PySide2.QtCore.QOperatingSystemVersion.__copy__": (),
-    "PySide2.QtCore.QOperatingSystemVersion.current": (),
-    "PySide2.QtCore.QOperatingSystemVersion.currentType": (),
-    "PySide2.QtCore.QOperatingSystemVersion.majorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.microVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.minorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.name": (),
-    "PySide2.QtCore.QOperatingSystemVersion.segmentCount": (),
-    "PySide2.QtCore.QOperatingSystemVersion.type": (),
-# class PySide2.QtCore.QParallelAnimationGroup:
-    "PySide2.QtCore.QParallelAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QParallelAnimationGroup.duration": (),
-    "PySide2.QtCore.QParallelAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QPauseAnimation:
-    "PySide2.QtCore.QPauseAnimation.__init__": [('PySide2.QtCore.QObject',), ('int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPauseAnimation.duration": (),
-    "PySide2.QtCore.QPauseAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPauseAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QPauseAnimation.updateCurrentTime": ('int',),
-# class PySide2.QtCore.QPersistentModelIndex:
-    "PySide2.QtCore.QPersistentModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QPersistentModelIndex',)],
-    "PySide2.QtCore.QPersistentModelIndex.__copy__": (),
-    "PySide2.QtCore.QPersistentModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.column": (),
-    "PySide2.QtCore.QPersistentModelIndex.data": ('int',),
-    "PySide2.QtCore.QPersistentModelIndex.flags": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalId": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalPointer": (),
-    "PySide2.QtCore.QPersistentModelIndex.isValid": (),
-    "PySide2.QtCore.QPersistentModelIndex.model": (),
-    "PySide2.QtCore.QPersistentModelIndex.parent": (),
-    "PySide2.QtCore.QPersistentModelIndex.row": (),
-    "PySide2.QtCore.QPersistentModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.swap": ('PySide2.QtCore.QPersistentModelIndex',),
-# class PySide2.QtCore.QPluginLoader:
-    "PySide2.QtCore.QPluginLoader.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPluginLoader.errorString": (),
-    "PySide2.QtCore.QPluginLoader.fileName": (),
-    "PySide2.QtCore.QPluginLoader.instance": (),
-    "PySide2.QtCore.QPluginLoader.isLoaded": (),
-    "PySide2.QtCore.QPluginLoader.load": (),
-    "PySide2.QtCore.QPluginLoader.metaData": (),
-    "PySide2.QtCore.QPluginLoader.setFileName": ('str',),
-    "PySide2.QtCore.QPluginLoader.staticInstances": (),
-    "PySide2.QtCore.QPluginLoader.unload": (),
-# class PySide2.QtCore.QPoint:
-    "PySide2.QtCore.QPoint.__init__": [(), ('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QPoint.__add__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__copy__": (),
-    "PySide2.QtCore.QPoint.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__isub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__neg__": (),
-    "PySide2.QtCore.QPoint.__pos__": (),
-    "PySide2.QtCore.QPoint.__reduce__": (),
-    "PySide2.QtCore.QPoint.__repr__": (),
-    "PySide2.QtCore.QPoint.__sub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.dotProduct": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QPoint.isNull": (),
-    "PySide2.QtCore.QPoint.manhattanLength": (),
-    "PySide2.QtCore.QPoint.setX": ('int',),
-    "PySide2.QtCore.QPoint.setY": ('int',),
-    "PySide2.QtCore.QPoint.toTuple": (),
-    "PySide2.QtCore.QPoint.transposed": (),
-    "PySide2.QtCore.QPoint.x": (),
-    "PySide2.QtCore.QPoint.y": (),
-# class PySide2.QtCore.QPointF:
-    "PySide2.QtCore.QPointF.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QPointF.__add__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__copy__": (),
-    "PySide2.QtCore.QPointF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__imul__": ('float',),
-    "PySide2.QtCore.QPointF.__isub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__mul__": ('float',),
-    "PySide2.QtCore.QPointF.__neg__": (),
-    "PySide2.QtCore.QPointF.__pos__": (),
-    "PySide2.QtCore.QPointF.__reduce__": (),
-    "PySide2.QtCore.QPointF.__repr__": (),
-    "PySide2.QtCore.QPointF.__sub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.dotProduct": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QPointF.isNull": (),
-    "PySide2.QtCore.QPointF.manhattanLength": (),
-    "PySide2.QtCore.QPointF.setX": ('float',),
-    "PySide2.QtCore.QPointF.setY": ('float',),
-    "PySide2.QtCore.QPointF.toPoint": (),
-    "PySide2.QtCore.QPointF.toTuple": (),
-    "PySide2.QtCore.QPointF.transposed": (),
-    "PySide2.QtCore.QPointF.x": (),
-    "PySide2.QtCore.QPointF.y": (),
-# class PySide2.QtCore.QProcess:
-# class PySide2.QtCore.QProcess.ExitStatus:
-# class PySide2.QtCore.QProcess.InputChannelMode:
-# class PySide2.QtCore.QProcess.ProcessChannel:
-# class PySide2.QtCore.QProcess.ProcessChannelMode:
-# class PySide2.QtCore.QProcess.ProcessError:
-# class PySide2.QtCore.QProcess.ProcessState:
-    "PySide2.QtCore.QProcess.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QProcess.arguments": (),
-    "PySide2.QtCore.QProcess.atEnd": (),
-    "PySide2.QtCore.QProcess.bytesAvailable": (),
-    "PySide2.QtCore.QProcess.bytesToWrite": (),
-    "PySide2.QtCore.QProcess.canReadLine": (),
-    "PySide2.QtCore.QProcess.close": (),
-    "PySide2.QtCore.QProcess.closeReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.closeWriteChannel": (),
-    "PySide2.QtCore.QProcess.environment": (),
-    "PySide2.QtCore.QProcess.error": (),
-    "PySide2.QtCore.QProcess.execute": [('str',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtCore.QProcess.exitCode": (),
-    "PySide2.QtCore.QProcess.exitStatus": (),
-    "PySide2.QtCore.QProcess.inputChannelMode": (),
-    "PySide2.QtCore.QProcess.isSequential": (),
-    "PySide2.QtCore.QProcess.kill": (),
-    "PySide2.QtCore.QProcess.nullDevice": (),
-    "PySide2.QtCore.QProcess.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QProcess.pid": (),
-    "PySide2.QtCore.QProcess.processChannelMode": (),
-    "PySide2.QtCore.QProcess.processEnvironment": (),
-    "PySide2.QtCore.QProcess.processId": (),
-    "PySide2.QtCore.QProcess.program": (),
-    "PySide2.QtCore.QProcess.readAllStandardError": (),
-    "PySide2.QtCore.QProcess.readAllStandardOutput": (),
-    "PySide2.QtCore.QProcess.readChannel": (),
-    "PySide2.QtCore.QProcess.readData": ('str', 'int'),
-    "PySide2.QtCore.QProcess.setArguments": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setEnvironment": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setInputChannelMode": ('PySide2.QtCore.QProcess.InputChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessChannelMode": ('PySide2.QtCore.QProcess.ProcessChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessEnvironment": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcess.setProcessState": ('PySide2.QtCore.QProcess.ProcessState',),
-    "PySide2.QtCore.QProcess.setProgram": ('str',),
-    "PySide2.QtCore.QProcess.setReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.setStandardErrorFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardInputFile": ('str',),
-    "PySide2.QtCore.QProcess.setStandardOutputFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardOutputProcess": ('PySide2.QtCore.QProcess',),
-    "PySide2.QtCore.QProcess.setWorkingDirectory": ('str',),
-    "PySide2.QtCore.QProcess.setupChildProcess": (),
-    "PySide2.QtCore.QProcess.start": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtCore.QProcess.startDetached": [(), ('str',), ('str', 'typing.Sequence[str]'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QProcess.state": (),
-    "PySide2.QtCore.QProcess.systemEnvironment": (),
-    "PySide2.QtCore.QProcess.terminate": (),
-    "PySide2.QtCore.QProcess.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QProcess.waitForFinished": ('int',),
-    "PySide2.QtCore.QProcess.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QProcess.waitForStarted": ('int',),
-    "PySide2.QtCore.QProcess.workingDirectory": (),
-    "PySide2.QtCore.QProcess.writeData": ('str', 'int'),
-# class PySide2.QtCore.QProcessEnvironment:
-    "PySide2.QtCore.QProcessEnvironment.__init__": [(), ('PySide2.QtCore.QProcessEnvironment',)],
-    "PySide2.QtCore.QProcessEnvironment.__copy__": (),
-    "PySide2.QtCore.QProcessEnvironment.clear": (),
-    "PySide2.QtCore.QProcessEnvironment.contains": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.insert": [('PySide2.QtCore.QProcessEnvironment',), ('str', 'str')],
-    "PySide2.QtCore.QProcessEnvironment.isEmpty": (),
-    "PySide2.QtCore.QProcessEnvironment.keys": (),
-    "PySide2.QtCore.QProcessEnvironment.remove": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.swap": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcessEnvironment.systemEnvironment": (),
-    "PySide2.QtCore.QProcessEnvironment.toStringList": (),
-    "PySide2.QtCore.QProcessEnvironment.value": ('str', 'str'),
-# class PySide2.QtCore.QPropertyAnimation:
-    "PySide2.QtCore.QPropertyAnimation.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPropertyAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPropertyAnimation.propertyName": (),
-    "PySide2.QtCore.QPropertyAnimation.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QPropertyAnimation.setTargetObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QPropertyAnimation.targetObject": (),
-    "PySide2.QtCore.QPropertyAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QPropertyAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QRandomGenerator:
-    "PySide2.QtCore.QRandomGenerator.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.bounded": [('float',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator.generate": (),
-    "PySide2.QtCore.QRandomGenerator.generate64": (),
-    "PySide2.QtCore.QRandomGenerator.generateDouble": (),
-    "PySide2.QtCore.QRandomGenerator.global_": (),
-    "PySide2.QtCore.QRandomGenerator.max": (),
-    "PySide2.QtCore.QRandomGenerator.min": (),
-    "PySide2.QtCore.QRandomGenerator.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator.seed": ('int',),
-    "PySide2.QtCore.QRandomGenerator.system": (),
-# class PySide2.QtCore.QRandomGenerator64:
-    "PySide2.QtCore.QRandomGenerator64.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator64.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator64.generate": (),
-    "PySide2.QtCore.QRandomGenerator64.global_": (),
-    "PySide2.QtCore.QRandomGenerator64.max": (),
-    "PySide2.QtCore.QRandomGenerator64.min": (),
-    "PySide2.QtCore.QRandomGenerator64.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator64.system": (),
-# class PySide2.QtCore.QReadLocker:
-    "PySide2.QtCore.QReadLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QReadLocker.__enter__": (),
-    "PySide2.QtCore.QReadLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QReadLocker.readWriteLock": (),
-    "PySide2.QtCore.QReadLocker.relock": (),
-    "PySide2.QtCore.QReadLocker.unlock": (),
-# class PySide2.QtCore.QReadWriteLock:
-# class PySide2.QtCore.QReadWriteLock.RecursionMode:
-    "PySide2.QtCore.QReadWriteLock.__init__": ('PySide2.QtCore.QReadWriteLock.RecursionMode',),
-    "PySide2.QtCore.QReadWriteLock.lockForRead": (),
-    "PySide2.QtCore.QReadWriteLock.lockForWrite": (),
-    "PySide2.QtCore.QReadWriteLock.tryLockForRead": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.tryLockForWrite": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.unlock": (),
-# class PySide2.QtCore.QRect:
-    "PySide2.QtCore.QRect.__init__": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QSize'), ('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QRect.__add__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__and__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__copy__": (),
-    "PySide2.QtCore.QRect.__iadd__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__iand__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__ior__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__isub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__or__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__reduce__": (),
-    "PySide2.QtCore.QRect.__repr__": (),
-    "PySide2.QtCore.QRect.__sub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.adjust": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.adjusted": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.bottom": (),
-    "PySide2.QtCore.QRect.bottomLeft": (),
-    "PySide2.QtCore.QRect.bottomRight": (),
-    "PySide2.QtCore.QRect.center": (),
-    "PySide2.QtCore.QRect.contains": [('PySide2.QtCore.QPoint', 'bool'), ('PySide2.QtCore.QRect', 'bool'), ('int', 'int'), ('int', 'int', 'bool')],
-    "PySide2.QtCore.QRect.getCoords": (),
-    "PySide2.QtCore.QRect.getRect": (),
-    "PySide2.QtCore.QRect.height": (),
-    "PySide2.QtCore.QRect.intersected": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.intersects": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.isEmpty": (),
-    "PySide2.QtCore.QRect.isNull": (),
-    "PySide2.QtCore.QRect.isValid": (),
-    "PySide2.QtCore.QRect.left": (),
-    "PySide2.QtCore.QRect.marginsAdded": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.marginsRemoved": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.moveBottom": ('int',),
-    "PySide2.QtCore.QRect.moveBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveCenter": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveLeft": ('int',),
-    "PySide2.QtCore.QRect.moveRight": ('int',),
-    "PySide2.QtCore.QRect.moveTo": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.moveTop": ('int',),
-    "PySide2.QtCore.QRect.moveTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.normalized": (),
-    "PySide2.QtCore.QRect.right": (),
-    "PySide2.QtCore.QRect.setBottom": ('int',),
-    "PySide2.QtCore.QRect.setBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setCoords": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setHeight": ('int',),
-    "PySide2.QtCore.QRect.setLeft": ('int',),
-    "PySide2.QtCore.QRect.setRect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setRight": ('int',),
-    "PySide2.QtCore.QRect.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QRect.setTop": ('int',),
-    "PySide2.QtCore.QRect.setTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setWidth": ('int',),
-    "PySide2.QtCore.QRect.setX": ('int',),
-    "PySide2.QtCore.QRect.setY": ('int',),
-    "PySide2.QtCore.QRect.size": (),
-    "PySide2.QtCore.QRect.top": (),
-    "PySide2.QtCore.QRect.topLeft": (),
-    "PySide2.QtCore.QRect.topRight": (),
-    "PySide2.QtCore.QRect.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.transposed": (),
-    "PySide2.QtCore.QRect.united": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.width": (),
-    "PySide2.QtCore.QRect.x": (),
-    "PySide2.QtCore.QRect.y": (),
-# class PySide2.QtCore.QRectF:
-    "PySide2.QtCore.QRectF.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QSizeF'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QRectF.__add__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__and__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__copy__": (),
-    "PySide2.QtCore.QRectF.__iadd__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__iand__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__ior__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__isub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__or__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__reduce__": (),
-    "PySide2.QtCore.QRectF.__repr__": (),
-    "PySide2.QtCore.QRectF.__sub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.adjust": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.adjusted": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.bottom": (),
-    "PySide2.QtCore.QRectF.bottomLeft": (),
-    "PySide2.QtCore.QRectF.bottomRight": (),
-    "PySide2.QtCore.QRectF.center": (),
-    "PySide2.QtCore.QRectF.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.getCoords": (),
-    "PySide2.QtCore.QRectF.getRect": (),
-    "PySide2.QtCore.QRectF.height": (),
-    "PySide2.QtCore.QRectF.intersected": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.intersects": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.isEmpty": (),
-    "PySide2.QtCore.QRectF.isNull": (),
-    "PySide2.QtCore.QRectF.isValid": (),
-    "PySide2.QtCore.QRectF.left": (),
-    "PySide2.QtCore.QRectF.marginsAdded": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.marginsRemoved": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.moveBottom": ('float',),
-    "PySide2.QtCore.QRectF.moveBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveCenter": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveLeft": ('float',),
-    "PySide2.QtCore.QRectF.moveRight": ('float',),
-    "PySide2.QtCore.QRectF.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.moveTop": ('float',),
-    "PySide2.QtCore.QRectF.moveTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.normalized": (),
-    "PySide2.QtCore.QRectF.right": (),
-    "PySide2.QtCore.QRectF.setBottom": ('float',),
-    "PySide2.QtCore.QRectF.setBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setCoords": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setHeight": ('float',),
-    "PySide2.QtCore.QRectF.setLeft": ('float',),
-    "PySide2.QtCore.QRectF.setRect": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setRight": ('float',),
-    "PySide2.QtCore.QRectF.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QRectF.setTop": ('float',),
-    "PySide2.QtCore.QRectF.setTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setWidth": ('float',),
-    "PySide2.QtCore.QRectF.setX": ('float',),
-    "PySide2.QtCore.QRectF.setY": ('float',),
-    "PySide2.QtCore.QRectF.size": (),
-    "PySide2.QtCore.QRectF.toAlignedRect": (),
-    "PySide2.QtCore.QRectF.toRect": (),
-    "PySide2.QtCore.QRectF.top": (),
-    "PySide2.QtCore.QRectF.topLeft": (),
-    "PySide2.QtCore.QRectF.topRight": (),
-    "PySide2.QtCore.QRectF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.transposed": (),
-    "PySide2.QtCore.QRectF.united": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.width": (),
-    "PySide2.QtCore.QRectF.x": (),
-    "PySide2.QtCore.QRectF.y": (),
-# class PySide2.QtCore.QRecursiveMutex:
-    "PySide2.QtCore.QRecursiveMutex.__init__": (),
-# class PySide2.QtCore.QRegExp:
-# class PySide2.QtCore.QRegExp.CaretMode:
-# class PySide2.QtCore.QRegExp.PatternSyntax:
-    "PySide2.QtCore.QRegExp.__init__": [(), ('PySide2.QtCore.QRegExp',), ('str', 'PySide2.QtCore.Qt.CaseSensitivity', 'PySide2.QtCore.QRegExp.PatternSyntax')],
-    "PySide2.QtCore.QRegExp.__copy__": (),
-    "PySide2.QtCore.QRegExp.__reduce__": (),
-    "PySide2.QtCore.QRegExp.__repr__": (),
-    "PySide2.QtCore.QRegExp.cap": ('int',),
-    "PySide2.QtCore.QRegExp.captureCount": (),
-    "PySide2.QtCore.QRegExp.capturedTexts": (),
-    "PySide2.QtCore.QRegExp.caseSensitivity": (),
-    "PySide2.QtCore.QRegExp.errorString": (),
-    "PySide2.QtCore.QRegExp.escape": ('str',),
-    "PySide2.QtCore.QRegExp.exactMatch": ('str',),
-    "PySide2.QtCore.QRegExp.indexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.isEmpty": (),
-    "PySide2.QtCore.QRegExp.isMinimal": (),
-    "PySide2.QtCore.QRegExp.isValid": (),
-    "PySide2.QtCore.QRegExp.lastIndexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.matchedLength": (),
-    "PySide2.QtCore.QRegExp.pattern": (),
-    "PySide2.QtCore.QRegExp.patternSyntax": (),
-    "PySide2.QtCore.QRegExp.pos": ('int',),
-    "PySide2.QtCore.QRegExp.replace": ('str', 'str'),
-    "PySide2.QtCore.QRegExp.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QRegExp.setMinimal": ('bool',),
-    "PySide2.QtCore.QRegExp.setPattern": ('str',),
-    "PySide2.QtCore.QRegExp.setPatternSyntax": ('PySide2.QtCore.QRegExp.PatternSyntax',),
-    "PySide2.QtCore.QRegExp.swap": ('PySide2.QtCore.QRegExp',),
-# class PySide2.QtCore.QRegularExpression:
-# class PySide2.QtCore.QRegularExpression.MatchOption:
-# class PySide2.QtCore.QRegularExpression.MatchOptions:
-# class PySide2.QtCore.QRegularExpression.MatchType:
-# class PySide2.QtCore.QRegularExpression.PatternOption:
-# class PySide2.QtCore.QRegularExpression.PatternOptions:
-    "PySide2.QtCore.QRegularExpression.__init__": [(), ('PySide2.QtCore.QRegularExpression',), ('str', 'PySide2.QtCore.QRegularExpression.PatternOptions')],
-    "PySide2.QtCore.QRegularExpression.__copy__": (),
-    "PySide2.QtCore.QRegularExpression.anchoredPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.captureCount": (),
-    "PySide2.QtCore.QRegularExpression.errorString": (),
-    "PySide2.QtCore.QRegularExpression.escape": ('str',),
-    "PySide2.QtCore.QRegularExpression.globalMatch": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.isValid": (),
-    "PySide2.QtCore.QRegularExpression.match": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.namedCaptureGroups": (),
-    "PySide2.QtCore.QRegularExpression.optimize": (),
-    "PySide2.QtCore.QRegularExpression.pattern": (),
-    "PySide2.QtCore.QRegularExpression.patternErrorOffset": (),
-    "PySide2.QtCore.QRegularExpression.patternOptions": (),
-    "PySide2.QtCore.QRegularExpression.setPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.setPatternOptions": ('PySide2.QtCore.QRegularExpression.PatternOptions',),
-    "PySide2.QtCore.QRegularExpression.swap": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QRegularExpression.wildcardToRegularExpression": ('str',),
-# class PySide2.QtCore.QRegularExpressionMatch:
-    "PySide2.QtCore.QRegularExpressionMatch.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatch',)],
-    "PySide2.QtCore.QRegularExpressionMatch.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatch.captured": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedEnd": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedLength": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedRef": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedStart": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedTexts": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasPartialMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatch.lastCapturedIndex": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatch.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatch.swap": ('PySide2.QtCore.QRegularExpressionMatch',),
-# class PySide2.QtCore.QRegularExpressionMatchIterator:
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatchIterator',)],
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.hasNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.peekNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.swap": ('PySide2.QtCore.QRegularExpressionMatchIterator',),
-# class PySide2.QtCore.QResource:
-# class PySide2.QtCore.QResource.Compression:
-    "PySide2.QtCore.QResource.__init__": ('str', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtCore.QResource.absoluteFilePath": (),
-    "PySide2.QtCore.QResource.addSearchPath": ('str',),
-    "PySide2.QtCore.QResource.children": (),
-    "PySide2.QtCore.QResource.compressionAlgorithm": (),
-    "PySide2.QtCore.QResource.data": (),
-    "PySide2.QtCore.QResource.fileName": (),
-    "PySide2.QtCore.QResource.isCompressed": (),
-    "PySide2.QtCore.QResource.isDir": (),
-    "PySide2.QtCore.QResource.isFile": (),
-    "PySide2.QtCore.QResource.isValid": (),
-    "PySide2.QtCore.QResource.lastModified": (),
-    "PySide2.QtCore.QResource.locale": (),
-    "PySide2.QtCore.QResource.registerResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.registerResourceData": ('str', 'str'),
-    "PySide2.QtCore.QResource.searchPaths": (),
-    "PySide2.QtCore.QResource.setFileName": ('str',),
-    "PySide2.QtCore.QResource.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QResource.size": (),
-    "PySide2.QtCore.QResource.unregisterResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.unregisterResourceData": ('str', 'str'),
-# class PySide2.QtCore.QRunnable:
-    "PySide2.QtCore.QRunnable.__init__": (),
-    "PySide2.QtCore.QRunnable.autoDelete": (),
-    "PySide2.QtCore.QRunnable.run": (),
-    "PySide2.QtCore.QRunnable.setAutoDelete": ('bool',),
-# class PySide2.QtCore.QSaveFile:
-    "PySide2.QtCore.QSaveFile.__init__": [('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSaveFile.cancelWriting": (),
-    "PySide2.QtCore.QSaveFile.close": (),
-    "PySide2.QtCore.QSaveFile.commit": (),
-    "PySide2.QtCore.QSaveFile.directWriteFallback": (),
-    "PySide2.QtCore.QSaveFile.fileName": (),
-    "PySide2.QtCore.QSaveFile.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QSaveFile.setDirectWriteFallback": ('bool',),
-    "PySide2.QtCore.QSaveFile.setFileName": ('str',),
-    "PySide2.QtCore.QSaveFile.writeData": ('str', 'int'),
-# class PySide2.QtCore.QSemaphore:
-    "PySide2.QtCore.QSemaphore.__init__": ('int',),
-    "PySide2.QtCore.QSemaphore.acquire": ('int',),
-    "PySide2.QtCore.QSemaphore.available": (),
-    "PySide2.QtCore.QSemaphore.release": ('int',),
-    "PySide2.QtCore.QSemaphore.tryAcquire": [('int',), ('int', 'int')],
-# class PySide2.QtCore.QSemaphoreReleaser:
-    "PySide2.QtCore.QSemaphoreReleaser.__init__": [(), ('PySide2.QtCore.QSemaphore', 'int')],
-    "PySide2.QtCore.QSemaphoreReleaser.cancel": (),
-    "PySide2.QtCore.QSemaphoreReleaser.semaphore": (),
-    "PySide2.QtCore.QSemaphoreReleaser.swap": ('PySide2.QtCore.QSemaphoreReleaser',),
-# class PySide2.QtCore.QSequentialAnimationGroup:
-    "PySide2.QtCore.QSequentialAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSequentialAnimationGroup.addPause": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.currentAnimation": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.duration": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSequentialAnimationGroup.insertPause": ('int', 'int'),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QSettings:
-# class PySide2.QtCore.QSettings.Format:
-# class PySide2.QtCore.QSettings.Scope:
-# class PySide2.QtCore.QSettings.Status:
-    "PySide2.QtCore.QSettings.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QObject'), ('str', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSettings.allKeys": (),
-    "PySide2.QtCore.QSettings.applicationName": (),
-    "PySide2.QtCore.QSettings.beginGroup": ('str',),
-    "PySide2.QtCore.QSettings.beginReadArray": ('str',),
-    "PySide2.QtCore.QSettings.beginWriteArray": ('str', 'int'),
-    "PySide2.QtCore.QSettings.childGroups": (),
-    "PySide2.QtCore.QSettings.childKeys": (),
-    "PySide2.QtCore.QSettings.clear": (),
-    "PySide2.QtCore.QSettings.contains": ('str',),
-    "PySide2.QtCore.QSettings.defaultFormat": (),
-    "PySide2.QtCore.QSettings.endArray": (),
-    "PySide2.QtCore.QSettings.endGroup": (),
-    "PySide2.QtCore.QSettings.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSettings.fallbacksEnabled": (),
-    "PySide2.QtCore.QSettings.fileName": (),
-    "PySide2.QtCore.QSettings.format": (),
-    "PySide2.QtCore.QSettings.group": (),
-    "PySide2.QtCore.QSettings.iniCodec": (),
-    "PySide2.QtCore.QSettings.isAtomicSyncRequired": (),
-    "PySide2.QtCore.QSettings.isWritable": (),
-    "PySide2.QtCore.QSettings.organizationName": (),
-    "PySide2.QtCore.QSettings.remove": ('str',),
-    "PySide2.QtCore.QSettings.scope": (),
-    "PySide2.QtCore.QSettings.setArrayIndex": ('int',),
-    "PySide2.QtCore.QSettings.setAtomicSyncRequired": ('bool',),
-    "PySide2.QtCore.QSettings.setDefaultFormat": ('PySide2.QtCore.QSettings.Format',),
-    "PySide2.QtCore.QSettings.setFallbacksEnabled": ('bool',),
-    "PySide2.QtCore.QSettings.setIniCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QSettings.setPath": ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str'),
-    "PySide2.QtCore.QSettings.setValue": ('str', 'typing.Any'),
-    "PySide2.QtCore.QSettings.status": (),
-    "PySide2.QtCore.QSettings.sync": (),
-    "PySide2.QtCore.QSettings.value": ('str', 'typing.Any', 'object'),
-# class PySide2.QtCore.QSignalBlocker:
-    "PySide2.QtCore.QSignalBlocker.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalBlocker.reblock": (),
-    "PySide2.QtCore.QSignalBlocker.unblock": (),
-# class PySide2.QtCore.QSignalMapper:
-    "PySide2.QtCore.QSignalMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.map": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QSignalMapper.mapping": [('PySide2.QtCore.QObject',), ('int',), ('str',)],
-    "PySide2.QtCore.QSignalMapper.removeMappings": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.setMapping": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-# class PySide2.QtCore.QSignalTransition:
-    "PySide2.QtCore.QSignalTransition.__init__": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',), ('object', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QSignalTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.senderObject": (),
-    "PySide2.QtCore.QSignalTransition.setSenderObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalTransition.setSignal": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QSignalTransition.signal": (),
-# class PySide2.QtCore.QSize:
-    "PySide2.QtCore.QSize.__init__": [(), ('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtCore.QSize.__add__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__copy__": (),
-    "PySide2.QtCore.QSize.__iadd__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__imul__": ('float',),
-    "PySide2.QtCore.QSize.__isub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__mul__": ('float',),
-    "PySide2.QtCore.QSize.__reduce__": (),
-    "PySide2.QtCore.QSize.__repr__": (),
-    "PySide2.QtCore.QSize.__sub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.boundedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.expandedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.grownBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.height": (),
-    "PySide2.QtCore.QSize.isEmpty": (),
-    "PySide2.QtCore.QSize.isNull": (),
-    "PySide2.QtCore.QSize.isValid": (),
-    "PySide2.QtCore.QSize.scale": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.setHeight": ('int',),
-    "PySide2.QtCore.QSize.setWidth": ('int',),
-    "PySide2.QtCore.QSize.shrunkBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.toTuple": (),
-    "PySide2.QtCore.QSize.transpose": (),
-    "PySide2.QtCore.QSize.transposed": (),
-    "PySide2.QtCore.QSize.width": (),
-# class PySide2.QtCore.QSizeF:
-    "PySide2.QtCore.QSizeF.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtCore.QSizeF.__add__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__copy__": (),
-    "PySide2.QtCore.QSizeF.__iadd__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__imul__": ('float',),
-    "PySide2.QtCore.QSizeF.__isub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__mul__": ('float',),
-    "PySide2.QtCore.QSizeF.__reduce__": (),
-    "PySide2.QtCore.QSizeF.__repr__": (),
-    "PySide2.QtCore.QSizeF.__sub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.boundedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.expandedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.grownBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.height": (),
-    "PySide2.QtCore.QSizeF.isEmpty": (),
-    "PySide2.QtCore.QSizeF.isNull": (),
-    "PySide2.QtCore.QSizeF.isValid": (),
-    "PySide2.QtCore.QSizeF.scale": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.scaled": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.setHeight": ('float',),
-    "PySide2.QtCore.QSizeF.setWidth": ('float',),
-    "PySide2.QtCore.QSizeF.shrunkBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.toSize": (),
-    "PySide2.QtCore.QSizeF.toTuple": (),
-    "PySide2.QtCore.QSizeF.transpose": (),
-    "PySide2.QtCore.QSizeF.transposed": (),
-    "PySide2.QtCore.QSizeF.width": (),
-# class PySide2.QtCore.QSocketNotifier:
-# class PySide2.QtCore.QSocketNotifier.Type:
-    "PySide2.QtCore.QSocketNotifier.__init__": [('int', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject'), ('object', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSocketNotifier.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSocketNotifier.isEnabled": (),
-    "PySide2.QtCore.QSocketNotifier.setEnabled": ('bool',),
-    "PySide2.QtCore.QSocketNotifier.socket": (),
-    "PySide2.QtCore.QSocketNotifier.type": (),
-# class PySide2.QtCore.QSortFilterProxyModel:
-    "PySide2.QtCore.QSortFilterProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSortFilterProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.dynamicSortFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterKeyColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegExp": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegularExpression": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidate": (),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidateFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isRecursiveFilteringEnabled": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isSortLocaleAware": (),
-    "PySide2.QtCore.QSortFilterProxyModel.lessThan": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QSortFilterProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QSortFilterProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setDynamicSortFilter": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterFixedString": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterKeyColumn": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegExp": [('PySide2.QtCore.QRegExp',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegularExpression": [('PySide2.QtCore.QRegularExpression',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterWildcard": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setRecursiveFilteringEnabled": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortLocaleAware": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QSortFilterProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QSortFilterProxyModel.sortCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortOrder": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QStandardPaths:
-# class PySide2.QtCore.QStandardPaths.LocateOption:
-# class PySide2.QtCore.QStandardPaths.LocateOptions:
-# class PySide2.QtCore.QStandardPaths.StandardLocation:
-    "PySide2.QtCore.QStandardPaths.displayName": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.enableTestMode": ('bool',),
-    "PySide2.QtCore.QStandardPaths.findExecutable": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QStandardPaths.isTestModeEnabled": (),
-    "PySide2.QtCore.QStandardPaths.locate": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.locateAll": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.setTestModeEnabled": ('bool',),
-    "PySide2.QtCore.QStandardPaths.standardLocations": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.writableLocation": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-# class PySide2.QtCore.QState:
-# class PySide2.QtCore.QState.ChildMode:
-# class PySide2.QtCore.QState.RestorePolicy:
-    "PySide2.QtCore.QState.__init__": [('PySide2.QtCore.QState',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QState.addTransition": [('PySide2.QtCore.QAbstractState',), ('PySide2.QtCore.QAbstractTransition',), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QAbstractState'), ('object', 'PySide2.QtCore.QAbstractState')],
-    "PySide2.QtCore.QState.assignProperty": ('PySide2.QtCore.QObject', 'str', 'typing.Any'),
-    "PySide2.QtCore.QState.childMode": (),
-    "PySide2.QtCore.QState.errorState": (),
-    "PySide2.QtCore.QState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.initialState": (),
-    "PySide2.QtCore.QState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.removeTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QState.setChildMode": ('PySide2.QtCore.QState.ChildMode',),
-    "PySide2.QtCore.QState.setErrorState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.setInitialState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.transitions": (),
-# class PySide2.QtCore.QStateMachine:
-# class PySide2.QtCore.QStateMachine.Error:
-# class PySide2.QtCore.QStateMachine.EventPriority:
-# class PySide2.QtCore.QStateMachine.SignalEvent:
-    "PySide2.QtCore.QStateMachine.SignalEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'typing.Sequence[typing.Any]'), ('PySide2.QtCore.QStateMachine.SignalEvent',)],
-    "PySide2.QtCore.QStateMachine.SignalEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.arguments": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.sender": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.signalIndex": (),
-# class PySide2.QtCore.QStateMachine.WrappedEvent:
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'), ('PySide2.QtCore.QStateMachine.WrappedEvent',)],
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.event": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.object": (),
-    "PySide2.QtCore.QStateMachine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStateMachine.addDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.addState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.beginMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.beginSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.cancelDelayedEvent": ('int',),
-    "PySide2.QtCore.QStateMachine.clearError": (),
-    "PySide2.QtCore.QStateMachine.configuration": (),
-    "PySide2.QtCore.QStateMachine.defaultAnimations": (),
-    "PySide2.QtCore.QStateMachine.endMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.endSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.error": (),
-    "PySide2.QtCore.QStateMachine.errorString": (),
-    "PySide2.QtCore.QStateMachine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QStateMachine.globalRestorePolicy": (),
-    "PySide2.QtCore.QStateMachine.isAnimated": (),
-    "PySide2.QtCore.QStateMachine.isRunning": (),
-    "PySide2.QtCore.QStateMachine.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.postDelayedEvent": ('PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QStateMachine.postEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QStateMachine.EventPriority'),
-    "PySide2.QtCore.QStateMachine.removeDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.removeState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.setAnimated": ('bool',),
-    "PySide2.QtCore.QStateMachine.setGlobalRestorePolicy": ('PySide2.QtCore.QState.RestorePolicy',),
-    "PySide2.QtCore.QStateMachine.setRunning": ('bool',),
-    "PySide2.QtCore.QStateMachine.start": (),
-    "PySide2.QtCore.QStateMachine.stop": (),
-# class PySide2.QtCore.QStorageInfo:
-    "PySide2.QtCore.QStorageInfo.__init__": [(), ('PySide2.QtCore.QDir',), ('PySide2.QtCore.QStorageInfo',), ('str',)],
-    "PySide2.QtCore.QStorageInfo.__copy__": (),
-    "PySide2.QtCore.QStorageInfo.blockSize": (),
-    "PySide2.QtCore.QStorageInfo.bytesAvailable": (),
-    "PySide2.QtCore.QStorageInfo.bytesFree": (),
-    "PySide2.QtCore.QStorageInfo.bytesTotal": (),
-    "PySide2.QtCore.QStorageInfo.device": (),
-    "PySide2.QtCore.QStorageInfo.displayName": (),
-    "PySide2.QtCore.QStorageInfo.fileSystemType": (),
-    "PySide2.QtCore.QStorageInfo.isReadOnly": (),
-    "PySide2.QtCore.QStorageInfo.isReady": (),
-    "PySide2.QtCore.QStorageInfo.isRoot": (),
-    "PySide2.QtCore.QStorageInfo.isValid": (),
-    "PySide2.QtCore.QStorageInfo.mountedVolumes": (),
-    "PySide2.QtCore.QStorageInfo.name": (),
-    "PySide2.QtCore.QStorageInfo.refresh": (),
-    "PySide2.QtCore.QStorageInfo.root": (),
-    "PySide2.QtCore.QStorageInfo.rootPath": (),
-    "PySide2.QtCore.QStorageInfo.setPath": ('str',),
-    "PySide2.QtCore.QStorageInfo.subvolume": (),
-    "PySide2.QtCore.QStorageInfo.swap": ('PySide2.QtCore.QStorageInfo',),
-# class PySide2.QtCore.QStringListModel:
-    "PySide2.QtCore.QStringListModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStringListModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QStringListModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QStringListModel.setStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QStringListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QStringListModel.stringList": (),
-    "PySide2.QtCore.QStringListModel.supportedDropActions": (),
-# class PySide2.QtCore.QSysInfo:
-# class PySide2.QtCore.QSysInfo.Endian:
-# class PySide2.QtCore.QSysInfo.MacVersion:
-# class PySide2.QtCore.QSysInfo.Sizes:
-    "PySide2.QtCore.QSysInfo.__init__": (),
-    "PySide2.QtCore.QSysInfo.bootUniqueId": (),
-    "PySide2.QtCore.QSysInfo.buildAbi": (),
-    "PySide2.QtCore.QSysInfo.buildCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.currentCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.kernelType": (),
-    "PySide2.QtCore.QSysInfo.kernelVersion": (),
-    "PySide2.QtCore.QSysInfo.macVersion": (),
-    "PySide2.QtCore.QSysInfo.machineHostName": (),
-    "PySide2.QtCore.QSysInfo.machineUniqueId": (),
-    "PySide2.QtCore.QSysInfo.prettyProductName": (),
-    "PySide2.QtCore.QSysInfo.productType": (),
-    "PySide2.QtCore.QSysInfo.productVersion": (),
-# class PySide2.QtCore.QSystemSemaphore:
-# class PySide2.QtCore.QSystemSemaphore.AccessMode:
-# class PySide2.QtCore.QSystemSemaphore.SystemSemaphoreError:
-    "PySide2.QtCore.QSystemSemaphore.__init__": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-    "PySide2.QtCore.QSystemSemaphore.acquire": (),
-    "PySide2.QtCore.QSystemSemaphore.error": (),
-    "PySide2.QtCore.QSystemSemaphore.errorString": (),
-    "PySide2.QtCore.QSystemSemaphore.key": (),
-    "PySide2.QtCore.QSystemSemaphore.release": ('int',),
-    "PySide2.QtCore.QSystemSemaphore.setKey": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-# class PySide2.QtCore.QTemporaryDir:
-    "PySide2.QtCore.QTemporaryDir.__init__": [(), ('str',)],
-    "PySide2.QtCore.QTemporaryDir.autoRemove": (),
-    "PySide2.QtCore.QTemporaryDir.errorString": (),
-    "PySide2.QtCore.QTemporaryDir.filePath": ('str',),
-    "PySide2.QtCore.QTemporaryDir.isValid": (),
-    "PySide2.QtCore.QTemporaryDir.path": (),
-    "PySide2.QtCore.QTemporaryDir.remove": (),
-    "PySide2.QtCore.QTemporaryDir.setAutoRemove": ('bool',),
-# class PySide2.QtCore.QTemporaryFile:
-    "PySide2.QtCore.QTemporaryFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QTemporaryFile.autoRemove": (),
-    "PySide2.QtCore.QTemporaryFile.createLocalFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.createNativeFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.fileName": (),
-    "PySide2.QtCore.QTemporaryFile.fileTemplate": (),
-    "PySide2.QtCore.QTemporaryFile.open": [(), ('PySide2.QtCore.QIODevice.OpenMode',)],
-    "PySide2.QtCore.QTemporaryFile.rename": ('str',),
-    "PySide2.QtCore.QTemporaryFile.setAutoRemove": ('bool',),
-    "PySide2.QtCore.QTemporaryFile.setFileTemplate": ('str',),
-# class PySide2.QtCore.QTextBoundaryFinder:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReason:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReasons:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryType:
-    "PySide2.QtCore.QTextBoundaryFinder.__init__": [(), ('PySide2.QtCore.QTextBoundaryFinder',), ('PySide2.QtCore.QTextBoundaryFinder.BoundaryType', 'str')],
-    "PySide2.QtCore.QTextBoundaryFinder.__copy__": (),
-    "PySide2.QtCore.QTextBoundaryFinder.boundaryReasons": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isAtBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isValid": (),
-    "PySide2.QtCore.QTextBoundaryFinder.position": (),
-    "PySide2.QtCore.QTextBoundaryFinder.setPosition": ('int',),
-    "PySide2.QtCore.QTextBoundaryFinder.string": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toEnd": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toNextBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toPreviousBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toStart": (),
-    "PySide2.QtCore.QTextBoundaryFinder.type": (),
-# class PySide2.QtCore.QTextCodec:
-# class PySide2.QtCore.QTextCodec.ConversionFlag:
-# class PySide2.QtCore.QTextCodec.ConversionFlags:
-# class PySide2.QtCore.QTextCodec.ConverterState:
-    "PySide2.QtCore.QTextCodec.ConverterState.__init__": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.__init__": (),
-    "PySide2.QtCore.QTextCodec.aliases": (),
-    "PySide2.QtCore.QTextCodec.availableCodecs": (),
-    "PySide2.QtCore.QTextCodec.availableMibs": (),
-    "PySide2.QtCore.QTextCodec.canEncode": ('str',),
-    "PySide2.QtCore.QTextCodec.codecForHtml": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.codecForLocale": (),
-    "PySide2.QtCore.QTextCodec.codecForMib": ('int',),
-    "PySide2.QtCore.QTextCodec.codecForName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QTextCodec.codecForUtfText": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.convertToUnicode": ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState'),
-    "PySide2.QtCore.QTextCodec.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextCodec.makeDecoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.makeEncoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.mibEnum": (),
-    "PySide2.QtCore.QTextCodec.name": (),
-    "PySide2.QtCore.QTextCodec.setCodecForLocale": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtCore.QTextCodec.toUnicode": [('PySide2.QtCore.QByteArray',), ('str',), ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState')],
-# class PySide2.QtCore.QTextDecoder:
-    "PySide2.QtCore.QTextDecoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextDecoder.hasFailure": (),
-    "PySide2.QtCore.QTextDecoder.needsMoreData": (),
-    "PySide2.QtCore.QTextDecoder.toUnicode": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QTextEncoder:
-    "PySide2.QtCore.QTextEncoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextEncoder.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextEncoder.hasFailure": (),
-# class PySide2.QtCore.QTextStream:
-# class PySide2.QtCore.QTextStream.FieldAlignment:
-# class PySide2.QtCore.QTextStream.NumberFlag:
-# class PySide2.QtCore.QTextStream.NumberFlags:
-# class PySide2.QtCore.QTextStream.RealNumberNotation:
-# class PySide2.QtCore.QTextStream.Status:
-    "PySide2.QtCore.QTextStream.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QTextStream.__lshift__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QTextStreamManipulator',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QTextStream.__rshift__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTextStream.atEnd": (),
-    "PySide2.QtCore.QTextStream.autoDetectUnicode": (),
-    "PySide2.QtCore.QTextStream.codec": (),
-    "PySide2.QtCore.QTextStream.device": (),
-    "PySide2.QtCore.QTextStream.fieldAlignment": (),
-    "PySide2.QtCore.QTextStream.fieldWidth": (),
-    "PySide2.QtCore.QTextStream.flush": (),
-    "PySide2.QtCore.QTextStream.generateByteOrderMark": (),
-    "PySide2.QtCore.QTextStream.integerBase": (),
-    "PySide2.QtCore.QTextStream.locale": (),
-    "PySide2.QtCore.QTextStream.numberFlags": (),
-    "PySide2.QtCore.QTextStream.padChar": (),
-    "PySide2.QtCore.QTextStream.pos": (),
-    "PySide2.QtCore.QTextStream.read": ('int',),
-    "PySide2.QtCore.QTextStream.readAll": (),
-    "PySide2.QtCore.QTextStream.readLine": ('int',),
-    "PySide2.QtCore.QTextStream.realNumberNotation": (),
-    "PySide2.QtCore.QTextStream.realNumberPrecision": (),
-    "PySide2.QtCore.QTextStream.reset": (),
-    "PySide2.QtCore.QTextStream.resetStatus": (),
-    "PySide2.QtCore.QTextStream.seek": ('int',),
-    "PySide2.QtCore.QTextStream.setAutoDetectUnicode": ('bool',),
-    "PySide2.QtCore.QTextStream.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QTextStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QTextStream.setFieldAlignment": ('PySide2.QtCore.QTextStream.FieldAlignment',),
-    "PySide2.QtCore.QTextStream.setFieldWidth": ('int',),
-    "PySide2.QtCore.QTextStream.setGenerateByteOrderMark": ('bool',),
-    "PySide2.QtCore.QTextStream.setIntegerBase": ('int',),
-    "PySide2.QtCore.QTextStream.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QTextStream.setNumberFlags": ('PySide2.QtCore.QTextStream.NumberFlags',),
-    "PySide2.QtCore.QTextStream.setPadChar": ('str',),
-    "PySide2.QtCore.QTextStream.setRealNumberNotation": ('PySide2.QtCore.QTextStream.RealNumberNotation',),
-    "PySide2.QtCore.QTextStream.setRealNumberPrecision": ('int',),
-    "PySide2.QtCore.QTextStream.setStatus": ('PySide2.QtCore.QTextStream.Status',),
-    "PySide2.QtCore.QTextStream.skipWhiteSpace": (),
-    "PySide2.QtCore.QTextStream.status": (),
-    "PySide2.QtCore.QTextStream.string": (),
-# class PySide2.QtCore.QTextStreamManipulator:
-    "PySide2.QtCore.QTextStreamManipulator.__copy__": (),
-    "PySide2.QtCore.QTextStreamManipulator.exec_": ('PySide2.QtCore.QTextStream',),
-# class PySide2.QtCore.QThread:
-# class PySide2.QtCore.QThread.Priority:
-    "PySide2.QtCore.QThread.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThread.currentThread": (),
-    "PySide2.QtCore.QThread.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QThread.eventDispatcher": (),
-    "PySide2.QtCore.QThread.exec_": (),
-    "PySide2.QtCore.QThread.exit": ('int',),
-    "PySide2.QtCore.QThread.idealThreadCount": (),
-    "PySide2.QtCore.QThread.isFinished": (),
-    "PySide2.QtCore.QThread.isInterruptionRequested": (),
-    "PySide2.QtCore.QThread.isRunning": (),
-    "PySide2.QtCore.QThread.loopLevel": (),
-    "PySide2.QtCore.QThread.msleep": ('int',),
-    "PySide2.QtCore.QThread.priority": (),
-    "PySide2.QtCore.QThread.quit": (),
-    "PySide2.QtCore.QThread.requestInterruption": (),
-    "PySide2.QtCore.QThread.run": (),
-    "PySide2.QtCore.QThread.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QThread.setPriority": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.setStackSize": ('int',),
-    "PySide2.QtCore.QThread.setTerminationEnabled": ('bool',),
-    "PySide2.QtCore.QThread.sleep": ('int',),
-    "PySide2.QtCore.QThread.stackSize": (),
-    "PySide2.QtCore.QThread.start": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.terminate": (),
-    "PySide2.QtCore.QThread.usleep": ('int',),
-    "PySide2.QtCore.QThread.wait": ('int',),
-    "PySide2.QtCore.QThread.yieldCurrentThread": (),
-# class PySide2.QtCore.QThreadPool:
-    "PySide2.QtCore.QThreadPool.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThreadPool.activeThreadCount": (),
-    "PySide2.QtCore.QThreadPool.cancel": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.clear": (),
-    "PySide2.QtCore.QThreadPool.expiryTimeout": (),
-    "PySide2.QtCore.QThreadPool.globalInstance": (),
-    "PySide2.QtCore.QThreadPool.maxThreadCount": (),
-    "PySide2.QtCore.QThreadPool.releaseThread": (),
-    "PySide2.QtCore.QThreadPool.reserveThread": (),
-    "PySide2.QtCore.QThreadPool.setExpiryTimeout": ('int',),
-    "PySide2.QtCore.QThreadPool.setMaxThreadCount": ('int',),
-    "PySide2.QtCore.QThreadPool.setStackSize": ('int',),
-    "PySide2.QtCore.QThreadPool.stackSize": (),
-    "PySide2.QtCore.QThreadPool.start": ('PySide2.QtCore.QRunnable', 'int'),
-    "PySide2.QtCore.QThreadPool.tryStart": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.tryTake": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.waitForDone": ('int',),
-# class PySide2.QtCore.QTime:
-    "PySide2.QtCore.QTime.__init__": [(), ('PySide2.QtCore.QTime',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.__copy__": (),
-    "PySide2.QtCore.QTime.__reduce__": (),
-    "PySide2.QtCore.QTime.__repr__": (),
-    "PySide2.QtCore.QTime.addMSecs": ('int',),
-    "PySide2.QtCore.QTime.addSecs": ('int',),
-    "PySide2.QtCore.QTime.currentTime": (),
-    "PySide2.QtCore.QTime.elapsed": (),
-    "PySide2.QtCore.QTime.fromMSecsSinceStartOfDay": ('int',),
-    "PySide2.QtCore.QTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str')],
-    "PySide2.QtCore.QTime.hour": (),
-    "PySide2.QtCore.QTime.isNull": (),
-    "PySide2.QtCore.QTime.isValid": [(), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.minute": (),
-    "PySide2.QtCore.QTime.msec": (),
-    "PySide2.QtCore.QTime.msecsSinceStartOfDay": (),
-    "PySide2.QtCore.QTime.msecsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.restart": (),
-    "PySide2.QtCore.QTime.second": (),
-    "PySide2.QtCore.QTime.secsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.setHMS": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QTime.start": (),
-    "PySide2.QtCore.QTime.toPython": (),
-    "PySide2.QtCore.QTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-# class PySide2.QtCore.QTimeLine:
-# class PySide2.QtCore.QTimeLine.CurveShape:
-# class PySide2.QtCore.QTimeLine.Direction:
-# class PySide2.QtCore.QTimeLine.State:
-    "PySide2.QtCore.QTimeLine.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QTimeLine.currentFrame": (),
-    "PySide2.QtCore.QTimeLine.currentTime": (),
-    "PySide2.QtCore.QTimeLine.currentValue": (),
-    "PySide2.QtCore.QTimeLine.curveShape": (),
-    "PySide2.QtCore.QTimeLine.direction": (),
-    "PySide2.QtCore.QTimeLine.duration": (),
-    "PySide2.QtCore.QTimeLine.easingCurve": (),
-    "PySide2.QtCore.QTimeLine.endFrame": (),
-    "PySide2.QtCore.QTimeLine.frameForTime": ('int',),
-    "PySide2.QtCore.QTimeLine.loopCount": (),
-    "PySide2.QtCore.QTimeLine.resume": (),
-    "PySide2.QtCore.QTimeLine.setCurrentTime": ('int',),
-    "PySide2.QtCore.QTimeLine.setCurveShape": ('PySide2.QtCore.QTimeLine.CurveShape',),
-    "PySide2.QtCore.QTimeLine.setDirection": ('PySide2.QtCore.QTimeLine.Direction',),
-    "PySide2.QtCore.QTimeLine.setDuration": ('int',),
-    "PySide2.QtCore.QTimeLine.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QTimeLine.setEndFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setFrameRange": ('int', 'int'),
-    "PySide2.QtCore.QTimeLine.setLoopCount": ('int',),
-    "PySide2.QtCore.QTimeLine.setPaused": ('bool',),
-    "PySide2.QtCore.QTimeLine.setStartFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setUpdateInterval": ('int',),
-    "PySide2.QtCore.QTimeLine.start": (),
-    "PySide2.QtCore.QTimeLine.startFrame": (),
-    "PySide2.QtCore.QTimeLine.state": (),
-    "PySide2.QtCore.QTimeLine.stop": (),
-    "PySide2.QtCore.QTimeLine.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimeLine.toggleDirection": (),
-    "PySide2.QtCore.QTimeLine.updateInterval": (),
-    "PySide2.QtCore.QTimeLine.valueForTime": ('int',),
-# class PySide2.QtCore.QTimeZone:
-# class PySide2.QtCore.QTimeZone.NameType:
-# class PySide2.QtCore.QTimeZone.OffsetData:
-    "PySide2.QtCore.QTimeZone.OffsetData.__init__": [(), ('PySide2.QtCore.QTimeZone.OffsetData',)],
-    "PySide2.QtCore.QTimeZone.OffsetData.__copy__": (),
-# class PySide2.QtCore.QTimeZone.TimeType:
-    "PySide2.QtCore.QTimeZone.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'int', 'str', 'str', 'PySide2.QtCore.QLocale.Country', 'str'), ('PySide2.QtCore.QTimeZone',), ('int',)],
-    "PySide2.QtCore.QTimeZone.__copy__": (),
-    "PySide2.QtCore.QTimeZone.abbreviation": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.availableTimeZoneIds": [(), ('PySide2.QtCore.QLocale.Country',), ('int',)],
-    "PySide2.QtCore.QTimeZone.comment": (),
-    "PySide2.QtCore.QTimeZone.country": (),
-    "PySide2.QtCore.QTimeZone.daylightTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.displayName": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale'), ('PySide2.QtCore.QTimeZone.TimeType', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale')],
-    "PySide2.QtCore.QTimeZone.hasDaylightTime": (),
-    "PySide2.QtCore.QTimeZone.hasTransitions": (),
-    "PySide2.QtCore.QTimeZone.ianaIdToWindowsId": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.id": (),
-    "PySide2.QtCore.QTimeZone.isDaylightTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.isTimeZoneIdAvailable": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.isValid": (),
-    "PySide2.QtCore.QTimeZone.nextTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetData": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetFromUtc": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.previousTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.standardTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.swap": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QTimeZone.systemTimeZone": (),
-    "PySide2.QtCore.QTimeZone.systemTimeZoneId": (),
-    "PySide2.QtCore.QTimeZone.transitions": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtCore.QTimeZone.utc": (),
-    "PySide2.QtCore.QTimeZone.windowsIdToDefaultIanaId": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-    "PySide2.QtCore.QTimeZone.windowsIdToIanaIds": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-# class PySide2.QtCore.QTimer:
-    "PySide2.QtCore.QTimer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTimer.interval": (),
-    "PySide2.QtCore.QTimer.isActive": (),
-    "PySide2.QtCore.QTimer.isSingleShot": (),
-    "PySide2.QtCore.QTimer.killTimer": ('int',),
-    "PySide2.QtCore.QTimer.remainingTime": (),
-    "PySide2.QtCore.QTimer.setInterval": ('int',),
-    "PySide2.QtCore.QTimer.setSingleShot": ('bool',),
-    "PySide2.QtCore.QTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QTimer.singleShot": [('int', 'PySide2.QtCore.QObject', 'str'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject', 'str'), ('int', 'typing.Callable')],
-    "PySide2.QtCore.QTimer.start": [(), ('int',)],
-    "PySide2.QtCore.QTimer.stop": (),
-    "PySide2.QtCore.QTimer.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimer.timerId": (),
-    "PySide2.QtCore.QTimer.timerType": (),
-# class PySide2.QtCore.QTimerEvent:
-    "PySide2.QtCore.QTimerEvent.__init__": ('int',),
-    "PySide2.QtCore.QTimerEvent.timerId": (),
-# class PySide2.QtCore.QTranslator:
-    "PySide2.QtCore.QTranslator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTranslator.isEmpty": (),
-    "PySide2.QtCore.QTranslator.load": [('PySide2.QtCore.QLocale', 'str', 'str', 'str', 'str'), ('str', 'int', 'str'), ('str', 'str', 'str', 'str')],
-    "PySide2.QtCore.QTranslator.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QTransposeProxyModel:
-    "PySide2.QtCore.QTransposeProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTransposeProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QTransposeProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QTransposeProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QTransposeProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QTransposeProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QUrl:
-# class PySide2.QtCore.QUrl.ComponentFormattingOption:
-# class PySide2.QtCore.QUrl.FormattingOptions:
-# class PySide2.QtCore.QUrl.ParsingMode:
-# class PySide2.QtCore.QUrl.UrlFormattingOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOptions:
-    "PySide2.QtCore.QUrl.__init__": [(), ('PySide2.QtCore.QUrl',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.__copy__": (),
-    "PySide2.QtCore.QUrl.__reduce__": (),
-    "PySide2.QtCore.QUrl.__repr__": (),
-    "PySide2.QtCore.QUrl.adjusted": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.authority": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.clear": (),
-    "PySide2.QtCore.QUrl.errorString": (),
-    "PySide2.QtCore.QUrl.fileName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fragment": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fromAce": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromEncoded": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromLocalFile": ('str',),
-    "PySide2.QtCore.QUrl.fromPercentEncoding": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromStringList": ('typing.Sequence[str]', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromUserInput": [('str',), ('str', 'str', 'PySide2.QtCore.QUrl.UserInputResolutionOptions')],
-    "PySide2.QtCore.QUrl.hasFragment": (),
-    "PySide2.QtCore.QUrl.hasQuery": (),
-    "PySide2.QtCore.QUrl.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.idnWhitelist": (),
-    "PySide2.QtCore.QUrl.isEmpty": (),
-    "PySide2.QtCore.QUrl.isLocalFile": (),
-    "PySide2.QtCore.QUrl.isParentOf": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.isRelative": (),
-    "PySide2.QtCore.QUrl.isValid": (),
-    "PySide2.QtCore.QUrl.matches": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.password": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.path": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.port": ('int',),
-    "PySide2.QtCore.QUrl.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.resolved": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.scheme": (),
-    "PySide2.QtCore.QUrl.setAuthority": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setFragment": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setIdnWhitelist": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QUrl.setPassword": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPath": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPort": ('int',),
-    "PySide2.QtCore.QUrl.setQuery": [('PySide2.QtCore.QUrlQuery',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.setScheme": ('str',),
-    "PySide2.QtCore.QUrl.setUrl": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserInfo": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserName": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.swap": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.toAce": ('str',),
-    "PySide2.QtCore.QUrl.toDisplayString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toEncoded": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toLocalFile": (),
-    "PySide2.QtCore.QUrl.toPercentEncoding": ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QUrl.toString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toStringList": ('typing.Sequence[PySide2.QtCore.QUrl]', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.topLevelDomain": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.url": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.userInfo": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.userName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUrlQuery:
-    "PySide2.QtCore.QUrlQuery.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrlQuery',), ('str',)],
-    "PySide2.QtCore.QUrlQuery.__copy__": (),
-    "PySide2.QtCore.QUrlQuery.addQueryItem": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.allQueryItemValues": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.clear": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.hasQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.isEmpty": (),
-    "PySide2.QtCore.QUrlQuery.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryItemValue": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.queryItems": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.queryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.removeAllQueryItems": ('str',),
-    "PySide2.QtCore.QUrlQuery.removeQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQuery": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQueryDelimiters": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.setQueryItems": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtCore.QUrlQuery.swap": ('PySide2.QtCore.QUrlQuery',),
-    "PySide2.QtCore.QUrlQuery.toString": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUuid:
-# class PySide2.QtCore.QUuid.StringFormat:
-# class PySide2.QtCore.QUuid.Variant:
-# class PySide2.QtCore.QUuid.Version:
-    "PySide2.QtCore.QUuid.__init__": [(), ('PySide2.QtCore.QByteArray',), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'), ('str',)],
-    "PySide2.QtCore.QUuid.__copy__": (),
-    "PySide2.QtCore.QUuid.__reduce__": (),
-    "PySide2.QtCore.QUuid.__repr__": (),
-    "PySide2.QtCore.QUuid.createUuid": (),
-    "PySide2.QtCore.QUuid.createUuidV3": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.createUuidV5": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.fromRfc4122": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUuid.isNull": (),
-    "PySide2.QtCore.QUuid.toByteArray": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.toRfc4122": (),
-    "PySide2.QtCore.QUuid.toString": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.variant": (),
-    "PySide2.QtCore.QUuid.version": (),
-# class PySide2.QtCore.QVariantAnimation:
-    "PySide2.QtCore.QVariantAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QVariantAnimation.currentValue": (),
-    "PySide2.QtCore.QVariantAnimation.duration": (),
-    "PySide2.QtCore.QVariantAnimation.easingCurve": (),
-    "PySide2.QtCore.QVariantAnimation.endValue": (),
-    "PySide2.QtCore.QVariantAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QVariantAnimation.interpolated": ('typing.Any', 'typing.Any', 'float'),
-    "PySide2.QtCore.QVariantAnimation.keyValueAt": ('float',),
-    "PySide2.QtCore.QVariantAnimation.keyValues": (),
-    "PySide2.QtCore.QVariantAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QVariantAnimation.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QVariantAnimation.setEndValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.setKeyValueAt": ('float', 'typing.Any'),
-    "PySide2.QtCore.QVariantAnimation.setKeyValues": ('typing.List[typing.Tuple]',),
-    "PySide2.QtCore.QVariantAnimation.setStartValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.startValue": (),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QVersionNumber:
-    "PySide2.QtCore.QVersionNumber.__init__": [(), ('int',), ('int', 'int'), ('int', 'int', 'int'), ('typing.List[int]',)],
-    "PySide2.QtCore.QVersionNumber.__copy__": (),
-    "PySide2.QtCore.QVersionNumber.commonPrefix": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.compare": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.fromString": ('str',),
-    "PySide2.QtCore.QVersionNumber.isNormalized": (),
-    "PySide2.QtCore.QVersionNumber.isNull": (),
-    "PySide2.QtCore.QVersionNumber.isPrefixOf": ('PySide2.QtCore.QVersionNumber',),
-    "PySide2.QtCore.QVersionNumber.majorVersion": (),
-    "PySide2.QtCore.QVersionNumber.microVersion": (),
-    "PySide2.QtCore.QVersionNumber.minorVersion": (),
-    "PySide2.QtCore.QVersionNumber.normalized": (),
-    "PySide2.QtCore.QVersionNumber.segmentAt": ('int',),
-    "PySide2.QtCore.QVersionNumber.segmentCount": (),
-    "PySide2.QtCore.QVersionNumber.segments": (),
-    "PySide2.QtCore.QVersionNumber.toString": (),
-# class PySide2.QtCore.QWaitCondition:
-    "PySide2.QtCore.QWaitCondition.__init__": (),
-    "PySide2.QtCore.QWaitCondition.notify_all": (),
-    "PySide2.QtCore.QWaitCondition.notify_one": (),
-    "PySide2.QtCore.QWaitCondition.wait": [('PySide2.QtCore.QMutex', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QMutex', 'int'), ('PySide2.QtCore.QReadWriteLock', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QReadWriteLock', 'int')],
-    "PySide2.QtCore.QWaitCondition.wakeAll": (),
-    "PySide2.QtCore.QWaitCondition.wakeOne": (),
-# class PySide2.QtCore.QWriteLocker:
-    "PySide2.QtCore.QWriteLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QWriteLocker.__enter__": (),
-    "PySide2.QtCore.QWriteLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QWriteLocker.readWriteLock": (),
-    "PySide2.QtCore.QWriteLocker.relock": (),
-    "PySide2.QtCore.QWriteLocker.unlock": (),
-# class PySide2.QtCore.QXmlStreamAttribute:
-    "PySide2.QtCore.QXmlStreamAttribute.__init__": [(), ('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttribute.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttribute.isDefault": (),
-    "PySide2.QtCore.QXmlStreamAttribute.name": (),
-    "PySide2.QtCore.QXmlStreamAttribute.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamAttribute.prefix": (),
-    "PySide2.QtCore.QXmlStreamAttribute.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamAttribute.value": (),
-# class PySide2.QtCore.QXmlStreamAttributes:
-    "PySide2.QtCore.QXmlStreamAttributes.__init__": [(), ('PySide2.QtCore.QXmlStreamAttributes',)],
-    "PySide2.QtCore.QXmlStreamAttributes.__add__": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttributes.__iadd__": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.__lshift__": [('PySide2.QtCore.QXmlStreamAttribute',), ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',)],
-    "PySide2.QtCore.QXmlStreamAttributes.append": [('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.at": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.back": (),
-    "PySide2.QtCore.QXmlStreamAttributes.capacity": (),
-    "PySide2.QtCore.QXmlStreamAttributes.clear": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constData": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.contains": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.count": [(), ('PySide2.QtCore.QXmlStreamAttribute',)],
-    "PySide2.QtCore.QXmlStreamAttributes.data": (),
-    "PySide2.QtCore.QXmlStreamAttributes.empty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.endsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.fill": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.first": (),
-    "PySide2.QtCore.QXmlStreamAttributes.front": (),
-    "PySide2.QtCore.QXmlStreamAttributes.hasAttribute": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.indexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.insert": [('int', 'PySide2.QtCore.QXmlStreamAttribute'), ('int', 'int', 'PySide2.QtCore.QXmlStreamAttribute')],
-    "PySide2.QtCore.QXmlStreamAttributes.isEmpty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.isSharedWith": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.last": (),
-    "PySide2.QtCore.QXmlStreamAttributes.lastIndexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.length": (),
-    "PySide2.QtCore.QXmlStreamAttributes.mid": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.move": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.prepend": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.remove": [('int',), ('int', 'int')],
-    "PySide2.QtCore.QXmlStreamAttributes.removeAll": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeOne": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.replace": ('int', 'PySide2.QtCore.QXmlStreamAttribute'),
-    "PySide2.QtCore.QXmlStreamAttributes.reserve": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.resize": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.setSharable": ('bool',),
-    "PySide2.QtCore.QXmlStreamAttributes.shrink_to_fit": (),
-    "PySide2.QtCore.QXmlStreamAttributes.size": (),
-    "PySide2.QtCore.QXmlStreamAttributes.squeeze": (),
-    "PySide2.QtCore.QXmlStreamAttributes.startsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.swap": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.takeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.takeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.takeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.value": [('str',), ('str', 'str')],
-# class PySide2.QtCore.QXmlStreamEntityDeclaration:
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamEntityDeclaration',)],
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.notationName": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.systemId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.value": (),
-# class PySide2.QtCore.QXmlStreamEntityResolver:
-    "PySide2.QtCore.QXmlStreamEntityResolver.__init__": (),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveEntity": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveUndeclaredEntity": ('str',),
-# class PySide2.QtCore.QXmlStreamNamespaceDeclaration:
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.prefix": (),
-# class PySide2.QtCore.QXmlStreamNotationDeclaration:
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNotationDeclaration',)],
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.systemId": (),
-# class PySide2.QtCore.QXmlStreamReader:
-# class PySide2.QtCore.QXmlStreamReader.Error:
-# class PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour:
-# class PySide2.QtCore.QXmlStreamReader.TokenType:
-    "PySide2.QtCore.QXmlStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclaration": ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',),
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclarations": ('typing.List[PySide2.QtCore.QXmlStreamNamespaceDeclaration]',),
-    "PySide2.QtCore.QXmlStreamReader.atEnd": (),
-    "PySide2.QtCore.QXmlStreamReader.attributes": (),
-    "PySide2.QtCore.QXmlStreamReader.characterOffset": (),
-    "PySide2.QtCore.QXmlStreamReader.clear": (),
-    "PySide2.QtCore.QXmlStreamReader.columnNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.device": (),
-    "PySide2.QtCore.QXmlStreamReader.documentEncoding": (),
-    "PySide2.QtCore.QXmlStreamReader.documentVersion": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdName": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdPublicId": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdSystemId": (),
-    "PySide2.QtCore.QXmlStreamReader.entityDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.entityResolver": (),
-    "PySide2.QtCore.QXmlStreamReader.error": (),
-    "PySide2.QtCore.QXmlStreamReader.errorString": (),
-    "PySide2.QtCore.QXmlStreamReader.hasError": (),
-    "PySide2.QtCore.QXmlStreamReader.isCDATA": (),
-    "PySide2.QtCore.QXmlStreamReader.isCharacters": (),
-    "PySide2.QtCore.QXmlStreamReader.isComment": (),
-    "PySide2.QtCore.QXmlStreamReader.isDTD": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isEntityReference": (),
-    "PySide2.QtCore.QXmlStreamReader.isProcessingInstruction": (),
-    "PySide2.QtCore.QXmlStreamReader.isStandaloneDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isWhitespace": (),
-    "PySide2.QtCore.QXmlStreamReader.lineNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.name": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceProcessing": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamReader.notationDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.prefix": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionData": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionTarget": (),
-    "PySide2.QtCore.QXmlStreamReader.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamReader.raiseError": ('str',),
-    "PySide2.QtCore.QXmlStreamReader.readElementText": ('PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour',),
-    "PySide2.QtCore.QXmlStreamReader.readNext": (),
-    "PySide2.QtCore.QXmlStreamReader.readNextStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamReader.setEntityResolver": ('PySide2.QtCore.QXmlStreamEntityResolver',),
-    "PySide2.QtCore.QXmlStreamReader.setNamespaceProcessing": ('bool',),
-    "PySide2.QtCore.QXmlStreamReader.skipCurrentElement": (),
-    "PySide2.QtCore.QXmlStreamReader.text": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenString": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenType": (),
-# class PySide2.QtCore.QXmlStreamWriter:
-    "PySide2.QtCore.QXmlStreamWriter.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QXmlStreamWriter.autoFormatting": (),
-    "PySide2.QtCore.QXmlStreamWriter.autoFormattingIndent": (),
-    "PySide2.QtCore.QXmlStreamWriter.codec": (),
-    "PySide2.QtCore.QXmlStreamWriter.device": (),
-    "PySide2.QtCore.QXmlStreamWriter.hasError": (),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormatting": ('bool',),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormattingIndent": ('int',),
-    "PySide2.QtCore.QXmlStreamWriter.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QXmlStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamWriter.writeAttribute": [('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeAttributes": ('PySide2.QtCore.QXmlStreamAttributes',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCDATA": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCharacters": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeComment": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCurrentToken": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDTD": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDefaultNamespace": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeEmptyElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeEndDocument": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEndElement": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEntityReference": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeNamespace": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeProcessingInstruction": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeStartDocument": [(), ('str',), ('str', 'bool')],
-    "PySide2.QtCore.QXmlStreamWriter.writeStartElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeTextElement": [('str', 'str'), ('str', 'str', 'str')],
-# class PySide2.QtCore.Qt:
-# class PySide2.QtCore.Qt.Alignment:
-# class PySide2.QtCore.Qt.AlignmentFlag:
-# class PySide2.QtCore.Qt.AnchorPoint:
-# class PySide2.QtCore.Qt.ApplicationAttribute:
-# class PySide2.QtCore.Qt.ApplicationState:
-# class PySide2.QtCore.Qt.ApplicationStates:
-# class PySide2.QtCore.Qt.ArrowType:
-# class PySide2.QtCore.Qt.AspectRatioMode:
-# class PySide2.QtCore.Qt.Axis:
-# class PySide2.QtCore.Qt.BGMode:
-# class PySide2.QtCore.Qt.BrushStyle:
-# class PySide2.QtCore.Qt.CaseSensitivity:
-# class PySide2.QtCore.Qt.CheckState:
-# class PySide2.QtCore.Qt.ChecksumType:
-# class PySide2.QtCore.Qt.ClipOperation:
-# class PySide2.QtCore.Qt.ConnectionType:
-# class PySide2.QtCore.Qt.ContextMenuPolicy:
-# class PySide2.QtCore.Qt.CoordinateSystem:
-# class PySide2.QtCore.Qt.Corner:
-# class PySide2.QtCore.Qt.CursorMoveStyle:
-# class PySide2.QtCore.Qt.CursorShape:
-# class PySide2.QtCore.Qt.DateFormat:
-# class PySide2.QtCore.Qt.DayOfWeek:
-# class PySide2.QtCore.Qt.DockWidgetArea:
-# class PySide2.QtCore.Qt.DockWidgetAreaSizes:
-# class PySide2.QtCore.Qt.DockWidgetAreas:
-# class PySide2.QtCore.Qt.DropAction:
-# class PySide2.QtCore.Qt.DropActions:
-# class PySide2.QtCore.Qt.Edge:
-# class PySide2.QtCore.Qt.Edges:
-# class PySide2.QtCore.Qt.EnterKeyType:
-# class PySide2.QtCore.Qt.EventPriority:
-# class PySide2.QtCore.Qt.FillRule:
-# class PySide2.QtCore.Qt.FindChildOption:
-# class PySide2.QtCore.Qt.FindChildOptions:
-# class PySide2.QtCore.Qt.FocusPolicy:
-# class PySide2.QtCore.Qt.FocusReason:
-# class PySide2.QtCore.Qt.GestureFlag:
-# class PySide2.QtCore.Qt.GestureFlags:
-# class PySide2.QtCore.Qt.GestureState:
-# class PySide2.QtCore.Qt.GestureType:
-# class PySide2.QtCore.Qt.GlobalColor:
-# class PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy:
-# class PySide2.QtCore.Qt.HitTestAccuracy:
-# class PySide2.QtCore.Qt.ImageConversionFlag:
-# class PySide2.QtCore.Qt.ImageConversionFlags:
-# class PySide2.QtCore.Qt.InputMethodHint:
-# class PySide2.QtCore.Qt.InputMethodHints:
-# class PySide2.QtCore.Qt.InputMethodQueries:
-# class PySide2.QtCore.Qt.InputMethodQuery:
-# class PySide2.QtCore.Qt.ItemDataRole:
-# class PySide2.QtCore.Qt.ItemFlag:
-# class PySide2.QtCore.Qt.ItemFlags:
-# class PySide2.QtCore.Qt.ItemSelectionMode:
-# class PySide2.QtCore.Qt.ItemSelectionOperation:
-# class PySide2.QtCore.Qt.Key:
-# class PySide2.QtCore.Qt.KeyboardModifier:
-# class PySide2.QtCore.Qt.KeyboardModifiers:
-# class PySide2.QtCore.Qt.LayoutDirection:
-# class PySide2.QtCore.Qt.MaskMode:
-# class PySide2.QtCore.Qt.MatchFlag:
-# class PySide2.QtCore.Qt.MatchFlags:
-# class PySide2.QtCore.Qt.Modifier:
-# class PySide2.QtCore.Qt.MouseButton:
-# class PySide2.QtCore.Qt.MouseButtons:
-# class PySide2.QtCore.Qt.MouseEventFlag:
-# class PySide2.QtCore.Qt.MouseEventFlags:
-# class PySide2.QtCore.Qt.MouseEventSource:
-# class PySide2.QtCore.Qt.NativeGestureType:
-# class PySide2.QtCore.Qt.NavigationMode:
-# class PySide2.QtCore.Qt.Orientation:
-# class PySide2.QtCore.Qt.Orientations:
-# class PySide2.QtCore.Qt.PenCapStyle:
-# class PySide2.QtCore.Qt.PenJoinStyle:
-# class PySide2.QtCore.Qt.PenStyle:
-# class PySide2.QtCore.Qt.ScreenOrientation:
-# class PySide2.QtCore.Qt.ScreenOrientations:
-# class PySide2.QtCore.Qt.ScrollBarPolicy:
-# class PySide2.QtCore.Qt.ScrollPhase:
-# class PySide2.QtCore.Qt.ShortcutContext:
-# class PySide2.QtCore.Qt.SizeHint:
-# class PySide2.QtCore.Qt.SizeMode:
-# class PySide2.QtCore.Qt.SortOrder:
-# class PySide2.QtCore.Qt.SplitBehavior:
-# class PySide2.QtCore.Qt.SplitBehaviorFlags:
-# class PySide2.QtCore.Qt.TabFocusBehavior:
-# class PySide2.QtCore.Qt.TextElideMode:
-# class PySide2.QtCore.Qt.TextFlag:
-# class PySide2.QtCore.Qt.TextFormat:
-# class PySide2.QtCore.Qt.TextInteractionFlag:
-# class PySide2.QtCore.Qt.TextInteractionFlags:
-# class PySide2.QtCore.Qt.TileRule:
-# class PySide2.QtCore.Qt.TimeSpec:
-# class PySide2.QtCore.Qt.TimerType:
-# class PySide2.QtCore.Qt.ToolBarArea:
-# class PySide2.QtCore.Qt.ToolBarAreaSizes:
-# class PySide2.QtCore.Qt.ToolBarAreas:
-# class PySide2.QtCore.Qt.ToolButtonStyle:
-# class PySide2.QtCore.Qt.TouchPointState:
-# class PySide2.QtCore.Qt.TouchPointStates:
-# class PySide2.QtCore.Qt.TransformationMode:
-# class PySide2.QtCore.Qt.UIEffect:
-# class PySide2.QtCore.Qt.WhiteSpaceMode:
-# class PySide2.QtCore.Qt.WidgetAttribute:
-# class PySide2.QtCore.Qt.WindowFlags:
-# class PySide2.QtCore.Qt.WindowFrameSection:
-# class PySide2.QtCore.Qt.WindowModality:
-# class PySide2.QtCore.Qt.WindowState:
-# class PySide2.QtCore.Qt.WindowStates:
-# class PySide2.QtCore.Qt.WindowType:
-# class PySide2.QtCore.QtMsgType:
-# class PySide2.QtCore.Signal:
-    "PySide2.QtCore.Signal.__init__": ('type', 'str', 'str'),
-# class PySide2.QtCore.SignalInstance:
-    "PySide2.QtCore.SignalInstance.connect": ('object', 'type'),
-    "PySide2.QtCore.SignalInstance.disconnect": ('object',),
-    "PySide2.QtCore.SignalInstance.emit": ('typing.Any',),
-# class PySide2.QtCore.Slot:
-    "PySide2.QtCore.Slot.__init__": ('type', 'str', 'str'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP": ('object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP3": ('object', 'object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.SIGNAL": ('str',),
-    "PySide2.QtCore.Slot.SLOT": ('str',),
-    "PySide2.QtCore.Slot.__moduleShutdown": (),
-    "PySide2.QtCore.Slot.qAbs": ('float',),
-    "PySide2.QtCore.Slot.qAcos": ('float',),
-    "PySide2.QtCore.Slot.qAddPostRoutine": ('object',),
-    "PySide2.QtCore.Slot.qAsin": ('float',),
-    "PySide2.QtCore.Slot.qAtan": ('float',),
-    "PySide2.QtCore.Slot.qAtan2": ('float', 'float'),
-    "PySide2.QtCore.Slot.qChecksum": ('str', 'int'),
-    "PySide2.QtCore.Slot.qCompress": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.Slot.qCritical": ('str',),
-    "PySide2.QtCore.Slot.qDebug": ('str',),
-    "PySide2.QtCore.Slot.qExp": ('float',),
-    "PySide2.QtCore.Slot.qFabs": ('float',),
-    "PySide2.QtCore.Slot.qFastCos": ('float',),
-    "PySide2.QtCore.Slot.qFastSin": ('float',),
-    "PySide2.QtCore.Slot.qFatal": ('str',),
-    "PySide2.QtCore.Slot.qFuzzyCompare": ('float', 'float'),
-    "PySide2.QtCore.Slot.qFuzzyIsNull": ('float',),
-    "PySide2.QtCore.Slot.qInstallMessageHandler": ('object',),
-    "PySide2.QtCore.Slot.qIsFinite": ('float',),
-    "PySide2.QtCore.Slot.qIsInf": ('float',),
-    "PySide2.QtCore.Slot.qIsNaN": ('float',),
-    "PySide2.QtCore.Slot.qIsNull": ('float',),
-    "PySide2.QtCore.Slot.qRegisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qTan": ('float',),
-    "PySide2.QtCore.Slot.qUncompress": [('PySide2.QtCore.QByteArray',), ('str', 'int')],
-    "PySide2.QtCore.Slot.qUnregisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qVersion": (),
-    "PySide2.QtCore.Slot.qWarning": ('str',),
-    "PySide2.QtCore.Slot.qrand": (),
-    "PySide2.QtCore.Slot.qsrand": ('int',),
-    "PySide2.QtCore.Slot.qtTrId": ('str', 'int'),
-    }) if "PySide2.QtCore" in sys.modules else None
-# Module PySide2.QtGui
-sig_dict.update({
-# class PySide2.QtGui.QAbstractOpenGLFunctions:
-    "PySide2.QtGui.QAbstractOpenGLFunctions.__init__": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.isInitialized": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.owningContext": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.setOwningContext": ('PySide2.QtGui.QOpenGLContext',),
-# class PySide2.QtGui.QAbstractTextDocumentLayout:
-# class PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__copy__": (),
-# class PySide2.QtGui.QAbstractTextDocumentLayout.Selection:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.Selection',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__copy__": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.anchorAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockWithMarkerAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.document": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentSize": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.drawInlineObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.format": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatIndex": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.handlerForObject": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.imageAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.pageCount": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.paintDevice": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.positionInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.registerHandler": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.resizeInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.setPaintDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.unregisterHandler": ('int', 'PySide2.QtCore.QObject'),
-# class PySide2.QtGui.QAccessible:
-# class PySide2.QtGui.QAccessible.Event:
-# class PySide2.QtGui.QAccessible.InterfaceType:
-# class PySide2.QtGui.QAccessible.Relation:
-# class PySide2.QtGui.QAccessible.RelationFlag:
-# class PySide2.QtGui.QAccessible.Role:
-# class PySide2.QtGui.QAccessible.State:
-    "PySide2.QtGui.QAccessible.State.__init__": [(), ('PySide2.QtGui.QAccessible.State',)],
-    "PySide2.QtGui.QAccessible.State.__copy__": (),
-# class PySide2.QtGui.QAccessible.Text:
-# class PySide2.QtGui.QAccessible.TextBoundaryType:
-    "PySide2.QtGui.QAccessible.__copy__": (),
-    "PySide2.QtGui.QAccessible.accessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.cleanup": (),
-    "PySide2.QtGui.QAccessible.deleteAccessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.isActive": (),
-    "PySide2.QtGui.QAccessible.qAccessibleTextBoundaryHelper": ('PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessible.queryAccessibleInterface": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.registerAccessibleInterface": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.setActive": ('bool',),
-    "PySide2.QtGui.QAccessible.setRootObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.uniqueId": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.updateAccessibility": ('PySide2.QtGui.QAccessibleEvent',),
-# class PySide2.QtGui.QAccessibleEditableTextInterface:
-    "PySide2.QtGui.QAccessibleEditableTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.deleteText": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.insertText": ('int', 'str'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.replaceText": ('int', 'int', 'str'),
-# class PySide2.QtGui.QAccessibleEvent:
-    "PySide2.QtGui.QAccessibleEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.Event'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.Event')],
-    "PySide2.QtGui.QAccessibleEvent.accessibleInterface": (),
-    "PySide2.QtGui.QAccessibleEvent.child": (),
-    "PySide2.QtGui.QAccessibleEvent.object": (),
-    "PySide2.QtGui.QAccessibleEvent.setChild": ('int',),
-    "PySide2.QtGui.QAccessibleEvent.type": (),
-    "PySide2.QtGui.QAccessibleEvent.uniqueId": (),
-# class PySide2.QtGui.QAccessibleInterface:
-    "PySide2.QtGui.QAccessibleInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleInterface.backgroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.child": ('int',),
-    "PySide2.QtGui.QAccessibleInterface.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.childCount": (),
-    "PySide2.QtGui.QAccessibleInterface.editableTextInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.focusChild": (),
-    "PySide2.QtGui.QAccessibleInterface.foregroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessibleInterface.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtGui.QAccessibleInterface.isValid": (),
-    "PySide2.QtGui.QAccessibleInterface.object": (),
-    "PySide2.QtGui.QAccessibleInterface.parent": (),
-    "PySide2.QtGui.QAccessibleInterface.rect": (),
-    "PySide2.QtGui.QAccessibleInterface.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtGui.QAccessibleInterface.role": (),
-    "PySide2.QtGui.QAccessibleInterface.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-    "PySide2.QtGui.QAccessibleInterface.state": (),
-    "PySide2.QtGui.QAccessibleInterface.tableCellInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtGui.QAccessibleInterface.textInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.valueInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.virtual_hook": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.window": (),
-# class PySide2.QtGui.QAccessibleObject:
-    "PySide2.QtGui.QAccessibleObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessibleObject.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleObject.isValid": (),
-    "PySide2.QtGui.QAccessibleObject.object": (),
-    "PySide2.QtGui.QAccessibleObject.rect": (),
-    "PySide2.QtGui.QAccessibleObject.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-# class PySide2.QtGui.QAccessibleStateChangeEvent:
-    "PySide2.QtGui.QAccessibleStateChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.State'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.State')],
-    "PySide2.QtGui.QAccessibleStateChangeEvent.changedStates": (),
-# class PySide2.QtGui.QAccessibleTableCellInterface:
-    "PySide2.QtGui.QAccessibleTableCellInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.isSelected": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.table": (),
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent:
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType:
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType')],
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.modelChangeType": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setModelChangeType": ('PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType',),
-# class PySide2.QtGui.QAccessibleTextCursorEvent:
-    "PySide2.QtGui.QAccessibleTextCursorEvent.__init__": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int')],
-    "PySide2.QtGui.QAccessibleTextCursorEvent.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextCursorEvent.setCursorPosition": ('int',),
-# class PySide2.QtGui.QAccessibleTextInsertEvent:
-    "PySide2.QtGui.QAccessibleTextInsertEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextInsertEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextInsertEvent.textInserted": (),
-# class PySide2.QtGui.QAccessibleTextInterface:
-    "PySide2.QtGui.QAccessibleTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTextInterface.addSelection": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.attributes": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.characterCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.characterRect": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextInterface.offsetAtPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QAccessibleTextInterface.removeSelection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.scrollToSubstring": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.selection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.selectionCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.setCursorPosition": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.setSelection": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.text": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAfterOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAtOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textBeforeOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-# class PySide2.QtGui.QAccessibleTextRemoveEvent:
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleTextSelectionEvent:
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'int')],
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionEnd": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionStart": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.setSelection": ('int', 'int'),
-# class PySide2.QtGui.QAccessibleTextUpdateEvent:
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str', 'str')],
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textInserted": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleValueChangeEvent:
-    "PySide2.QtGui.QAccessibleValueChangeEvent.__init__": [('PySide2.QtCore.QObject', 'typing.Any'), ('PySide2.QtGui.QAccessibleInterface', 'typing.Any')],
-    "PySide2.QtGui.QAccessibleValueChangeEvent.setValue": ('typing.Any',),
-    "PySide2.QtGui.QAccessibleValueChangeEvent.value": (),
-# class PySide2.QtGui.QAccessibleValueInterface:
-    "PySide2.QtGui.QAccessibleValueInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleValueInterface.currentValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.maximumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumStepSize": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.setCurrentValue": ('typing.Any',),
-# class PySide2.QtGui.QActionEvent:
-# class PySide2.QtGui.QBackingStore:
-    "PySide2.QtGui.QBackingStore.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QBackingStore.beginPaint": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.endPaint": (),
-    "PySide2.QtGui.QBackingStore.flush": ('PySide2.QtGui.QRegion', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QBackingStore.hasStaticContents": (),
-    "PySide2.QtGui.QBackingStore.paintDevice": (),
-    "PySide2.QtGui.QBackingStore.resize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QBackingStore.scroll": ('PySide2.QtGui.QRegion', 'int', 'int'),
-    "PySide2.QtGui.QBackingStore.setStaticContents": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.size": (),
-    "PySide2.QtGui.QBackingStore.staticContents": (),
-    "PySide2.QtGui.QBackingStore.window": (),
-# class PySide2.QtGui.QBitmap:
-    "PySide2.QtGui.QBitmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str')],
-    "PySide2.QtGui.QBitmap.__copy__": (),
-    "PySide2.QtGui.QBitmap.clear": (),
-    "PySide2.QtGui.QBitmap.fromData": ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QImage.Format'),
-    "PySide2.QtGui.QBitmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QBitmap.swap": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBitmap.transformed": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform',)],
-# class PySide2.QtGui.QBrush:
-    "PySide2.QtGui.QBrush.__init__": [(), ('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QBrush',), ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBrush.__copy__": (),
-    "PySide2.QtGui.QBrush.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.color": (),
-    "PySide2.QtGui.QBrush.gradient": (),
-    "PySide2.QtGui.QBrush.isOpaque": (),
-    "PySide2.QtGui.QBrush.matrix": (),
-    "PySide2.QtGui.QBrush.setColor": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',)],
-    "PySide2.QtGui.QBrush.setMatrix": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QBrush.setStyle": ('PySide2.QtCore.Qt.BrushStyle',),
-    "PySide2.QtGui.QBrush.setTexture": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QBrush.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QBrush.setTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QBrush.style": (),
-    "PySide2.QtGui.QBrush.swap": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QBrush.texture": (),
-    "PySide2.QtGui.QBrush.textureImage": (),
-    "PySide2.QtGui.QBrush.transform": (),
-# class PySide2.QtGui.QClipboard:
-# class PySide2.QtGui.QClipboard.Mode:
-    "PySide2.QtGui.QClipboard.clear": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.image": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.mimeData": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.ownsClipboard": (),
-    "PySide2.QtGui.QClipboard.ownsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.ownsSelection": (),
-    "PySide2.QtGui.QClipboard.pixmap": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.setImage": ('PySide2.QtGui.QImage', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setText": ('str', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.supportsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.supportsSelection": (),
-    "PySide2.QtGui.QClipboard.text": [('PySide2.QtGui.QClipboard.Mode',), ('str', 'PySide2.QtGui.QClipboard.Mode')],
-# class PySide2.QtGui.QCloseEvent:
-    "PySide2.QtGui.QCloseEvent.__init__": (),
-# class PySide2.QtGui.QColor:
-# class PySide2.QtGui.QColor.NameFormat:
-# class PySide2.QtGui.QColor.Spec:
-    "PySide2.QtGui.QColor.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor.Spec', 'int', 'int', 'int', 'int', 'int'), ('int',), ('int', 'int', 'int', 'int'), ('str',), ('typing.Any',)],
-    "PySide2.QtGui.QColor.__copy__": (),
-    "PySide2.QtGui.QColor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__reduce__": (),
-    "PySide2.QtGui.QColor.__repr__": (),
-    "PySide2.QtGui.QColor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__setstate__": ('object',),
-    "PySide2.QtGui.QColor.__str__": (),
-    "PySide2.QtGui.QColor.alpha": (),
-    "PySide2.QtGui.QColor.alphaF": (),
-    "PySide2.QtGui.QColor.black": (),
-    "PySide2.QtGui.QColor.blackF": (),
-    "PySide2.QtGui.QColor.blue": (),
-    "PySide2.QtGui.QColor.blueF": (),
-    "PySide2.QtGui.QColor.colorNames": (),
-    "PySide2.QtGui.QColor.convertTo": ('PySide2.QtGui.QColor.Spec',),
-    "PySide2.QtGui.QColor.cyan": (),
-    "PySide2.QtGui.QColor.cyanF": (),
-    "PySide2.QtGui.QColor.dark": ('int',),
-    "PySide2.QtGui.QColor.darker": ('int',),
-    "PySide2.QtGui.QColor.fromCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.fromRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgba": ('int',),
-    "PySide2.QtGui.QColor.fromRgba64": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.getCmyk": (),
-    "PySide2.QtGui.QColor.getCmykF": (),
-    "PySide2.QtGui.QColor.getHsl": (),
-    "PySide2.QtGui.QColor.getHslF": (),
-    "PySide2.QtGui.QColor.getHsv": (),
-    "PySide2.QtGui.QColor.getHsvF": (),
-    "PySide2.QtGui.QColor.getRgb": (),
-    "PySide2.QtGui.QColor.getRgbF": (),
-    "PySide2.QtGui.QColor.green": (),
-    "PySide2.QtGui.QColor.greenF": (),
-    "PySide2.QtGui.QColor.hslHue": (),
-    "PySide2.QtGui.QColor.hslHueF": (),
-    "PySide2.QtGui.QColor.hslSaturation": (),
-    "PySide2.QtGui.QColor.hslSaturationF": (),
-    "PySide2.QtGui.QColor.hsvHue": (),
-    "PySide2.QtGui.QColor.hsvHueF": (),
-    "PySide2.QtGui.QColor.hsvSaturation": (),
-    "PySide2.QtGui.QColor.hsvSaturationF": (),
-    "PySide2.QtGui.QColor.hue": (),
-    "PySide2.QtGui.QColor.hueF": (),
-    "PySide2.QtGui.QColor.isValid": (),
-    "PySide2.QtGui.QColor.isValidColor": ('str',),
-    "PySide2.QtGui.QColor.light": ('int',),
-    "PySide2.QtGui.QColor.lighter": ('int',),
-    "PySide2.QtGui.QColor.lightness": (),
-    "PySide2.QtGui.QColor.lightnessF": (),
-    "PySide2.QtGui.QColor.magenta": (),
-    "PySide2.QtGui.QColor.magentaF": (),
-    "PySide2.QtGui.QColor.name": [(), ('PySide2.QtGui.QColor.NameFormat',)],
-    "PySide2.QtGui.QColor.red": (),
-    "PySide2.QtGui.QColor.redF": (),
-    "PySide2.QtGui.QColor.rgb": (),
-    "PySide2.QtGui.QColor.rgba": (),
-    "PySide2.QtGui.QColor.saturation": (),
-    "PySide2.QtGui.QColor.saturationF": (),
-    "PySide2.QtGui.QColor.setAlpha": ('int',),
-    "PySide2.QtGui.QColor.setAlphaF": ('float',),
-    "PySide2.QtGui.QColor.setBlue": ('int',),
-    "PySide2.QtGui.QColor.setBlueF": ('float',),
-    "PySide2.QtGui.QColor.setCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setGreen": ('int',),
-    "PySide2.QtGui.QColor.setGreenF": ('float',),
-    "PySide2.QtGui.QColor.setHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setNamedColor": ('str',),
-    "PySide2.QtGui.QColor.setRed": ('int',),
-    "PySide2.QtGui.QColor.setRedF": ('float',),
-    "PySide2.QtGui.QColor.setRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.setRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setRgba": ('int',),
-    "PySide2.QtGui.QColor.spec": (),
-    "PySide2.QtGui.QColor.toCmyk": (),
-    "PySide2.QtGui.QColor.toExtendedRgb": (),
-    "PySide2.QtGui.QColor.toHsl": (),
-    "PySide2.QtGui.QColor.toHsv": (),
-    "PySide2.QtGui.QColor.toRgb": (),
-    "PySide2.QtGui.QColor.toTuple": (),
-    "PySide2.QtGui.QColor.value": (),
-    "PySide2.QtGui.QColor.valueF": (),
-    "PySide2.QtGui.QColor.yellow": (),
-    "PySide2.QtGui.QColor.yellowF": (),
-# class PySide2.QtGui.QColorSpace:
-# class PySide2.QtGui.QColorSpace.NamedColorSpace:
-# class PySide2.QtGui.QColorSpace.Primaries:
-# class PySide2.QtGui.QColorSpace.TransferFunction:
-    "PySide2.QtGui.QColorSpace.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace',), ('PySide2.QtGui.QColorSpace.NamedColorSpace',), ('PySide2.QtGui.QColorSpace.Primaries', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace.Primaries', 'float')],
-    "PySide2.QtGui.QColorSpace.__copy__": (),
-    "PySide2.QtGui.QColorSpace.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.fromIccProfile": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QColorSpace.gamma": (),
-    "PySide2.QtGui.QColorSpace.iccProfile": (),
-    "PySide2.QtGui.QColorSpace.isValid": (),
-    "PySide2.QtGui.QColorSpace.primaries": (),
-    "PySide2.QtGui.QColorSpace.setPrimaries": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QColorSpace.Primaries',)],
-    "PySide2.QtGui.QColorSpace.setTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-    "PySide2.QtGui.QColorSpace.swap": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QColorSpace.transferFunction": (),
-    "PySide2.QtGui.QColorSpace.withTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-# class PySide2.QtGui.QConicalGradient:
-    "PySide2.QtGui.QConicalGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QConicalGradient',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QConicalGradient.__copy__": (),
-    "PySide2.QtGui.QConicalGradient.angle": (),
-    "PySide2.QtGui.QConicalGradient.center": (),
-    "PySide2.QtGui.QConicalGradient.setAngle": ('float',),
-    "PySide2.QtGui.QConicalGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-# class PySide2.QtGui.QContextMenuEvent:
-# class PySide2.QtGui.QContextMenuEvent.Reason:
-    "PySide2.QtGui.QContextMenuEvent.__init__": [('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QContextMenuEvent.globalPos": (),
-    "PySide2.QtGui.QContextMenuEvent.globalX": (),
-    "PySide2.QtGui.QContextMenuEvent.global""Y": (),
-    "PySide2.QtGui.QContextMenuEvent.pos": (),
-    "PySide2.QtGui.QContextMenuEvent.reason": (),
-    "PySide2.QtGui.QContextMenuEvent.x": (),
-    "PySide2.QtGui.QContextMenuEvent.y": (),
-# class PySide2.QtGui.QCursor:
-    "PySide2.QtGui.QCursor.__init__": [(), ('PySide2.QtCore.Qt.CursorShape',), ('PySide2.QtGui.QBitmap', 'PySide2.QtGui.QBitmap', 'int', 'int'), ('PySide2.QtGui.QCursor',), ('PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QCursor.__copy__": (),
-    "PySide2.QtGui.QCursor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.bitmap": (),
-    "PySide2.QtGui.QCursor.hotSpot": (),
-    "PySide2.QtGui.QCursor.mask": (),
-    "PySide2.QtGui.QCursor.pixmap": (),
-    "PySide2.QtGui.QCursor.pos": [(), ('PySide2.QtGui.QScreen',)],
-    "PySide2.QtGui.QCursor.setPos": [('PySide2.QtCore.QPoint',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QScreen', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtGui.QCursor.setShape": ('PySide2.QtCore.Qt.CursorShape',),
-    "PySide2.QtGui.QCursor.shape": (),
-    "PySide2.QtGui.QCursor.swap": ('PySide2.QtGui.QCursor',),
-# class PySide2.QtGui.QDesktopServices:
-    "PySide2.QtGui.QDesktopServices.__init__": (),
-    "PySide2.QtGui.QDesktopServices.openUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QDesktopServices.setUrlHandler": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtGui.QDesktopServices.unsetUrlHandler": ('str',),
-# class PySide2.QtGui.QDoubleValidator:
-# class PySide2.QtGui.QDoubleValidator.Notation:
-    "PySide2.QtGui.QDoubleValidator.__init__": [('PySide2.QtCore.QObject',), ('float', 'float', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QDoubleValidator.bottom": (),
-    "PySide2.QtGui.QDoubleValidator.decimals": (),
-    "PySide2.QtGui.QDoubleValidator.notation": (),
-    "PySide2.QtGui.QDoubleValidator.setBottom": ('float',),
-    "PySide2.QtGui.QDoubleValidator.setDecimals": ('int',),
-    "PySide2.QtGui.QDoubleValidator.setNotation": ('PySide2.QtGui.QDoubleValidator.Notation',),
-    "PySide2.QtGui.QDoubleValidator.setRange": ('float', 'float', 'int'),
-    "PySide2.QtGui.QDoubleValidator.setTop": ('float',),
-    "PySide2.QtGui.QDoubleValidator.top": (),
-    "PySide2.QtGui.QDoubleValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QDrag:
-    "PySide2.QtGui.QDrag.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QDrag.cancel": (),
-    "PySide2.QtGui.QDrag.defaultAction": (),
-    "PySide2.QtGui.QDrag.dragCursor": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDrag.exec_": [('PySide2.QtCore.Qt.DropActions',), ('PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.Qt.DropAction')],
-    "PySide2.QtGui.QDrag.hotSpot": (),
-    "PySide2.QtGui.QDrag.mimeData": (),
-    "PySide2.QtGui.QDrag.pixmap": (),
-    "PySide2.QtGui.QDrag.setDragCursor": ('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtGui.QDrag.setHotSpot": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QDrag.setMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtGui.QDrag.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QDrag.source": (),
-    "PySide2.QtGui.QDrag.start": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtGui.QDrag.supportedActions": (),
-    "PySide2.QtGui.QDrag.target": (),
-# class PySide2.QtGui.QDragEnterEvent:
-    "PySide2.QtGui.QDragEnterEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-# class PySide2.QtGui.QDragLeaveEvent:
-    "PySide2.QtGui.QDragLeaveEvent.__init__": (),
-# class PySide2.QtGui.QDragMoveEvent:
-    "PySide2.QtGui.QDragMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDragMoveEvent.accept": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QDragMoveEvent.answerRect": (),
-    "PySide2.QtGui.QDragMoveEvent.ignore": [(), ('PySide2.QtCore.QRect',)],
-# class PySide2.QtGui.QDropEvent:
-    "PySide2.QtGui.QDropEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDropEvent.acceptProposedAction": (),
-    "PySide2.QtGui.QDropEvent.dropAction": (),
-    "PySide2.QtGui.QDropEvent.keyboardModifiers": (),
-    "PySide2.QtGui.QDropEvent.mimeData": (),
-    "PySide2.QtGui.QDropEvent.mouseButtons": (),
-    "PySide2.QtGui.QDropEvent.pos": (),
-    "PySide2.QtGui.QDropEvent.posF": (),
-    "PySide2.QtGui.QDropEvent.possibleActions": (),
-    "PySide2.QtGui.QDropEvent.proposedAction": (),
-    "PySide2.QtGui.QDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDropEvent.source": (),
-# class PySide2.QtGui.QEnterEvent:
-    "PySide2.QtGui.QEnterEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QEnterEvent.globalPos": (),
-    "PySide2.QtGui.QEnterEvent.globalX": (),
-    "PySide2.QtGui.QEnterEvent.global""Y": (),
-    "PySide2.QtGui.QEnterEvent.localPos": (),
-    "PySide2.QtGui.QEnterEvent.pos": (),
-    "PySide2.QtGui.QEnterEvent.screenPos": (),
-    "PySide2.QtGui.QEnterEvent.windowPos": (),
-    "PySide2.QtGui.QEnterEvent.x": (),
-    "PySide2.QtGui.QEnterEvent.y": (),
-# class PySide2.QtGui.QExposeEvent:
-    "PySide2.QtGui.QExposeEvent.__init__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QExposeEvent.region": (),
-# class PySide2.QtGui.QFileOpenEvent:
-    "PySide2.QtGui.QFileOpenEvent.__init__": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtGui.QFileOpenEvent.file": (),
-    "PySide2.QtGui.QFileOpenEvent.openFile": ('PySide2.QtCore.QFile', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtGui.QFileOpenEvent.url": (),
-# class PySide2.QtGui.QFocusEvent:
-    "PySide2.QtGui.QFocusEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtGui.QFocusEvent.gotFocus": (),
-    "PySide2.QtGui.QFocusEvent.lostFocus": (),
-    "PySide2.QtGui.QFocusEvent.reason": (),
-# class PySide2.QtGui.QFont:
-# class PySide2.QtGui.QFont.Capitalization:
-# class PySide2.QtGui.QFont.HintingPreference:
-# class PySide2.QtGui.QFont.SpacingType:
-# class PySide2.QtGui.QFont.Stretch:
-# class PySide2.QtGui.QFont.Style:
-# class PySide2.QtGui.QFont.StyleHint:
-# class PySide2.QtGui.QFont.StyleStrategy:
-# class PySide2.QtGui.QFont.Weight:
-    "PySide2.QtGui.QFont.__init__": [(), ('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('str', 'int', 'int', 'bool')],
-    "PySide2.QtGui.QFont.__copy__": (),
-    "PySide2.QtGui.QFont.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.bold": (),
-    "PySide2.QtGui.QFont.cacheStatistics": (),
-    "PySide2.QtGui.QFont.capitalization": (),
-    "PySide2.QtGui.QFont.cleanup": (),
-    "PySide2.QtGui.QFont.defaultFamily": (),
-    "PySide2.QtGui.QFont.exactMatch": (),
-    "PySide2.QtGui.QFont.families": (),
-    "PySide2.QtGui.QFont.family": (),
-    "PySide2.QtGui.QFont.fixedPitch": (),
-    "PySide2.QtGui.QFont.fromString": ('str',),
-    "PySide2.QtGui.QFont.hintingPreference": (),
-    "PySide2.QtGui.QFont.initialize": (),
-    "PySide2.QtGui.QFont.insertSubstitution": ('str', 'str'),
-    "PySide2.QtGui.QFont.insertSubstitutions": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtGui.QFont.isCopyOf": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.italic": (),
-    "PySide2.QtGui.QFont.kerning": (),
-    "PySide2.QtGui.QFont.key": (),
-    "PySide2.QtGui.QFont.lastResortFamily": (),
-    "PySide2.QtGui.QFont.lastResortFont": (),
-    "PySide2.QtGui.QFont.letterSpacing": (),
-    "PySide2.QtGui.QFont.letterSpacingType": (),
-    "PySide2.QtGui.QFont.overline": (),
-    "PySide2.QtGui.QFont.pixelSize": (),
-    "PySide2.QtGui.QFont.pointSize": (),
-    "PySide2.QtGui.QFont.pointSizeF": (),
-    "PySide2.QtGui.QFont.rawMode": (),
-    "PySide2.QtGui.QFont.rawName": (),
-    "PySide2.QtGui.QFont.removeSubstitutions": ('str',),
-    "PySide2.QtGui.QFont.resolve": [(), ('PySide2.QtGui.QFont',), ('int',)],
-    "PySide2.QtGui.QFont.setBold": ('bool',),
-    "PySide2.QtGui.QFont.setCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QFont.setFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QFont.setFamily": ('str',),
-    "PySide2.QtGui.QFont.setFixedPitch": ('bool',),
-    "PySide2.QtGui.QFont.setHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QFont.setItalic": ('bool',),
-    "PySide2.QtGui.QFont.setKerning": ('bool',),
-    "PySide2.QtGui.QFont.setLetterSpacing": ('PySide2.QtGui.QFont.SpacingType', 'float'),
-    "PySide2.QtGui.QFont.setOverline": ('bool',),
-    "PySide2.QtGui.QFont.setPixelSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSizeF": ('float',),
-    "PySide2.QtGui.QFont.setRawMode": ('bool',),
-    "PySide2.QtGui.QFont.setRawName": ('str',),
-    "PySide2.QtGui.QFont.setStretch": ('int',),
-    "PySide2.QtGui.QFont.setStrikeOut": ('bool',),
-    "PySide2.QtGui.QFont.setStyle": ('PySide2.QtGui.QFont.Style',),
-    "PySide2.QtGui.QFont.setStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QFont.setStyleName": ('str',),
-    "PySide2.QtGui.QFont.setStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QFont.setUnderline": ('bool',),
-    "PySide2.QtGui.QFont.setWeight": ('int',),
-    "PySide2.QtGui.QFont.setWordSpacing": ('float',),
-    "PySide2.QtGui.QFont.stretch": (),
-    "PySide2.QtGui.QFont.strikeOut": (),
-    "PySide2.QtGui.QFont.style": (),
-    "PySide2.QtGui.QFont.styleHint": (),
-    "PySide2.QtGui.QFont.styleName": (),
-    "PySide2.QtGui.QFont.styleStrategy": (),
-    "PySide2.QtGui.QFont.substitute": ('str',),
-    "PySide2.QtGui.QFont.substitutes": ('str',),
-    "PySide2.QtGui.QFont.substitutions": (),
-    "PySide2.QtGui.QFont.swap": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.toString": (),
-    "PySide2.QtGui.QFont.underline": (),
-    "PySide2.QtGui.QFont.weight": (),
-    "PySide2.QtGui.QFont.wordSpacing": (),
-# class PySide2.QtGui.QFontDatabase:
-# class PySide2.QtGui.QFontDatabase.SystemFont:
-# class PySide2.QtGui.QFontDatabase.WritingSystem:
-    "PySide2.QtGui.QFontDatabase.__init__": [(), ('PySide2.QtGui.QFontDatabase',)],
-    "PySide2.QtGui.QFontDatabase.__copy__": (),
-    "PySide2.QtGui.QFontDatabase.addApplicationFont": ('str',),
-    "PySide2.QtGui.QFontDatabase.addApplicationFontFromData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QFontDatabase.applicationFontFamilies": ('int',),
-    "PySide2.QtGui.QFontDatabase.bold": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.families": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.font": ('str', 'str', 'int'),
-    "PySide2.QtGui.QFontDatabase.hasFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isBitmapScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isFixedPitch": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isPrivateFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isSmoothlyScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.italic": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.pointSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.removeAllApplicationFonts": (),
-    "PySide2.QtGui.QFontDatabase.removeApplicationFont": ('int',),
-    "PySide2.QtGui.QFontDatabase.smoothSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.standardSizes": (),
-    "PySide2.QtGui.QFontDatabase.styleString": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontDatabase.styles": ('str',),
-    "PySide2.QtGui.QFontDatabase.supportsThreadedFontRendering": (),
-    "PySide2.QtGui.QFontDatabase.systemFont": ('PySide2.QtGui.QFontDatabase.SystemFont',),
-    "PySide2.QtGui.QFontDatabase.weight": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.writingSystemName": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystemSample": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystems": [(), ('str',)],
-# class PySide2.QtGui.QFontInfo:
-    "PySide2.QtGui.QFontInfo.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontInfo.__copy__": (),
-    "PySide2.QtGui.QFontInfo.bold": (),
-    "PySide2.QtGui.QFontInfo.exactMatch": (),
-    "PySide2.QtGui.QFontInfo.family": (),
-    "PySide2.QtGui.QFontInfo.fixedPitch": (),
-    "PySide2.QtGui.QFontInfo.italic": (),
-    "PySide2.QtGui.QFontInfo.overline": (),
-    "PySide2.QtGui.QFontInfo.pixelSize": (),
-    "PySide2.QtGui.QFontInfo.pointSize": (),
-    "PySide2.QtGui.QFontInfo.pointSizeF": (),
-    "PySide2.QtGui.QFontInfo.rawMode": (),
-    "PySide2.QtGui.QFontInfo.strikeOut": (),
-    "PySide2.QtGui.QFontInfo.style": (),
-    "PySide2.QtGui.QFontInfo.styleHint": (),
-    "PySide2.QtGui.QFontInfo.styleName": (),
-    "PySide2.QtGui.QFontInfo.swap": ('PySide2.QtGui.QFontInfo',),
-    "PySide2.QtGui.QFontInfo.underline": (),
-    "PySide2.QtGui.QFontInfo.weight": (),
-# class PySide2.QtGui.QFontMetrics:
-    "PySide2.QtGui.QFontMetrics.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',)],
-    "PySide2.QtGui.QFontMetrics.__copy__": (),
-    "PySide2.QtGui.QFontMetrics.ascent": (),
-    "PySide2.QtGui.QFontMetrics.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetrics.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('int', 'int', 'int', 'int', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetrics.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.capHeight": (),
-    "PySide2.QtGui.QFontMetrics.charWidth": ('str', 'int'),
-    "PySide2.QtGui.QFontMetrics.descent": (),
-    "PySide2.QtGui.QFontMetrics.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'int', 'int'),
-    "PySide2.QtGui.QFontMetrics.fontDpi": (),
-    "PySide2.QtGui.QFontMetrics.height": (),
-    "PySide2.QtGui.QFontMetrics.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetrics.inFont": ('str',),
-    "PySide2.QtGui.QFontMetrics.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetrics.leading": (),
-    "PySide2.QtGui.QFontMetrics.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.lineSpacing": (),
-    "PySide2.QtGui.QFontMetrics.lineWidth": (),
-    "PySide2.QtGui.QFontMetrics.maxWidth": (),
-    "PySide2.QtGui.QFontMetrics.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetrics.minRightBearing": (),
-    "PySide2.QtGui.QFontMetrics.overlinePos": (),
-    "PySide2.QtGui.QFontMetrics.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetrics.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetrics.swap": ('PySide2.QtGui.QFontMetrics',),
-    "PySide2.QtGui.QFontMetrics.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetrics.underlinePos": (),
-    "PySide2.QtGui.QFontMetrics.width": [('str', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtGui.QFontMetrics.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.xHeight": (),
-# class PySide2.QtGui.QFontMetricsF:
-    "PySide2.QtGui.QFontMetricsF.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',), ('PySide2.QtGui.QFontMetricsF',)],
-    "PySide2.QtGui.QFontMetricsF.__copy__": (),
-    "PySide2.QtGui.QFontMetricsF.ascent": (),
-    "PySide2.QtGui.QFontMetricsF.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetricsF.boundingRect": [('PySide2.QtCore.QRectF', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetricsF.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.capHeight": (),
-    "PySide2.QtGui.QFontMetricsF.descent": (),
-    "PySide2.QtGui.QFontMetricsF.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'float', 'int'),
-    "PySide2.QtGui.QFontMetricsF.fontDpi": (),
-    "PySide2.QtGui.QFontMetricsF.height": (),
-    "PySide2.QtGui.QFontMetricsF.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetricsF.inFont": ('str',),
-    "PySide2.QtGui.QFontMetricsF.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetricsF.leading": (),
-    "PySide2.QtGui.QFontMetricsF.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.lineSpacing": (),
-    "PySide2.QtGui.QFontMetricsF.lineWidth": (),
-    "PySide2.QtGui.QFontMetricsF.maxWidth": (),
-    "PySide2.QtGui.QFontMetricsF.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetricsF.minRightBearing": (),
-    "PySide2.QtGui.QFontMetricsF.overlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetricsF.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetricsF.swap": ('PySide2.QtGui.QFontMetricsF',),
-    "PySide2.QtGui.QFontMetricsF.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetricsF.underlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.width": ('str',),
-    "PySide2.QtGui.QFontMetricsF.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.xHeight": (),
-# class PySide2.QtGui.QGradient:
-# class PySide2.QtGui.QGradient.CoordinateMode:
-# class PySide2.QtGui.QGradient.InterpolationMode:
-# class PySide2.QtGui.QGradient.Preset:
-# class PySide2.QtGui.QGradient.Spread:
-# class PySide2.QtGui.QGradient.Type:
-    "PySide2.QtGui.QGradient.__init__": [(), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QGradient.Preset',)],
-    "PySide2.QtGui.QGradient.__copy__": (),
-    "PySide2.QtGui.QGradient.coordinateMode": (),
-    "PySide2.QtGui.QGradient.interpolationMode": (),
-    "PySide2.QtGui.QGradient.setColorAt": ('float', 'PySide2.QtGui.QColor'),
-    "PySide2.QtGui.QGradient.setCoordinateMode": ('PySide2.QtGui.QGradient.CoordinateMode',),
-    "PySide2.QtGui.QGradient.setInterpolationMode": ('PySide2.QtGui.QGradient.InterpolationMode',),
-    "PySide2.QtGui.QGradient.setSpread": ('PySide2.QtGui.QGradient.Spread',),
-    "PySide2.QtGui.QGradient.setStops": ('typing.List[typing.Tuple]',),
-    "PySide2.QtGui.QGradient.spread": (),
-    "PySide2.QtGui.QGradient.stops": (),
-    "PySide2.QtGui.QGradient.type": (),
-# class PySide2.QtGui.QGuiApplication:
-    "PySide2.QtGui.QGuiApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QGuiApplication.allWindows": (),
-    "PySide2.QtGui.QGuiApplication.applicationDisplayName": (),
-    "PySide2.QtGui.QGuiApplication.applicationState": (),
-    "PySide2.QtGui.QGuiApplication.changeOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.clipboard": (),
-    "PySide2.QtGui.QGuiApplication.desktopFileName": (),
-    "PySide2.QtGui.QGuiApplication.desktopSettingsAware": (),
-    "PySide2.QtGui.QGuiApplication.devicePixelRatio": (),
-    "PySide2.QtGui.QGuiApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QGuiApplication.exec_": (),
-    "PySide2.QtGui.QGuiApplication.focusObject": (),
-    "PySide2.QtGui.QGuiApplication.focusWindow": (),
-    "PySide2.QtGui.QGuiApplication.font": (),
-    "PySide2.QtGui.QGuiApplication.highDpiScaleFactorRoundingPolicy": (),
-    "PySide2.QtGui.QGuiApplication.inputMethod": (),
-    "PySide2.QtGui.QGuiApplication.isFallbackSessionManagementEnabled": (),
-    "PySide2.QtGui.QGuiApplication.isLeftToRight": (),
-    "PySide2.QtGui.QGuiApplication.isRightToLeft": (),
-    "PySide2.QtGui.QGuiApplication.isSavingSession": (),
-    "PySide2.QtGui.QGuiApplication.isSessionRestored": (),
-    "PySide2.QtGui.QGuiApplication.keyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.layoutDirection": (),
-    "PySide2.QtGui.QGuiApplication.modalWindow": (),
-    "PySide2.QtGui.QGuiApplication.mouseButtons": (),
-    "PySide2.QtGui.QGuiApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtGui.QGuiApplication.overrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.palette": (),
-    "PySide2.QtGui.QGuiApplication.platformName": (),
-    "PySide2.QtGui.QGuiApplication.primaryScreen": (),
-    "PySide2.QtGui.QGuiApplication.queryKeyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.quitOnLastWindowClosed": (),
-    "PySide2.QtGui.QGuiApplication.restoreOverrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.screenAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.screens": (),
-    "PySide2.QtGui.QGuiApplication.sessionId": (),
-    "PySide2.QtGui.QGuiApplication.sessionKey": (),
-    "PySide2.QtGui.QGuiApplication.setApplicationDisplayName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopFileName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopSettingsAware": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFallbackSessionManagementEnabled": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QGuiApplication.setHighDpiScaleFactorRoundingPolicy": ('PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy',),
-    "PySide2.QtGui.QGuiApplication.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QGuiApplication.setOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QGuiApplication.setQuitOnLastWindowClosed": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QGuiApplication.styleHints": (),
-    "PySide2.QtGui.QGuiApplication.sync": (),
-    "PySide2.QtGui.QGuiApplication.topLevelAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.topLevelWindows": (),
-    "PySide2.QtGui.QGuiApplication.windowIcon": (),
-# class PySide2.QtGui.QHelpEvent:
-    "PySide2.QtGui.QHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QHelpEvent.globalPos": (),
-    "PySide2.QtGui.QHelpEvent.globalX": (),
-    "PySide2.QtGui.QHelpEvent.global""Y": (),
-    "PySide2.QtGui.QHelpEvent.pos": (),
-    "PySide2.QtGui.QHelpEvent.x": (),
-    "PySide2.QtGui.QHelpEvent.y": (),
-# class PySide2.QtGui.QHideEvent:
-    "PySide2.QtGui.QHideEvent.__init__": (),
-# class PySide2.QtGui.QHoverEvent:
-    "PySide2.QtGui.QHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QHoverEvent.oldPos": (),
-    "PySide2.QtGui.QHoverEvent.oldPosF": (),
-    "PySide2.QtGui.QHoverEvent.pos": (),
-    "PySide2.QtGui.QHoverEvent.posF": (),
-# class PySide2.QtGui.QIcon:
-# class PySide2.QtGui.QIcon.Mode:
-# class PySide2.QtGui.QIcon.State:
-    "PySide2.QtGui.QIcon.__init__": [(), ('PySide2.QtGui.QIcon',), ('PySide2.QtGui.QIconEngine',), ('PySide2.QtGui.QPixmap',), ('str',)],
-    "PySide2.QtGui.QIcon.__copy__": (),
-    "PySide2.QtGui.QIcon.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.actualSize": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.cacheKey": (),
-    "PySide2.QtGui.QIcon.fallbackSearchPaths": (),
-    "PySide2.QtGui.QIcon.fallbackThemeName": (),
-    "PySide2.QtGui.QIcon.fromTheme": [('str',), ('str', 'PySide2.QtGui.QIcon')],
-    "PySide2.QtGui.QIcon.hasThemeIcon": ('str',),
-    "PySide2.QtGui.QIcon.isMask": (),
-    "PySide2.QtGui.QIcon.isNull": (),
-    "PySide2.QtGui.QIcon.name": (),
-    "PySide2.QtGui.QIcon.paint": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QPainter', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.pixmap": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.setFallbackSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.setFallbackThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setIsMask": ('bool',),
-    "PySide2.QtGui.QIcon.setThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setThemeSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.swap": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QIcon.themeName": (),
-    "PySide2.QtGui.QIcon.themeSearchPaths": (),
-# class PySide2.QtGui.QIconDragEvent:
-    "PySide2.QtGui.QIconDragEvent.__init__": (),
-# class PySide2.QtGui.QIconEngine:
-# class PySide2.QtGui.QIconEngine.AvailableSizesArgument:
-    "PySide2.QtGui.QIconEngine.AvailableSizesArgument.__init__": (),
-# class PySide2.QtGui.QIconEngine.IconEngineHook:
-    "PySide2.QtGui.QIconEngine.__init__": [(), ('PySide2.QtGui.QIconEngine',)],
-    "PySide2.QtGui.QIconEngine.actualSize": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.clone": (),
-    "PySide2.QtGui.QIconEngine.iconName": (),
-    "PySide2.QtGui.QIconEngine.isNull": (),
-    "PySide2.QtGui.QIconEngine.key": (),
-    "PySide2.QtGui.QIconEngine.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.pixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIconEngine.scaledPixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State', 'float'),
-    "PySide2.QtGui.QIconEngine.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QImage:
-# class PySide2.QtGui.QImage.Format:
-# class PySide2.QtGui.QImage.InvertMode:
-    "PySide2.QtGui.QImage.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QImage.Format'), ('PySide2.QtGui.QImage',), ('int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'str'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QImage.__copy__": (),
-    "PySide2.QtGui.QImage.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.allGray": (),
-    "PySide2.QtGui.QImage.alphaChannel": (),
-    "PySide2.QtGui.QImage.bitPlaneCount": (),
-    "PySide2.QtGui.QImage.bits": (),
-    "PySide2.QtGui.QImage.byteCount": (),
-    "PySide2.QtGui.QImage.bytesPerLine": (),
-    "PySide2.QtGui.QImage.cacheKey": (),
-    "PySide2.QtGui.QImage.color": ('int',),
-    "PySide2.QtGui.QImage.colorCount": (),
-    "PySide2.QtGui.QImage.colorSpace": (),
-    "PySide2.QtGui.QImage.colorTable": (),
-    "PySide2.QtGui.QImage.constBits": (),
-    "PySide2.QtGui.QImage.constScanLine": ('int',),
-    "PySide2.QtGui.QImage.convertTo": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.convertToFormat": [('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QImage.convertToFormat_helper": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToFormat_inplace": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertedToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QImage.createAlphaMask": ('PySide2.QtCore.Qt.ImageConversionFlags',),
-    "PySide2.QtGui.QImage.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QImage.createMaskFromColor": ('int', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QImage.depth": (),
-    "PySide2.QtGui.QImage.devType": (),
-    "PySide2.QtGui.QImage.devicePixelRatio": (),
-    "PySide2.QtGui.QImage.dotsPerMeterX": (),
-    "PySide2.QtGui.QImage.dotsPerMeterY": (),
-    "PySide2.QtGui.QImage.fill": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('int',)],
-    "PySide2.QtGui.QImage.format": (),
-    "PySide2.QtGui.QImage.fromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.hasAlphaChannel": (),
-    "PySide2.QtGui.QImage.height": (),
-    "PySide2.QtGui.QImage.invertPixels": ('PySide2.QtGui.QImage.InvertMode',),
-    "PySide2.QtGui.QImage.isGrayscale": (),
-    "PySide2.QtGui.QImage.isNull": (),
-    "PySide2.QtGui.QImage.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QImage.loadFromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QImage.mirrored": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_helper": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_inplace": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.offset": (),
-    "PySide2.QtGui.QImage.paintEngine": (),
-    "PySide2.QtGui.QImage.pixel": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelColor": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelFormat": (),
-    "PySide2.QtGui.QImage.pixelIndex": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.rect": (),
-    "PySide2.QtGui.QImage.reinterpretAsFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.rgbSwapped": (),
-    "PySide2.QtGui.QImage.rgbSwapped_helper": (),
-    "PySide2.QtGui.QImage.rgbSwapped_inplace": (),
-    "PySide2.QtGui.QImage.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QImage.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scanLine": ('int',),
-    "PySide2.QtGui.QImage.setAlphaChannel": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.setColor": ('int', 'int'),
-    "PySide2.QtGui.QImage.setColorCount": ('int',),
-    "PySide2.QtGui.QImage.setColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.setColorTable": ('typing.List[int]',),
-    "PySide2.QtGui.QImage.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QImage.setDotsPerMeterX": ('int',),
-    "PySide2.QtGui.QImage.setDotsPerMeterY": ('int',),
-    "PySide2.QtGui.QImage.setOffset": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QImage.setPixel": [('PySide2.QtCore.QPoint', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QImage.setPixelColor": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QImage.setText": ('str', 'str'),
-    "PySide2.QtGui.QImage.size": (),
-    "PySide2.QtGui.QImage.sizeInBytes": (),
-    "PySide2.QtGui.QImage.smoothScaled": ('int', 'int'),
-    "PySide2.QtGui.QImage.swap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.text": ('str',),
-    "PySide2.QtGui.QImage.textKeys": (),
-    "PySide2.QtGui.QImage.toImageFormat": ('PySide2.QtGui.QPixelFormat',),
-    "PySide2.QtGui.QImage.toPixelFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QImage.valid": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.width": (),
-# class PySide2.QtGui.QImageIOHandler:
-# class PySide2.QtGui.QImageIOHandler.ImageOption:
-# class PySide2.QtGui.QImageIOHandler.Transformation:
-# class PySide2.QtGui.QImageIOHandler.Transformations:
-    "PySide2.QtGui.QImageIOHandler.__init__": (),
-    "PySide2.QtGui.QImageIOHandler.canRead": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageNumber": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageRect": (),
-    "PySide2.QtGui.QImageIOHandler.device": (),
-    "PySide2.QtGui.QImageIOHandler.format": (),
-    "PySide2.QtGui.QImageIOHandler.imageCount": (),
-    "PySide2.QtGui.QImageIOHandler.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageIOHandler.jumpToNextImage": (),
-    "PySide2.QtGui.QImageIOHandler.loopCount": (),
-    "PySide2.QtGui.QImageIOHandler.name": (),
-    "PySide2.QtGui.QImageIOHandler.nextImageDelay": (),
-    "PySide2.QtGui.QImageIOHandler.option": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.read": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImageIOHandler.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageIOHandler.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageIOHandler.setOption": ('PySide2.QtGui.QImageIOHandler.ImageOption', 'typing.Any'),
-    "PySide2.QtGui.QImageIOHandler.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QImageReader:
-# class PySide2.QtGui.QImageReader.ImageReaderError:
-    "PySide2.QtGui.QImageReader.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageReader.autoDetectImageFormat": (),
-    "PySide2.QtGui.QImageReader.autoTransform": (),
-    "PySide2.QtGui.QImageReader.backgroundColor": (),
-    "PySide2.QtGui.QImageReader.canRead": (),
-    "PySide2.QtGui.QImageReader.clipRect": (),
-    "PySide2.QtGui.QImageReader.currentImageNumber": (),
-    "PySide2.QtGui.QImageReader.currentImageRect": (),
-    "PySide2.QtGui.QImageReader.decideFormatFromContent": (),
-    "PySide2.QtGui.QImageReader.device": (),
-    "PySide2.QtGui.QImageReader.error": (),
-    "PySide2.QtGui.QImageReader.errorString": (),
-    "PySide2.QtGui.QImageReader.fileName": (),
-    "PySide2.QtGui.QImageReader.format": (),
-    "PySide2.QtGui.QImageReader.gamma": (),
-    "PySide2.QtGui.QImageReader.imageCount": (),
-    "PySide2.QtGui.QImageReader.imageFormat": [(), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QImageReader.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageReader.jumpToNextImage": (),
-    "PySide2.QtGui.QImageReader.loopCount": (),
-    "PySide2.QtGui.QImageReader.nextImageDelay": (),
-    "PySide2.QtGui.QImageReader.quality": (),
-    "PySide2.QtGui.QImageReader.read": (),
-    "PySide2.QtGui.QImageReader.scaledClipRect": (),
-    "PySide2.QtGui.QImageReader.scaledSize": (),
-    "PySide2.QtGui.QImageReader.setAutoDetectImageFormat": ('bool',),
-    "PySide2.QtGui.QImageReader.setAutoTransform": ('bool',),
-    "PySide2.QtGui.QImageReader.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QImageReader.setClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setDecideFormatFromContent": ('bool',),
-    "PySide2.QtGui.QImageReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageReader.setFileName": ('str',),
-    "PySide2.QtGui.QImageReader.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.setGamma": ('float',),
-    "PySide2.QtGui.QImageReader.setQuality": ('int',),
-    "PySide2.QtGui.QImageReader.setScaledClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QImageReader.size": (),
-    "PySide2.QtGui.QImageReader.subType": (),
-    "PySide2.QtGui.QImageReader.supportedImageFormats": (),
-    "PySide2.QtGui.QImageReader.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageReader.supportedSubTypes": (),
-    "PySide2.QtGui.QImageReader.supportsAnimation": (),
-    "PySide2.QtGui.QImageReader.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageReader.text": ('str',),
-    "PySide2.QtGui.QImageReader.textKeys": (),
-    "PySide2.QtGui.QImageReader.transformation": (),
-# class PySide2.QtGui.QImageWriter:
-# class PySide2.QtGui.QImageWriter.ImageWriterError:
-    "PySide2.QtGui.QImageWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageWriter.canWrite": (),
-    "PySide2.QtGui.QImageWriter.compression": (),
-    "PySide2.QtGui.QImageWriter.description": (),
-    "PySide2.QtGui.QImageWriter.device": (),
-    "PySide2.QtGui.QImageWriter.error": (),
-    "PySide2.QtGui.QImageWriter.errorString": (),
-    "PySide2.QtGui.QImageWriter.fileName": (),
-    "PySide2.QtGui.QImageWriter.format": (),
-    "PySide2.QtGui.QImageWriter.gamma": (),
-    "PySide2.QtGui.QImageWriter.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.optimizedWrite": (),
-    "PySide2.QtGui.QImageWriter.progressiveScanWrite": (),
-    "PySide2.QtGui.QImageWriter.quality": (),
-    "PySide2.QtGui.QImageWriter.setCompression": ('int',),
-    "PySide2.QtGui.QImageWriter.setDescription": ('str',),
-    "PySide2.QtGui.QImageWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageWriter.setFileName": ('str',),
-    "PySide2.QtGui.QImageWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setGamma": ('float',),
-    "PySide2.QtGui.QImageWriter.setOptimizedWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setProgressiveScanWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setQuality": ('int',),
-    "PySide2.QtGui.QImageWriter.setSubType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setText": ('str', 'str'),
-    "PySide2.QtGui.QImageWriter.setTransformation": ('PySide2.QtGui.QImageIOHandler.Transformations',),
-    "PySide2.QtGui.QImageWriter.subType": (),
-    "PySide2.QtGui.QImageWriter.supportedImageFormats": (),
-    "PySide2.QtGui.QImageWriter.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageWriter.supportedSubTypes": (),
-    "PySide2.QtGui.QImageWriter.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageWriter.transformation": (),
-    "PySide2.QtGui.QImageWriter.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QInputEvent:
-    "PySide2.QtGui.QInputEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QInputEvent.modifiers": (),
-    "PySide2.QtGui.QInputEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtGui.QInputEvent.setTimestamp": ('int',),
-    "PySide2.QtGui.QInputEvent.timestamp": (),
-# class PySide2.QtGui.QInputMethod:
-# class PySide2.QtGui.QInputMethod.Action:
-    "PySide2.QtGui.QInputMethod.anchorRectangle": (),
-    "PySide2.QtGui.QInputMethod.commit": (),
-    "PySide2.QtGui.QInputMethod.cursorRectangle": (),
-    "PySide2.QtGui.QInputMethod.hide": (),
-    "PySide2.QtGui.QInputMethod.inputDirection": (),
-    "PySide2.QtGui.QInputMethod.inputItemClipRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemTransform": (),
-    "PySide2.QtGui.QInputMethod.invokeAction": ('PySide2.QtGui.QInputMethod.Action', 'int'),
-    "PySide2.QtGui.QInputMethod.isAnimating": (),
-    "PySide2.QtGui.QInputMethod.isVisible": (),
-    "PySide2.QtGui.QInputMethod.keyboardRectangle": (),
-    "PySide2.QtGui.QInputMethod.locale": (),
-    "PySide2.QtGui.QInputMethod.queryFocusObject": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethod.reset": (),
-    "PySide2.QtGui.QInputMethod.setInputItemRectangle": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QInputMethod.setInputItemTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QInputMethod.setVisible": ('bool',),
-    "PySide2.QtGui.QInputMethod.show": (),
-    "PySide2.QtGui.QInputMethod.update": ('PySide2.QtCore.Qt.InputMethodQueries',),
-# class PySide2.QtGui.QInputMethodEvent:
-# class PySide2.QtGui.QInputMethodEvent.Attribute:
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__init__": [('PySide2.QtGui.QInputMethodEvent.Attribute',), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int'), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int', 'typing.Any')],
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__copy__": (),
-# class PySide2.QtGui.QInputMethodEvent.AttributeType:
-    "PySide2.QtGui.QInputMethodEvent.__init__": [(), ('PySide2.QtGui.QInputMethodEvent',), ('str', 'typing.Sequence[PySide2.QtGui.QInputMethodEvent.Attribute]')],
-    "PySide2.QtGui.QInputMethodEvent.attributes": (),
-    "PySide2.QtGui.QInputMethodEvent.commitString": (),
-    "PySide2.QtGui.QInputMethodEvent.preeditString": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementLength": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementStart": (),
-    "PySide2.QtGui.QInputMethodEvent.setCommitString": ('str', 'int', 'int'),
-# class PySide2.QtGui.QInputMethodQueryEvent:
-    "PySide2.QtGui.QInputMethodQueryEvent.__init__": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtGui.QInputMethodQueryEvent.queries": (),
-    "PySide2.QtGui.QInputMethodQueryEvent.setValue": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethodQueryEvent.value": ('PySide2.QtCore.Qt.InputMethodQuery',),
-# class PySide2.QtGui.QIntValidator:
-    "PySide2.QtGui.QIntValidator.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QIntValidator.bottom": (),
-    "PySide2.QtGui.QIntValidator.fixup": ('str',),
-    "PySide2.QtGui.QIntValidator.setBottom": ('int',),
-    "PySide2.QtGui.QIntValidator.setRange": ('int', 'int'),
-    "PySide2.QtGui.QIntValidator.setTop": ('int',),
-    "PySide2.QtGui.QIntValidator.top": (),
-    "PySide2.QtGui.QIntValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QKeyEvent:
-    "PySide2.QtGui.QKeyEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'int', 'int', 'str', 'bool', 'int'), ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtGui.QKeyEvent.count": (),
-    "PySide2.QtGui.QKeyEvent.isAutoRepeat": (),
-    "PySide2.QtGui.QKeyEvent.key": (),
-    "PySide2.QtGui.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeyEvent.modifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeModifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeScanCode": (),
-    "PySide2.QtGui.QKeyEvent.nativeVirtualKey": (),
-    "PySide2.QtGui.QKeyEvent.text": (),
-# class PySide2.QtGui.QKeySequence:
-# class PySide2.QtGui.QKeySequence.SequenceFormat:
-# class PySide2.QtGui.QKeySequence.SequenceMatch:
-# class PySide2.QtGui.QKeySequence.StandardKey:
-    "PySide2.QtGui.QKeySequence.__init__": [(), ('PySide2.QtGui.QKeySequence',), ('PySide2.QtGui.QKeySequence.StandardKey',), ('int', 'int', 'int', 'int'), ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat')],
-    "PySide2.QtGui.QKeySequence.__copy__": (),
-    "PySide2.QtGui.QKeySequence.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.__reduce__": (),
-    "PySide2.QtGui.QKeySequence.__repr__": (),
-    "PySide2.QtGui.QKeySequence.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.count": (),
-    "PySide2.QtGui.QKeySequence.fromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.isEmpty": (),
-    "PySide2.QtGui.QKeySequence.keyBindings": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeySequence.listFromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.listToString": ('typing.Sequence[PySide2.QtGui.QKeySequence]', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.matches": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.mnemonic": ('str',),
-    "PySide2.QtGui.QKeySequence.swap": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.toString": ('PySide2.QtGui.QKeySequence.SequenceFormat',),
-# class PySide2.QtGui.QLinearGradient:
-    "PySide2.QtGui.QLinearGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QLinearGradient',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QLinearGradient.__copy__": (),
-    "PySide2.QtGui.QLinearGradient.finalStop": (),
-    "PySide2.QtGui.QLinearGradient.setFinalStop": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.setStart": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.start": (),
-# class PySide2.QtGui.QMatrix:
-    "PySide2.QtGui.QMatrix.__init__": [(), ('PySide2.QtGui.QMatrix',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix.__copy__": (),
-    "PySide2.QtGui.QMatrix.__imul__": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QMatrix.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix',)],
-    "PySide2.QtGui.QMatrix.__reduce__": (),
-    "PySide2.QtGui.QMatrix.__repr__": (),
-    "PySide2.QtGui.QMatrix.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.determinant": (),
-    "PySide2.QtGui.QMatrix.dx": (),
-    "PySide2.QtGui.QMatrix.dy": (),
-    "PySide2.QtGui.QMatrix.inverted": (),
-    "PySide2.QtGui.QMatrix.isIdentity": (),
-    "PySide2.QtGui.QMatrix.isInvertible": (),
-    "PySide2.QtGui.QMatrix.m11": (),
-    "PySide2.QtGui.QMatrix.m12": (),
-    "PySide2.QtGui.QMatrix.m21": (),
-    "PySide2.QtGui.QMatrix.m22": (),
-    "PySide2.QtGui.QMatrix.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float'), ('int', 'int')],
-    "PySide2.QtGui.QMatrix.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QMatrix.reset": (),
-    "PySide2.QtGui.QMatrix.rotate": ('float',),
-    "PySide2.QtGui.QMatrix.scale": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix.shear": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.translate": ('float', 'float'),
-# class PySide2.QtGui.QMatrix2x2:
-    "PySide2.QtGui.QMatrix2x2.__init__": [(), ('PySide2.QtGui.QMatrix2x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x2.__copy__": (),
-    "PySide2.QtGui.QMatrix2x2.__iadd__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x2.__isub__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x2.__repr__": (),
-    "PySide2.QtGui.QMatrix2x2.data": (),
-    "PySide2.QtGui.QMatrix2x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.transposed": (),
-# class PySide2.QtGui.QMatrix2x3:
-    "PySide2.QtGui.QMatrix2x3.__init__": [(), ('PySide2.QtGui.QMatrix2x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x3.__copy__": (),
-    "PySide2.QtGui.QMatrix2x3.__iadd__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x3.__isub__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x3.__repr__": (),
-    "PySide2.QtGui.QMatrix2x3.data": (),
-    "PySide2.QtGui.QMatrix2x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.transposed": (),
-# class PySide2.QtGui.QMatrix2x4:
-    "PySide2.QtGui.QMatrix2x4.__init__": [(), ('PySide2.QtGui.QMatrix2x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x4.__copy__": (),
-    "PySide2.QtGui.QMatrix2x4.__iadd__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x4.__isub__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x4.__repr__": (),
-    "PySide2.QtGui.QMatrix2x4.data": (),
-    "PySide2.QtGui.QMatrix2x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.transposed": (),
-# class PySide2.QtGui.QMatrix3x2:
-    "PySide2.QtGui.QMatrix3x2.__init__": [(), ('PySide2.QtGui.QMatrix3x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x2.__copy__": (),
-    "PySide2.QtGui.QMatrix3x2.__iadd__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x2.__isub__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x2.__repr__": (),
-    "PySide2.QtGui.QMatrix3x2.data": (),
-    "PySide2.QtGui.QMatrix3x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.transposed": (),
-# class PySide2.QtGui.QMatrix3x3:
-    "PySide2.QtGui.QMatrix3x3.__init__": [(), ('PySide2.QtGui.QMatrix3x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x3.__copy__": (),
-    "PySide2.QtGui.QMatrix3x3.__iadd__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x3.__isub__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x3.__repr__": (),
-    "PySide2.QtGui.QMatrix3x3.data": (),
-    "PySide2.QtGui.QMatrix3x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.transposed": (),
-# class PySide2.QtGui.QMatrix3x4:
-    "PySide2.QtGui.QMatrix3x4.__init__": [(), ('PySide2.QtGui.QMatrix3x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x4.__copy__": (),
-    "PySide2.QtGui.QMatrix3x4.__iadd__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x4.__isub__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x4.__repr__": (),
-    "PySide2.QtGui.QMatrix3x4.data": (),
-    "PySide2.QtGui.QMatrix3x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.transposed": (),
-# class PySide2.QtGui.QMatrix4x2:
-    "PySide2.QtGui.QMatrix4x2.__init__": [(), ('PySide2.QtGui.QMatrix4x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x2.__copy__": (),
-    "PySide2.QtGui.QMatrix4x2.__iadd__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x2.__isub__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x2.__repr__": (),
-    "PySide2.QtGui.QMatrix4x2.data": (),
-    "PySide2.QtGui.QMatrix4x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.transposed": (),
-# class PySide2.QtGui.QMatrix4x3:
-    "PySide2.QtGui.QMatrix4x3.__init__": [(), ('PySide2.QtGui.QMatrix4x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x3.__copy__": (),
-    "PySide2.QtGui.QMatrix4x3.__iadd__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x3.__isub__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x3.__repr__": (),
-    "PySide2.QtGui.QMatrix4x3.data": (),
-    "PySide2.QtGui.QMatrix4x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.transposed": (),
-# class PySide2.QtGui.QMatrix4x4:
-    "PySide2.QtGui.QMatrix4x4.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtGui.QMatrix4x4.__add__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__copy__": (),
-    "PySide2.QtGui.QMatrix4x4.__dummy": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QMatrix4x4.__iadd__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__imul__": [('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__isub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__mul__": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__neg__": (),
-    "PySide2.QtGui.QMatrix4x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x4.__repr__": (),
-    "PySide2.QtGui.QMatrix4x4.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__sub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.column": ('int',),
-    "PySide2.QtGui.QMatrix4x4.copyDataTo": (),
-    "PySide2.QtGui.QMatrix4x4.data": (),
-    "PySide2.QtGui.QMatrix4x4.determinant": (),
-    "PySide2.QtGui.QMatrix4x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x4.flipCoordinates": (),
-    "PySide2.QtGui.QMatrix4x4.frustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.inverted": (),
-    "PySide2.QtGui.QMatrix4x4.isAffine": (),
-    "PySide2.QtGui.QMatrix4x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.lookAt": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QMatrix4x4.map": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',)],
-    "PySide2.QtGui.QMatrix4x4.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix4x4.mapVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QMatrix4x4.normalMatrix": (),
-    "PySide2.QtGui.QMatrix4x4.optimize": (),
-    "PySide2.QtGui.QMatrix4x4.ortho": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.perspective": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.rotate": [('PySide2.QtGui.QQuaternion',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.row": ('int',),
-    "PySide2.QtGui.QMatrix4x4.scale": [('PySide2.QtGui.QVector3D',), ('float',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.setColumn": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setRow": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.toAffine": (),
-    "PySide2.QtGui.QMatrix4x4.toTransform": [(), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.translate": [('PySide2.QtGui.QVector3D',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.transposed": (),
-    "PySide2.QtGui.QMatrix4x4.viewport": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-# class PySide2.QtGui.QMouseEvent:
-    "PySide2.QtGui.QMouseEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QMouseEvent.button": (),
-    "PySide2.QtGui.QMouseEvent.buttons": (),
-    "PySide2.QtGui.QMouseEvent.flags": (),
-    "PySide2.QtGui.QMouseEvent.globalPos": (),
-    "PySide2.QtGui.QMouseEvent.globalX": (),
-    "PySide2.QtGui.QMouseEvent.global""Y": (),
-    "PySide2.QtGui.QMouseEvent.localPos": (),
-    "PySide2.QtGui.QMouseEvent.pos": (),
-    "PySide2.QtGui.QMouseEvent.screenPos": (),
-    "PySide2.QtGui.QMouseEvent.setLocalPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QMouseEvent.source": (),
-    "PySide2.QtGui.QMouseEvent.windowPos": (),
-    "PySide2.QtGui.QMouseEvent.x": (),
-    "PySide2.QtGui.QMouseEvent.y": (),
-# class PySide2.QtGui.QMoveEvent:
-    "PySide2.QtGui.QMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QMoveEvent.oldPos": (),
-    "PySide2.QtGui.QMoveEvent.pos": (),
-# class PySide2.QtGui.QMovie:
-# class PySide2.QtGui.QMovie.CacheMode:
-# class PySide2.QtGui.QMovie.MovieState:
-    "PySide2.QtGui.QMovie.__init__": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QMovie.backgroundColor": (),
-    "PySide2.QtGui.QMovie.cacheMode": (),
-    "PySide2.QtGui.QMovie.currentFrameNumber": (),
-    "PySide2.QtGui.QMovie.currentImage": (),
-    "PySide2.QtGui.QMovie.currentPixmap": (),
-    "PySide2.QtGui.QMovie.device": (),
-    "PySide2.QtGui.QMovie.fileName": (),
-    "PySide2.QtGui.QMovie.format": (),
-    "PySide2.QtGui.QMovie.frameCount": (),
-    "PySide2.QtGui.QMovie.frameRect": (),
-    "PySide2.QtGui.QMovie.isValid": (),
-    "PySide2.QtGui.QMovie.jumpToFrame": ('int',),
-    "PySide2.QtGui.QMovie.jumpToNextFrame": (),
-    "PySide2.QtGui.QMovie.lastError": (),
-    "PySide2.QtGui.QMovie.lastErrorString": (),
-    "PySide2.QtGui.QMovie.loopCount": (),
-    "PySide2.QtGui.QMovie.nextFrameDelay": (),
-    "PySide2.QtGui.QMovie.scaledSize": (),
-    "PySide2.QtGui.QMovie.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QMovie.setCacheMode": ('PySide2.QtGui.QMovie.CacheMode',),
-    "PySide2.QtGui.QMovie.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QMovie.setFileName": ('str',),
-    "PySide2.QtGui.QMovie.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QMovie.setPaused": ('bool',),
-    "PySide2.QtGui.QMovie.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QMovie.setSpeed": ('int',),
-    "PySide2.QtGui.QMovie.speed": (),
-    "PySide2.QtGui.QMovie.start": (),
-    "PySide2.QtGui.QMovie.state": (),
-    "PySide2.QtGui.QMovie.stop": (),
-    "PySide2.QtGui.QMovie.supportedFormats": (),
-# class PySide2.QtGui.QNativeGestureEvent:
-    "PySide2.QtGui.QNativeGestureEvent.__init__": [('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int'), ('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int')],
-    "PySide2.QtGui.QNativeGestureEvent.device": (),
-    "PySide2.QtGui.QNativeGestureEvent.gestureType": (),
-    "PySide2.QtGui.QNativeGestureEvent.globalPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.localPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.pos": (),
-    "PySide2.QtGui.QNativeGestureEvent.screenPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.value": (),
-    "PySide2.QtGui.QNativeGestureEvent.windowPos": (),
-# class PySide2.QtGui.QOffscreenSurface:
-    "PySide2.QtGui.QOffscreenSurface.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QOffscreenSurface.create": (),
-    "PySide2.QtGui.QOffscreenSurface.destroy": (),
-    "PySide2.QtGui.QOffscreenSurface.format": (),
-    "PySide2.QtGui.QOffscreenSurface.isValid": (),
-    "PySide2.QtGui.QOffscreenSurface.nativeHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.requestedFormat": (),
-    "PySide2.QtGui.QOffscreenSurface.screen": (),
-    "PySide2.QtGui.QOffscreenSurface.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOffscreenSurface.setNativeHandle": ('int',),
-    "PySide2.QtGui.QOffscreenSurface.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOffscreenSurface.size": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceType": (),
-# class PySide2.QtGui.QOpenGLBuffer:
-# class PySide2.QtGui.QOpenGLBuffer.Access:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlag:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags:
-# class PySide2.QtGui.QOpenGLBuffer.Type:
-# class PySide2.QtGui.QOpenGLBuffer.UsagePattern:
-    "PySide2.QtGui.QOpenGLBuffer.__init__": [(), ('PySide2.QtGui.QOpenGLBuffer',), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QOpenGLBuffer.bind": (),
-    "PySide2.QtGui.QOpenGLBuffer.bufferId": (),
-    "PySide2.QtGui.QOpenGLBuffer.create": (),
-    "PySide2.QtGui.QOpenGLBuffer.destroy": (),
-    "PySide2.QtGui.QOpenGLBuffer.isCreated": (),
-    "PySide2.QtGui.QOpenGLBuffer.map": ('PySide2.QtGui.QOpenGLBuffer.Access',),
-    "PySide2.QtGui.QOpenGLBuffer.mapRange": ('int', 'int', 'PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags'),
-    "PySide2.QtGui.QOpenGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLBuffer.release": [(), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.setUsagePattern": ('PySide2.QtGui.QOpenGLBuffer.UsagePattern',),
-    "PySide2.QtGui.QOpenGLBuffer.size": (),
-    "PySide2.QtGui.QOpenGLBuffer.type": (),
-    "PySide2.QtGui.QOpenGLBuffer.unmap": (),
-    "PySide2.QtGui.QOpenGLBuffer.usagePattern": (),
-    "PySide2.QtGui.QOpenGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtGui.QOpenGLContext:
-# class PySide2.QtGui.QOpenGLContext.OpenGLModuleType:
-    "PySide2.QtGui.QOpenGLContext.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLContext.areSharing": ('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLContext.create": (),
-    "PySide2.QtGui.QOpenGLContext.currentContext": (),
-    "PySide2.QtGui.QOpenGLContext.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLContext.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLContext.extensions": (),
-    "PySide2.QtGui.QOpenGLContext.extraFunctions": (),
-    "PySide2.QtGui.QOpenGLContext.format": (),
-    "PySide2.QtGui.QOpenGLContext.functions": (),
-    "PySide2.QtGui.QOpenGLContext.globalShareContext": (),
-    "PySide2.QtGui.QOpenGLContext.hasExtension": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QOpenGLContext.isOpenGLES": (),
-    "PySide2.QtGui.QOpenGLContext.isValid": (),
-    "PySide2.QtGui.QOpenGLContext.makeCurrent": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.nativeHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleType": (),
-    "PySide2.QtGui.QOpenGLContext.screen": (),
-    "PySide2.QtGui.QOpenGLContext.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOpenGLContext.setNativeHandle": ('typing.Any',),
-    "PySide2.QtGui.QOpenGLContext.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOpenGLContext.setShareContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLContext.shareContext": (),
-    "PySide2.QtGui.QOpenGLContext.shareGroup": (),
-    "PySide2.QtGui.QOpenGLContext.supportsThreadedOpenGL": (),
-    "PySide2.QtGui.QOpenGLContext.surface": (),
-    "PySide2.QtGui.QOpenGLContext.swapBuffers": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.versionFunctions": ('PySide2.QtGui.QOpenGLVersionProfile',),
-# class PySide2.QtGui.QOpenGLContextGroup:
-    "PySide2.QtGui.QOpenGLContextGroup.currentContextGroup": (),
-    "PySide2.QtGui.QOpenGLContextGroup.shares": (),
-# class PySide2.QtGui.QOpenGLDebugLogger:
-# class PySide2.QtGui.QOpenGLDebugLogger.LoggingMode:
-    "PySide2.QtGui.QOpenGLDebugLogger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLDebugLogger.disableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.enableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.initialize": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.isLogging": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.logMessage": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggedMessages": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggingMode": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.maximumMessageLength": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.popGroup": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.pushGroup": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Source'),
-    "PySide2.QtGui.QOpenGLDebugLogger.startLogging": ('PySide2.QtGui.QOpenGLDebugLogger.LoggingMode',),
-    "PySide2.QtGui.QOpenGLDebugLogger.stopLogging": (),
-# class PySide2.QtGui.QOpenGLDebugMessage:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severities:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severity:
-# class PySide2.QtGui.QOpenGLDebugMessage.Source:
-# class PySide2.QtGui.QOpenGLDebugMessage.Sources:
-# class PySide2.QtGui.QOpenGLDebugMessage.Type:
-# class PySide2.QtGui.QOpenGLDebugMessage.Types:
-    "PySide2.QtGui.QOpenGLDebugMessage.__init__": [(), ('PySide2.QtGui.QOpenGLDebugMessage',)],
-    "PySide2.QtGui.QOpenGLDebugMessage.__copy__": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.createApplicationMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.createThirdPartyMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.id": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.message": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.severity": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.source": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.swap": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugMessage.type": (),
-# class PySide2.QtGui.QOpenGLExtraFunctions:
-    "PySide2.QtGui.QOpenGLExtraFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLExtraFunctions.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginQuery": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindSampler": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendBarrier": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageControl": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDisablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEnablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEndQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformBlockiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformsiv": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetBufferParameteri64v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFramebufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetGraphicsResetStatus": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64i_v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64v": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetIntegeri_v": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInternalformativ": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetMultisamplefv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramBinary": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramInterfaceiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramPipelineiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceiv": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryObjectuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetStringi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameterfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformfv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformuiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateSubFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsSampler": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrier": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMinSampleShading": ('float',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPopDebugGroup": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPrimitiveBoundingBox": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSampleMaski": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1ui": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUnmapBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glValidateProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4iv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4uiv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexBindingDivisor": ('int', 'int'),
-# class PySide2.QtGui.QOpenGLFramebufferObject:
-# class PySide2.QtGui.QOpenGLFramebufferObject.Attachment:
-# class PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy:
-    "PySide2.QtGui.QOpenGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.addColorAttachment": [('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bind": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bindDefault": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.blitFramebuffer": [('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtGui.QOpenGLFramebufferObject', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.format": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.handle": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.height": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isBound": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isValid": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.release": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObject.size": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.sizes": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.takeTexture": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLFramebufferObject.texture": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.textures": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.toImage": [(), ('bool',), ('bool', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.width": (),
-# class PySide2.QtGui.QOpenGLFramebufferObjectFormat:
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtGui.QOpenGLFramebufferObjectFormat',)],
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtGui.QOpenGLFunctions:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeature:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeatures:
-    "PySide2.QtGui.QOpenGLFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLFunctions.glActiveTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glAttachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindBuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindTexture": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquation": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFunc": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClear": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glClearDepthf": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearStencil": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompileShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateProgram": (),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCullFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthFunc": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthRangef": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glDetachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDisable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glEnable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glFinish": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFlush": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFrontFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGenBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenerateMipmap": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttachedShaders": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetBufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetError": (),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFloatv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFramebufferAttachmentParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetIntegerv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetProgramiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetRenderbufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderPrecisionFormat": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetString": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glHint": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glIsBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsEnabled": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsFramebuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsRenderbuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glLineWidth": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glLinkProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glPixelStorei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glReleaseShaderCompiler": (),
-    "PySide2.QtGui.QOpenGLFunctions.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glShaderBinary": ('int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1i": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUseProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glValidateProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.hasOpenGLFeature": ('PySide2.QtGui.QOpenGLFunctions.OpenGLFeature',),
-    "PySide2.QtGui.QOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QOpenGLFunctions.openGLFeatures": (),
-# class PySide2.QtGui.QOpenGLPixelTransferOptions:
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__init__": [(), ('PySide2.QtGui.QOpenGLPixelTransferOptions',)],
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__copy__": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.alignment": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.imageHeight": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isLeastSignificantBitFirst": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isSwapBytesEnabled": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.rowLength": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setAlignment": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setImageHeight": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setLeastSignificantByteFirst": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setRowLength": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipImages": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipPixels": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipRows": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSwapBytesEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipImages": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipPixels": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipRows": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.swap": ('PySide2.QtGui.QOpenGLPixelTransferOptions',),
-# class PySide2.QtGui.QOpenGLShader:
-# class PySide2.QtGui.QOpenGLShader.ShaderType:
-# class PySide2.QtGui.QOpenGLShader.ShaderTypeBit:
-    "PySide2.QtGui.QOpenGLShader.__init__": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QOpenGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShader.compileSourceFile": ('str',),
-    "PySide2.QtGui.QOpenGLShader.hasOpenGLShaders": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLShader.isCompiled": (),
-    "PySide2.QtGui.QOpenGLShader.log": (),
-    "PySide2.QtGui.QOpenGLShader.shaderId": (),
-    "PySide2.QtGui.QOpenGLShader.shaderType": (),
-    "PySide2.QtGui.QOpenGLShader.sourceCode": (),
-# class PySide2.QtGui.QOpenGLShaderProgram:
-    "PySide2.QtGui.QOpenGLShaderProgram.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.bind": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.create": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultInnerTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultOuterTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLShaderProgram.isLinked": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.link": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.log": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.patchVertexCount": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.programId": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.release": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeArray": [('int', 'int', 'int', 'int', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'int', 'int', 'int', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultInnerTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultOuterTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setPatchVertexCount": ('int',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple]'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple]')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1f": [('int', 'float'), ('str', 'float')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1i": [('int', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValueArray": [('int', 'shibokensupport.typing27.Sequence', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'shibokensupport.typing27.Sequence', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.shaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtGui.QOpenGLTexture:
-# class PySide2.QtGui.QOpenGLTexture.BindingTarget:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonFunction:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonMode:
-# class PySide2.QtGui.QOpenGLTexture.CoordinateDirection:
-# class PySide2.QtGui.QOpenGLTexture.CubeMapFace:
-# class PySide2.QtGui.QOpenGLTexture.DepthStencilMode:
-# class PySide2.QtGui.QOpenGLTexture.Feature:
-# class PySide2.QtGui.QOpenGLTexture.Features:
-# class PySide2.QtGui.QOpenGLTexture.Filter:
-# class PySide2.QtGui.QOpenGLTexture.MipMapGeneration:
-# class PySide2.QtGui.QOpenGLTexture.PixelFormat:
-# class PySide2.QtGui.QOpenGLTexture.PixelType:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleComponent:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleValue:
-# class PySide2.QtGui.QOpenGLTexture.Target:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormat:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormatClass:
-# class PySide2.QtGui.QOpenGLTexture.TextureUnitReset:
-# class PySide2.QtGui.QOpenGLTexture.WrapMode:
-    "PySide2.QtGui.QOpenGLTexture.__init__": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.Target',)],
-    "PySide2.QtGui.QOpenGLTexture.allocateStorage": [(), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType')],
-    "PySide2.QtGui.QOpenGLTexture.bind": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.borderColor": (),
-    "PySide2.QtGui.QOpenGLTexture.boundTextureId": [('PySide2.QtGui.QOpenGLTexture.BindingTarget',), ('int', 'PySide2.QtGui.QOpenGLTexture.BindingTarget')],
-    "PySide2.QtGui.QOpenGLTexture.comparisonFunction": (),
-    "PySide2.QtGui.QOpenGLTexture.comparisonMode": (),
-    "PySide2.QtGui.QOpenGLTexture.create": (),
-    "PySide2.QtGui.QOpenGLTexture.createTextureView": ('PySide2.QtGui.QOpenGLTexture.Target', 'PySide2.QtGui.QOpenGLTexture.TextureFormat', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.depth": (),
-    "PySide2.QtGui.QOpenGLTexture.depthStencilMode": (),
-    "PySide2.QtGui.QOpenGLTexture.destroy": (),
-    "PySide2.QtGui.QOpenGLTexture.faces": (),
-    "PySide2.QtGui.QOpenGLTexture.format": (),
-    "PySide2.QtGui.QOpenGLTexture.generateMipMaps": [(), ('int', 'bool')],
-    "PySide2.QtGui.QOpenGLTexture.hasFeature": ('PySide2.QtGui.QOpenGLTexture.Feature',),
-    "PySide2.QtGui.QOpenGLTexture.height": (),
-    "PySide2.QtGui.QOpenGLTexture.isAutoMipMapGenerationEnabled": (),
-    "PySide2.QtGui.QOpenGLTexture.isBound": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLTexture.isCreated": (),
-    "PySide2.QtGui.QOpenGLTexture.isFixedSamplePositions": (),
-    "PySide2.QtGui.QOpenGLTexture.isStorageAllocated": (),
-    "PySide2.QtGui.QOpenGLTexture.isTextureView": (),
-    "PySide2.QtGui.QOpenGLTexture.layers": (),
-    "PySide2.QtGui.QOpenGLTexture.levelOfDetailRange": (),
-    "PySide2.QtGui.QOpenGLTexture.levelofDetailBias": (),
-    "PySide2.QtGui.QOpenGLTexture.magnificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumAnisotropy": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumMipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.minMagFilters": (),
-    "PySide2.QtGui.QOpenGLTexture.minificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.minimumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.mipBaseLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevelRange": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.mipMaxLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.release": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.samples": (),
-    "PySide2.QtGui.QOpenGLTexture.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setBorderColor": [('PySide2.QtGui.QColor',), ('float', 'float', 'float', 'float'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLTexture.setComparisonFunction": ('PySide2.QtGui.QOpenGLTexture.ComparisonFunction',),
-    "PySide2.QtGui.QOpenGLTexture.setComparisonMode": ('PySide2.QtGui.QOpenGLTexture.ComparisonMode',),
-    "PySide2.QtGui.QOpenGLTexture.setCompressedData": [('int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setData": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setDepthStencilMode": ('PySide2.QtGui.QOpenGLTexture.DepthStencilMode',),
-    "PySide2.QtGui.QOpenGLTexture.setFixedSamplePositions": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.QtGui.QOpenGLTexture.setLayers": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setLevelOfDetailRange": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLTexture.setLevelofDetailBias": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMagnificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMinMagFilters": ('PySide2.QtGui.QOpenGLTexture.Filter', 'PySide2.QtGui.QOpenGLTexture.Filter'),
-    "PySide2.QtGui.QOpenGLTexture.setMinificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMinimumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMipBaseLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevelRange": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevels": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipMaxLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setSwizzleMask": [('PySide2.QtGui.QOpenGLTexture.SwizzleComponent', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue'), ('PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue')],
-    "PySide2.QtGui.QOpenGLTexture.setWrapMode": [('PySide2.QtGui.QOpenGLTexture.CoordinateDirection', 'PySide2.QtGui.QOpenGLTexture.WrapMode'), ('PySide2.QtGui.QOpenGLTexture.WrapMode',)],
-    "PySide2.QtGui.QOpenGLTexture.swizzleMask": ('PySide2.QtGui.QOpenGLTexture.SwizzleComponent',),
-    "PySide2.QtGui.QOpenGLTexture.target": (),
-    "PySide2.QtGui.QOpenGLTexture.textureId": (),
-    "PySide2.QtGui.QOpenGLTexture.width": (),
-    "PySide2.QtGui.QOpenGLTexture.wrapMode": ('PySide2.QtGui.QOpenGLTexture.CoordinateDirection',),
-# class PySide2.QtGui.QOpenGLTextureBlitter:
-# class PySide2.QtGui.QOpenGLTextureBlitter.Origin:
-    "PySide2.QtGui.QOpenGLTextureBlitter.__init__": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.bind": ('int',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.blit": [('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin')],
-    "PySide2.QtGui.QOpenGLTextureBlitter.create": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.destroy": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.isCreated": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.release": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setOpacity": ('float',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setRedBlueSwizzle": ('bool',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.sourceTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin'),
-    "PySide2.QtGui.QOpenGLTextureBlitter.supportsExternalOESTarget": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.targetTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect'),
-# class PySide2.QtGui.QOpenGLTimeMonitor:
-    "PySide2.QtGui.QOpenGLTimeMonitor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.create": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.destroy": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.objectIds": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.recordSample": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.reset": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.sampleCount": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.setSampleCount": ('int',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForIntervals": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForSamples": (),
-# class PySide2.QtGui.QOpenGLTimerQuery:
-    "PySide2.QtGui.QOpenGLTimerQuery.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimerQuery.begin": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.create": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.destroy": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.end": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.objectId": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.recordTimestamp": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForResult": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForTimestamp": (),
-# class PySide2.QtGui.QOpenGLVersionProfile:
-    "PySide2.QtGui.QOpenGLVersionProfile.__init__": [(), ('PySide2.QtGui.QOpenGLVersionProfile',), ('PySide2.QtGui.QSurfaceFormat',)],
-    "PySide2.QtGui.QOpenGLVersionProfile.__copy__": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.hasProfiles": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isLegacyVersion": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isValid": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.profile": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QOpenGLVersionProfile.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLVersionProfile.version": (),
-# class PySide2.QtGui.QOpenGLVertexArrayObject:
-# class PySide2.QtGui.QOpenGLVertexArrayObject.Binder:
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.__init__": ('PySide2.QtGui.QOpenGLVertexArrayObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.rebind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.release": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.bind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.create": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.destroy": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.isCreated": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.objectId": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.release": (),
-# class PySide2.QtGui.QOpenGLWindow:
-# class PySide2.QtGui.QOpenGLWindow.UpdateBehavior:
-    "PySide2.QtGui.QOpenGLWindow.__init__": [('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow'), ('PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtGui.QOpenGLWindow.context": (),
-    "PySide2.QtGui.QOpenGLWindow.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLWindow.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.grabFramebuffer": (),
-    "PySide2.QtGui.QOpenGLWindow.initializeGL": (),
-    "PySide2.QtGui.QOpenGLWindow.isValid": (),
-    "PySide2.QtGui.QOpenGLWindow.makeCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QOpenGLWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QOpenGLWindow.paintGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintOverGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintUnderGL": (),
-    "PySide2.QtGui.QOpenGLWindow.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QOpenGLWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QOpenGLWindow.resizeGL": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLWindow.shareContext": (),
-    "PySide2.QtGui.QOpenGLWindow.updateBehavior": (),
-# class PySide2.QtGui.QPageLayout:
-# class PySide2.QtGui.QPageLayout.Mode:
-# class PySide2.QtGui.QPageLayout.Orientation:
-# class PySide2.QtGui.QPageLayout.Unit:
-    "PySide2.QtGui.QPageLayout.__init__": [(), ('PySide2.QtGui.QPageLayout',), ('PySide2.QtGui.QPageSize', 'PySide2.QtGui.QPageLayout.Orientation', 'PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit', 'PySide2.QtCore.QMarginsF')],
-    "PySide2.QtGui.QPageLayout.__copy__": (),
-    "PySide2.QtGui.QPageLayout.fullRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.fullRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.fullRectPoints": (),
-    "PySide2.QtGui.QPageLayout.isEquivalentTo": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.isValid": (),
-    "PySide2.QtGui.QPageLayout.margins": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.marginsPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.marginsPoints": (),
-    "PySide2.QtGui.QPageLayout.maximumMargins": (),
-    "PySide2.QtGui.QPageLayout.minimumMargins": (),
-    "PySide2.QtGui.QPageLayout.mode": (),
-    "PySide2.QtGui.QPageLayout.orientation": (),
-    "PySide2.QtGui.QPageLayout.pageSize": (),
-    "PySide2.QtGui.QPageLayout.paintRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.paintRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.paintRectPoints": (),
-    "PySide2.QtGui.QPageLayout.setBottomMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setLeftMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMinimumMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMode": ('PySide2.QtGui.QPageLayout.Mode',),
-    "PySide2.QtGui.QPageLayout.setOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPageLayout.setPageSize": ('PySide2.QtGui.QPageSize', 'PySide2.QtCore.QMarginsF'),
-    "PySide2.QtGui.QPageLayout.setRightMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setTopMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setUnits": ('PySide2.QtGui.QPageLayout.Unit',),
-    "PySide2.QtGui.QPageLayout.swap": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.units": (),
-# class PySide2.QtGui.QPageSize:
-# class PySide2.QtGui.QPageSize.PageSizeId:
-# class PySide2.QtGui.QPageSize.SizeMatchPolicy:
-# class PySide2.QtGui.QPageSize.Unit:
-    "PySide2.QtGui.QPageSize.__init__": [(), ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.__copy__": (),
-    "PySide2.QtGui.QPageSize.definitionSize": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.definitionUnits": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.id": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('int',)],
-    "PySide2.QtGui.QPageSize.isEquivalentTo": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.isValid": (),
-    "PySide2.QtGui.QPageSize.key": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.name": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.rect": ('PySide2.QtGui.QPageSize.Unit',),
-    "PySide2.QtGui.QPageSize.rectPixels": ('int',),
-    "PySide2.QtGui.QPageSize.rectPoints": (),
-    "PySide2.QtGui.QPageSize.size": [('PySide2.QtGui.QPageSize.PageSizeId', 'PySide2.QtGui.QPageSize.Unit'), ('PySide2.QtGui.QPageSize.Unit',)],
-    "PySide2.QtGui.QPageSize.sizePixels": [('PySide2.QtGui.QPageSize.PageSizeId', 'int'), ('int',)],
-    "PySide2.QtGui.QPageSize.sizePoints": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.swap": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.windowsId": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-# class PySide2.QtGui.QPagedPaintDevice:
-# class PySide2.QtGui.QPagedPaintDevice.Margins:
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__init__": [(), ('PySide2.QtGui.QPagedPaintDevice.Margins',)],
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__copy__": (),
-# class PySide2.QtGui.QPagedPaintDevice.PageSize:
-# class PySide2.QtGui.QPagedPaintDevice.PdfVersion:
-    "PySide2.QtGui.QPagedPaintDevice.__init__": (),
-    "PySide2.QtGui.QPagedPaintDevice.devicePageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.margins": (),
-    "PySide2.QtGui.QPagedPaintDevice.newPage": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSize": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSizeMM": (),
-    "PySide2.QtGui.QPagedPaintDevice.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageLayout": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit')],
-    "PySide2.QtGui.QPagedPaintDevice.setPageOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtGui.QPagedPaintDevice.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtGui.QPaintDevice:
-# class PySide2.QtGui.QPaintDevice.PaintDeviceMetric:
-    "PySide2.QtGui.QPaintDevice.__init__": (),
-    "PySide2.QtGui.QPaintDevice.colorCount": (),
-    "PySide2.QtGui.QPaintDevice.depth": (),
-    "PySide2.QtGui.QPaintDevice.devType": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatio": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioF": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioFScale": (),
-    "PySide2.QtGui.QPaintDevice.height": (),
-    "PySide2.QtGui.QPaintDevice.heightMM": (),
-    "PySide2.QtGui.QPaintDevice.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPaintDevice.logicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.logicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDevice.paintEngine": (),
-    "PySide2.QtGui.QPaintDevice.paintingActive": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPaintDevice.sharedPainter": (),
-    "PySide2.QtGui.QPaintDevice.width": (),
-    "PySide2.QtGui.QPaintDevice.widthMM": (),
-# class PySide2.QtGui.QPaintDeviceWindow:
-    "PySide2.QtGui.QPaintDeviceWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEngine": (),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-# class PySide2.QtGui.QPaintEngine:
-# class PySide2.QtGui.QPaintEngine.DirtyFlag:
-# class PySide2.QtGui.QPaintEngine.DirtyFlags:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeature:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeatures:
-# class PySide2.QtGui.QPaintEngine.PolygonDrawMode:
-# class PySide2.QtGui.QPaintEngine.Type:
-    "PySide2.QtGui.QPaintEngine.__init__": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPaintEngine.clearDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.coordinateOffset": (),
-    "PySide2.QtGui.QPaintEngine.drawEllipse": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QPaintEngine.drawImage": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPaintEngine.drawLines": [('PySide2.QtCore.QLine', 'int'), ('PySide2.QtCore.QLineF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPaintEngine.drawPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QPaintEngine.drawPoints": [('PySide2.QtCore.QPoint', 'int'), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPolygon": [('PySide2.QtCore.QPoint', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode')],
-    "PySide2.QtGui.QPaintEngine.drawRects": [('PySide2.QtCore.QRect', 'int'), ('PySide2.QtCore.QRectF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawTextItem": ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'),
-    "PySide2.QtGui.QPaintEngine.drawTiledPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPaintEngine.end": (),
-    "PySide2.QtGui.QPaintEngine.hasFeature": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.isActive": (),
-    "PySide2.QtGui.QPaintEngine.isExtended": (),
-    "PySide2.QtGui.QPaintEngine.paintDevice": (),
-    "PySide2.QtGui.QPaintEngine.painter": (),
-    "PySide2.QtGui.QPaintEngine.setActive": ('bool',),
-    "PySide2.QtGui.QPaintEngine.setDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.setSystemClip": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPaintEngine.setSystemRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPaintEngine.syncState": (),
-    "PySide2.QtGui.QPaintEngine.systemClip": (),
-    "PySide2.QtGui.QPaintEngine.systemRect": (),
-    "PySide2.QtGui.QPaintEngine.testDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.type": (),
-    "PySide2.QtGui.QPaintEngine.updateState": ('PySide2.QtGui.QPaintEngineState',),
-# class PySide2.QtGui.QPaintEngineState:
-    "PySide2.QtGui.QPaintEngineState.__init__": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundBrush": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundMode": (),
-    "PySide2.QtGui.QPaintEngineState.brush": (),
-    "PySide2.QtGui.QPaintEngineState.brushNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.brushOrigin": (),
-    "PySide2.QtGui.QPaintEngineState.clipOperation": (),
-    "PySide2.QtGui.QPaintEngineState.clipPath": (),
-    "PySide2.QtGui.QPaintEngineState.clipRegion": (),
-    "PySide2.QtGui.QPaintEngineState.compositionMode": (),
-    "PySide2.QtGui.QPaintEngineState.font": (),
-    "PySide2.QtGui.QPaintEngineState.isClipEnabled": (),
-    "PySide2.QtGui.QPaintEngineState.matrix": (),
-    "PySide2.QtGui.QPaintEngineState.opacity": (),
-    "PySide2.QtGui.QPaintEngineState.painter": (),
-    "PySide2.QtGui.QPaintEngineState.pen": (),
-    "PySide2.QtGui.QPaintEngineState.penNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.renderHints": (),
-    "PySide2.QtGui.QPaintEngineState.state": (),
-    "PySide2.QtGui.QPaintEngineState.transform": (),
-# class PySide2.QtGui.QPaintEvent:
-    "PySide2.QtGui.QPaintEvent.__init__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QPaintEvent.rect": (),
-    "PySide2.QtGui.QPaintEvent.region": (),
-# class PySide2.QtGui.QPainter:
-# class PySide2.QtGui.QPainter.CompositionMode:
-# class PySide2.QtGui.QPainter.PixmapFragment:
-    "PySide2.QtGui.QPainter.PixmapFragment.__init__": [(), ('PySide2.QtGui.QPainter.PixmapFragment',)],
-    "PySide2.QtGui.QPainter.PixmapFragment.__copy__": (),
-    "PySide2.QtGui.QPainter.PixmapFragment.create": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QRectF', 'float', 'float', 'float', 'float'),
-# class PySide2.QtGui.QPainter.PixmapFragmentHint:
-# class PySide2.QtGui.QPainter.PixmapFragmentHints:
-# class PySide2.QtGui.QPainter.RenderHint:
-# class PySide2.QtGui.QPainter.RenderHints:
-    "PySide2.QtGui.QPainter.__init__": [(), ('PySide2.QtGui.QPaintDevice',)],
-    "PySide2.QtGui.QPainter.background": (),
-    "PySide2.QtGui.QPainter.backgroundMode": (),
-    "PySide2.QtGui.QPainter.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.beginNativePainting": (),
-    "PySide2.QtGui.QPainter.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str'), ('PySide2.QtCore.QRectF', 'int', 'str'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.brush": (),
-    "PySide2.QtGui.QPainter.brushOrigin": (),
-    "PySide2.QtGui.QPainter.clipBoundingRect": (),
-    "PySide2.QtGui.QPainter.clipPath": (),
-    "PySide2.QtGui.QPainter.clipRegion": (),
-    "PySide2.QtGui.QPainter.combinedMatrix": (),
-    "PySide2.QtGui.QPainter.combinedTransform": (),
-    "PySide2.QtGui.QPainter.compositionMode": (),
-    "PySide2.QtGui.QPainter.device": (),
-    "PySide2.QtGui.QPainter.deviceMatrix": (),
-    "PySide2.QtGui.QPainter.deviceTransform": (),
-    "PySide2.QtGui.QPainter.drawArc": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawChord": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawConvexPolygon": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawEllipse": [('PySide2.QtCore.QPoint', 'int', 'int'), ('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawImage": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('int', 'int', 'PySide2.QtGui.QImage', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPainter.drawLine": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawLines": [('typing.List[PySide2.QtCore.QLineF]',), ('typing.List[PySide2.QtCore.QLine]',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainter.drawPicture": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPicture'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPicture'), ('int', 'int', 'PySide2.QtGui.QPicture')],
-    "PySide2.QtGui.QPainter.drawPie": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmap": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmapFragments": ('PySide2.QtGui.QPainter.PixmapFragment', 'int', 'PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPainter.PixmapFragmentHints'),
-    "PySide2.QtGui.QPainter.drawPoint": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.drawPoints": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPolygon": [('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPointF]', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPoint]', 'PySide2.QtCore.Qt.FillRule')],
-    "PySide2.QtGui.QPainter.drawPolyline": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRects": [('typing.List[PySide2.QtCore.QRectF]',), ('typing.List[PySide2.QtCore.QRect]',)],
-    "PySide2.QtGui.QPainter.drawRoundRect": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRoundedRect": [('PySide2.QtCore.QRect', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('int', 'int', 'int', 'int', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainter.drawStaticText": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QStaticText'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QStaticText'), ('int', 'int', 'PySide2.QtGui.QStaticText')],
-    "PySide2.QtGui.QPainter.drawText": [('PySide2.QtCore.QPoint', 'str'), ('PySide2.QtCore.QPointF', 'str'), ('PySide2.QtCore.QRect', 'int', 'str', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'int', 'str', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str', 'PySide2.QtCore.QRect'), ('int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.drawTextItem": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QTextItem'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'), ('int', 'int', 'PySide2.QtGui.QTextItem')],
-    "PySide2.QtGui.QPainter.drawTiledPixmap": [('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QPainter.end": (),
-    "PySide2.QtGui.QPainter.endNativePainting": (),
-    "PySide2.QtGui.QPainter.eraseRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.fillPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPainter.fillRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QGradient.Preset'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QGradient.Preset'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.BrushStyle'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.GlobalColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QBrush'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QGradient.Preset')],
-    "PySide2.QtGui.QPainter.font": (),
-    "PySide2.QtGui.QPainter.fontInfo": (),
-    "PySide2.QtGui.QPainter.fontMetrics": (),
-    "PySide2.QtGui.QPainter.hasClipping": (),
-    "PySide2.QtGui.QPainter.initFrom": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.isActive": (),
-    "PySide2.QtGui.QPainter.layoutDirection": (),
-    "PySide2.QtGui.QPainter.matrix": (),
-    "PySide2.QtGui.QPainter.matrixEnabled": (),
-    "PySide2.QtGui.QPainter.opacity": (),
-    "PySide2.QtGui.QPainter.paintEngine": (),
-    "PySide2.QtGui.QPainter.pen": (),
-    "PySide2.QtGui.QPainter.redirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.renderHints": (),
-    "PySide2.QtGui.QPainter.resetMatrix": (),
-    "PySide2.QtGui.QPainter.resetTransform": (),
-    "PySide2.QtGui.QPainter.restore": (),
-    "PySide2.QtGui.QPainter.restoreRedirected": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.rotate": ('float',),
-    "PySide2.QtGui.QPainter.save": (),
-    "PySide2.QtGui.QPainter.scale": ('float', 'float'),
-    "PySide2.QtGui.QPainter.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPainter.setBackgroundMode": ('PySide2.QtCore.Qt.BGMode',),
-    "PySide2.QtGui.QPainter.setBrush": [('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtGui.QBrush',)],
-    "PySide2.QtGui.QPainter.setBrushOrigin": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.setClipPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ClipOperation'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ClipOperation'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ClipOperation')],
-    "PySide2.QtGui.QPainter.setClipRegion": ('PySide2.QtGui.QRegion', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipping": ('bool',),
-    "PySide2.QtGui.QPainter.setCompositionMode": ('PySide2.QtGui.QPainter.CompositionMode',),
-    "PySide2.QtGui.QPainter.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QPainter.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QPainter.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setOpacity": ('float',),
-    "PySide2.QtGui.QPainter.setPen": [('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainter.setRedirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtGui.QPainter.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints', 'bool'),
-    "PySide2.QtGui.QPainter.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.setViewTransformEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setViewport": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWindow": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWorldMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setWorldMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setWorldTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.shear": ('float', 'float'),
-    "PySide2.QtGui.QPainter.strokePath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen'),
-    "PySide2.QtGui.QPainter.testRenderHint": ('PySide2.QtGui.QPainter.RenderHint',),
-    "PySide2.QtGui.QPainter.transform": (),
-    "PySide2.QtGui.QPainter.translate": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainter.viewTransformEnabled": (),
-    "PySide2.QtGui.QPainter.viewport": (),
-    "PySide2.QtGui.QPainter.window": (),
-    "PySide2.QtGui.QPainter.worldMatrix": (),
-    "PySide2.QtGui.QPainter.worldMatrixEnabled": (),
-    "PySide2.QtGui.QPainter.worldTransform": (),
-# class PySide2.QtGui.QPainterPath:
-# class PySide2.QtGui.QPainterPath.Element:
-    "PySide2.QtGui.QPainterPath.Element.__init__": [(), ('PySide2.QtGui.QPainterPath.Element',)],
-    "PySide2.QtGui.QPainterPath.Element.__copy__": (),
-    "PySide2.QtGui.QPainterPath.Element.isCurveTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isLineTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isMoveTo": (),
-# class PySide2.QtGui.QPainterPath.ElementType:
-    "PySide2.QtGui.QPainterPath.__init__": [(), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.__add__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__and__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__copy__": (),
-    "PySide2.QtGui.QPainterPath.__iadd__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__iand__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__ior__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__isub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.__or__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__sub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addEllipse": [('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPainterPath.addRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPainterPath.addRoundRect": [('PySide2.QtCore.QRectF', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtGui.QPainterPath.addRoundedRect": [('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('float', 'float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainterPath.addText": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QFont', 'str'), ('float', 'float', 'PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtGui.QPainterPath.angleAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.arcMoveTo": [('PySide2.QtCore.QRectF', 'float'), ('float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.arcTo": [('PySide2.QtCore.QRectF', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.boundingRect": (),
-    "PySide2.QtGui.QPainterPath.capacity": (),
-    "PySide2.QtGui.QPainterPath.clear": (),
-    "PySide2.QtGui.QPainterPath.closeSubpath": (),
-    "PySide2.QtGui.QPainterPath.connectPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.controlPointRect": (),
-    "PySide2.QtGui.QPainterPath.cubicTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.currentPosition": (),
-    "PySide2.QtGui.QPainterPath.elementAt": ('int',),
-    "PySide2.QtGui.QPainterPath.elementCount": (),
-    "PySide2.QtGui.QPainterPath.fillRule": (),
-    "PySide2.QtGui.QPainterPath.intersected": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.intersects": [('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.isEmpty": (),
-    "PySide2.QtGui.QPainterPath.length": (),
-    "PySide2.QtGui.QPainterPath.lineTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.percentAtLength": ('float',),
-    "PySide2.QtGui.QPainterPath.pointAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.quadTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.reserve": ('int',),
-    "PySide2.QtGui.QPainterPath.setElementPositionAt": ('int', 'float', 'float'),
-    "PySide2.QtGui.QPainterPath.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtGui.QPainterPath.simplified": (),
-    "PySide2.QtGui.QPainterPath.slopeAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.subtracted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.subtractedInverted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.swap": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.toFillPolygon": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toFillPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toReversed": (),
-    "PySide2.QtGui.QPainterPath.toSubpathPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.united": ('PySide2.QtGui.QPainterPath',),
-# class PySide2.QtGui.QPainterPathStroker:
-    "PySide2.QtGui.QPainterPathStroker.__init__": [(), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainterPathStroker.capStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.createStroke": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPathStroker.curveThreshold": (),
-    "PySide2.QtGui.QPainterPathStroker.dashOffset": (),
-    "PySide2.QtGui.QPainterPathStroker.dashPattern": (),
-    "PySide2.QtGui.QPainterPathStroker.joinStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.miterLimit": (),
-    "PySide2.QtGui.QPainterPathStroker.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setCurveThreshold": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashOffset": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashPattern": [('PySide2.QtCore.Qt.PenStyle',), ('typing.List[float]',)],
-    "PySide2.QtGui.QPainterPathStroker.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setWidth": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.width": (),
-# class PySide2.QtGui.QPalette:
-# class PySide2.QtGui.QPalette.ColorGroup:
-# class PySide2.QtGui.QPalette.ColorRole:
-    "PySide2.QtGui.QPalette.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette',)],
-    "PySide2.QtGui.QPalette.__copy__": (),
-    "PySide2.QtGui.QPalette.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.alternateBase": (),
-    "PySide2.QtGui.QPalette.background": (),
-    "PySide2.QtGui.QPalette.base": (),
-    "PySide2.QtGui.QPalette.brightText": (),
-    "PySide2.QtGui.QPalette.brush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.button": (),
-    "PySide2.QtGui.QPalette.buttonText": (),
-    "PySide2.QtGui.QPalette.cacheKey": (),
-    "PySide2.QtGui.QPalette.color": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.currentColorGroup": (),
-    "PySide2.QtGui.QPalette.dark": (),
-    "PySide2.QtGui.QPalette.foreground": (),
-    "PySide2.QtGui.QPalette.highlight": (),
-    "PySide2.QtGui.QPalette.highlightedText": (),
-    "PySide2.QtGui.QPalette.isBrushSet": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtGui.QPalette.isCopyOf": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.isEqual": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorGroup'),
-    "PySide2.QtGui.QPalette.light": (),
-    "PySide2.QtGui.QPalette.link": (),
-    "PySide2.QtGui.QPalette.linkVisited": (),
-    "PySide2.QtGui.QPalette.mid": (),
-    "PySide2.QtGui.QPalette.midlight": (),
-    "PySide2.QtGui.QPalette.placeholderText": (),
-    "PySide2.QtGui.QPalette.resolve": [(), ('PySide2.QtGui.QPalette',), ('int',)],
-    "PySide2.QtGui.QPalette.setBrush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtGui.QPalette.setColor": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QPalette.setColorGroup": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPalette.setCurrentColorGroup": ('PySide2.QtGui.QPalette.ColorGroup',),
-    "PySide2.QtGui.QPalette.shadow": (),
-    "PySide2.QtGui.QPalette.swap": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.text": (),
-    "PySide2.QtGui.QPalette.toolTipBase": (),
-    "PySide2.QtGui.QPalette.toolTipText": (),
-    "PySide2.QtGui.QPalette.window": (),
-    "PySide2.QtGui.QPalette.windowText": (),
-# class PySide2.QtGui.QPdfWriter:
-    "PySide2.QtGui.QPdfWriter.__init__": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPdfWriter.creator": (),
-    "PySide2.QtGui.QPdfWriter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPdfWriter.newPage": (),
-    "PySide2.QtGui.QPdfWriter.paintEngine": (),
-    "PySide2.QtGui.QPdfWriter.pdfVersion": (),
-    "PySide2.QtGui.QPdfWriter.resolution": (),
-    "PySide2.QtGui.QPdfWriter.setCreator": ('str',),
-    "PySide2.QtGui.QPdfWriter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPdfWriter.setPageSize": ('PySide2.QtGui.QPagedPaintDevice.PageSize',),
-    "PySide2.QtGui.QPdfWriter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QPdfWriter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtGui.QPdfWriter.setResolution": ('int',),
-    "PySide2.QtGui.QPdfWriter.setTitle": ('str',),
-    "PySide2.QtGui.QPdfWriter.title": (),
-# class PySide2.QtGui.QPen:
-    "PySide2.QtGui.QPen.__init__": [(), ('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QBrush', 'float', 'PySide2.QtCore.Qt.PenStyle', 'PySide2.QtCore.Qt.PenCapStyle', 'PySide2.QtCore.Qt.PenJoinStyle'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPen.__copy__": (),
-    "PySide2.QtGui.QPen.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.brush": (),
-    "PySide2.QtGui.QPen.capStyle": (),
-    "PySide2.QtGui.QPen.color": (),
-    "PySide2.QtGui.QPen.dashOffset": (),
-    "PySide2.QtGui.QPen.dashPattern": (),
-    "PySide2.QtGui.QPen.isCosmetic": (),
-    "PySide2.QtGui.QPen.isSolid": (),
-    "PySide2.QtGui.QPen.joinStyle": (),
-    "PySide2.QtGui.QPen.miterLimit": (),
-    "PySide2.QtGui.QPen.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPen.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPen.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QPen.setCosmetic": ('bool',),
-    "PySide2.QtGui.QPen.setDashOffset": ('float',),
-    "PySide2.QtGui.QPen.setDashPattern": ('typing.List[float]',),
-    "PySide2.QtGui.QPen.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPen.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPen.setStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtGui.QPen.setWidth": ('int',),
-    "PySide2.QtGui.QPen.setWidthF": ('float',),
-    "PySide2.QtGui.QPen.style": (),
-    "PySide2.QtGui.QPen.swap": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QPen.width": (),
-    "PySide2.QtGui.QPen.widthF": (),
-# class PySide2.QtGui.QPicture:
-    "PySide2.QtGui.QPicture.__init__": [('PySide2.QtGui.QPicture',), ('int',)],
-    "PySide2.QtGui.QPicture.__copy__": (),
-    "PySide2.QtGui.QPicture.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.boundingRect": (),
-    "PySide2.QtGui.QPicture.data": (),
-    "PySide2.QtGui.QPicture.devType": (),
-    "PySide2.QtGui.QPicture.inputFormatList": (),
-    "PySide2.QtGui.QPicture.inputFormats": (),
-    "PySide2.QtGui.QPicture.isNull": (),
-    "PySide2.QtGui.QPicture.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPicture.outputFormatList": (),
-    "PySide2.QtGui.QPicture.outputFormats": (),
-    "PySide2.QtGui.QPicture.paintEngine": (),
-    "PySide2.QtGui.QPicture.pictureFormat": ('str',),
-    "PySide2.QtGui.QPicture.play": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPicture.save": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.setBoundingRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPicture.setData": ('str', 'int'),
-    "PySide2.QtGui.QPicture.size": (),
-    "PySide2.QtGui.QPicture.swap": ('PySide2.QtGui.QPicture',),
-# class PySide2.QtGui.QPictureIO:
-    "PySide2.QtGui.QPictureIO.__init__": [(), ('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPictureIO.description": (),
-    "PySide2.QtGui.QPictureIO.fileName": (),
-    "PySide2.QtGui.QPictureIO.format": (),
-    "PySide2.QtGui.QPictureIO.gamma": (),
-    "PySide2.QtGui.QPictureIO.inputFormats": (),
-    "PySide2.QtGui.QPictureIO.ioDevice": (),
-    "PySide2.QtGui.QPictureIO.outputFormats": (),
-    "PySide2.QtGui.QPictureIO.parameters": (),
-    "PySide2.QtGui.QPictureIO.picture": (),
-    "PySide2.QtGui.QPictureIO.pictureFormat": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPictureIO.quality": (),
-    "PySide2.QtGui.QPictureIO.read": (),
-    "PySide2.QtGui.QPictureIO.setDescription": ('str',),
-    "PySide2.QtGui.QPictureIO.setFileName": ('str',),
-    "PySide2.QtGui.QPictureIO.setFormat": ('str',),
-    "PySide2.QtGui.QPictureIO.setGamma": ('float',),
-    "PySide2.QtGui.QPictureIO.setIODevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QPictureIO.setParameters": ('str',),
-    "PySide2.QtGui.QPictureIO.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtGui.QPictureIO.setQuality": ('int',),
-    "PySide2.QtGui.QPictureIO.setStatus": ('int',),
-    "PySide2.QtGui.QPictureIO.status": (),
-    "PySide2.QtGui.QPictureIO.write": (),
-# class PySide2.QtGui.QPixelFormat:
-# class PySide2.QtGui.QPixelFormat.AlphaPosition:
-# class PySide2.QtGui.QPixelFormat.AlphaPremultiplied:
-# class PySide2.QtGui.QPixelFormat.AlphaUsage:
-# class PySide2.QtGui.QPixelFormat.ByteOrder:
-# class PySide2.QtGui.QPixelFormat.ColorModel:
-# class PySide2.QtGui.QPixelFormat.TypeInterpretation:
-# class PySide2.QtGui.QPixelFormat.YUVLayout:
-    "PySide2.QtGui.QPixelFormat.__init__": [(), ('PySide2.QtGui.QPixelFormat',), ('PySide2.QtGui.QPixelFormat.ColorModel', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QPixelFormat.AlphaUsage', 'PySide2.QtGui.QPixelFormat.AlphaPosition', 'PySide2.QtGui.QPixelFormat.AlphaPremultiplied', 'PySide2.QtGui.QPixelFormat.TypeInterpretation', 'PySide2.QtGui.QPixelFormat.ByteOrder', 'int')],
-    "PySide2.QtGui.QPixelFormat.__copy__": (),
-    "PySide2.QtGui.QPixelFormat.alphaPosition": (),
-    "PySide2.QtGui.QPixelFormat.alphaSize": (),
-    "PySide2.QtGui.QPixelFormat.alphaUsage": (),
-    "PySide2.QtGui.QPixelFormat.bitsPerPixel": (),
-    "PySide2.QtGui.QPixelFormat.blackSize": (),
-    "PySide2.QtGui.QPixelFormat.blueSize": (),
-    "PySide2.QtGui.QPixelFormat.brightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.byteOrder": (),
-    "PySide2.QtGui.QPixelFormat.channelCount": (),
-    "PySide2.QtGui.QPixelFormat.colorModel": (),
-    "PySide2.QtGui.QPixelFormat.cyanSize": (),
-    "PySide2.QtGui.QPixelFormat.greenSize": (),
-    "PySide2.QtGui.QPixelFormat.hueSize": (),
-    "PySide2.QtGui.QPixelFormat.lightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.magentaSize": (),
-    "PySide2.QtGui.QPixelFormat.premultiplied": (),
-    "PySide2.QtGui.QPixelFormat.redSize": (),
-    "PySide2.QtGui.QPixelFormat.saturationSize": (),
-    "PySide2.QtGui.QPixelFormat.subEnum": (),
-    "PySide2.QtGui.QPixelFormat.typeInterpretation": (),
-    "PySide2.QtGui.QPixelFormat.yellowSize": (),
-    "PySide2.QtGui.QPixelFormat.yuvLayout": (),
-# class PySide2.QtGui.QPixmap:
-    "PySide2.QtGui.QPixmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QPixmap.__copy__": (),
-    "PySide2.QtGui.QPixmap.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.cacheKey": (),
-    "PySide2.QtGui.QPixmap.convertFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QPixmap.createMaskFromColor": ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QPixmap.defaultDepth": (),
-    "PySide2.QtGui.QPixmap.depth": (),
-    "PySide2.QtGui.QPixmap.devType": (),
-    "PySide2.QtGui.QPixmap.devicePixelRatio": (),
-    "PySide2.QtGui.QPixmap.fill": [('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QPaintDevice', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageInPlace": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageReader": ('PySide2.QtGui.QImageReader', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.grabWidget": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QObject', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QPixmap.hasAlpha": (),
-    "PySide2.QtGui.QPixmap.hasAlphaChannel": (),
-    "PySide2.QtGui.QPixmap.height": (),
-    "PySide2.QtGui.QPixmap.isNull": (),
-    "PySide2.QtGui.QPixmap.isQBitmap": (),
-    "PySide2.QtGui.QPixmap.load": ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.loadFromData": [('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('str', 'int', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPixmap.mask": (),
-    "PySide2.QtGui.QPixmap.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPixmap.paintEngine": (),
-    "PySide2.QtGui.QPixmap.rect": (),
-    "PySide2.QtGui.QPixmap.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QPixmap.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scroll": [('int', 'int', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion')],
-    "PySide2.QtGui.QPixmap.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QPixmap.setMask": ('PySide2.QtGui.QBitmap',),
-    "PySide2.QtGui.QPixmap.size": (),
-    "PySide2.QtGui.QPixmap.swap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QPixmap.toImage": (),
-    "PySide2.QtGui.QPixmap.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.width": (),
-# class PySide2.QtGui.QPixmapCache:
-# class PySide2.QtGui.QPixmapCache.Key:
-    "PySide2.QtGui.QPixmapCache.Key.__init__": [(), ('PySide2.QtGui.QPixmapCache.Key',)],
-    "PySide2.QtGui.QPixmapCache.Key.__copy__": (),
-    "PySide2.QtGui.QPixmapCache.Key.isValid": (),
-    "PySide2.QtGui.QPixmapCache.Key.swap": ('PySide2.QtGui.QPixmapCache.Key',),
-    "PySide2.QtGui.QPixmapCache.__init__": (),
-    "PySide2.QtGui.QPixmapCache.cacheLimit": (),
-    "PySide2.QtGui.QPixmapCache.clear": (),
-    "PySide2.QtGui.QPixmapCache.find": [('PySide2.QtGui.QPixmapCache.Key',), ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'), ('str',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.insert": [('PySide2.QtGui.QPixmap',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.remove": [('PySide2.QtGui.QPixmapCache.Key',), ('str',)],
-    "PySide2.QtGui.QPixmapCache.replace": ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtGui.QPixmapCache.setCacheLimit": ('int',),
-# class PySide2.QtGui.QPointingDeviceUniqueId:
-    "PySide2.QtGui.QPointingDeviceUniqueId.__init__": [(), ('PySide2.QtGui.QPointingDeviceUniqueId',)],
-    "PySide2.QtGui.QPointingDeviceUniqueId.__copy__": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.fromNumericId": ('int',),
-    "PySide2.QtGui.QPointingDeviceUniqueId.isValid": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.numericId": (),
-# class PySide2.QtGui.QPolygon:
-    "PySide2.QtGui.QPolygon.__init__": [(), ('PySide2.QtCore.QRect', 'bool'), ('PySide2.QtGui.QPolygon',), ('int',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__add__": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.__copy__": (),
-    "PySide2.QtGui.QPolygon.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.__lshift__": [('PySide2.QtCore.QDataStream',), ('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygon.__reduce__": (),
-    "PySide2.QtGui.QPolygon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygon.append": [('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.at": ('int',),
-    "PySide2.QtGui.QPolygon.back": (),
-    "PySide2.QtGui.QPolygon.boundingRect": (),
-    "PySide2.QtGui.QPolygon.capacity": (),
-    "PySide2.QtGui.QPolygon.clear": (),
-    "PySide2.QtGui.QPolygon.constData": (),
-    "PySide2.QtGui.QPolygon.constFirst": (),
-    "PySide2.QtGui.QPolygon.constLast": (),
-    "PySide2.QtGui.QPolygon.contains": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.containsPoint": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygon.count": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtGui.QPolygon.data": (),
-    "PySide2.QtGui.QPolygon.empty": (),
-    "PySide2.QtGui.QPolygon.endsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.fill": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.first": (),
-    "PySide2.QtGui.QPolygon.fromList": ('typing.Sequence[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.front": (),
-    "PySide2.QtGui.QPolygon.indexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.insert": [('int', 'PySide2.QtCore.QPoint'), ('int', 'int', 'PySide2.QtCore.QPoint')],
-    "PySide2.QtGui.QPolygon.intersected": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.intersects": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.isEmpty": (),
-    "PySide2.QtGui.QPolygon.isSharedWith": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.last": (),
-    "PySide2.QtGui.QPolygon.lastIndexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.length": (),
-    "PySide2.QtGui.QPolygon.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.pop_back": (),
-    "PySide2.QtGui.QPolygon.pop_front": (),
-    "PySide2.QtGui.QPolygon.prepend": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_back": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_front": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.removeAll": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.removeAt": ('int',),
-    "PySide2.QtGui.QPolygon.removeFirst": (),
-    "PySide2.QtGui.QPolygon.removeLast": (),
-    "PySide2.QtGui.QPolygon.removeOne": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.replace": ('int', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPolygon.reserve": ('int',),
-    "PySide2.QtGui.QPolygon.resize": ('int',),
-    "PySide2.QtGui.QPolygon.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygon.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygon.size": (),
-    "PySide2.QtGui.QPolygon.squeeze": (),
-    "PySide2.QtGui.QPolygon.startsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.subtracted": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swap": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.takeAt": ('int',),
-    "PySide2.QtGui.QPolygon.takeFirst": (),
-    "PySide2.QtGui.QPolygon.takeLast": (),
-    "PySide2.QtGui.QPolygon.toList": (),
-    "PySide2.QtGui.QPolygon.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.united": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.value": [('int',), ('int', 'PySide2.QtCore.QPoint')],
-# class PySide2.QtGui.QPolygonF:
-    "PySide2.QtGui.QPolygonF.__init__": [(), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('int',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.__add__": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.__copy__": (),
-    "PySide2.QtGui.QPolygonF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygonF.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.append": [('PySide2.QtCore.QPointF',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.at": ('int',),
-    "PySide2.QtGui.QPolygonF.back": (),
-    "PySide2.QtGui.QPolygonF.boundingRect": (),
-    "PySide2.QtGui.QPolygonF.capacity": (),
-    "PySide2.QtGui.QPolygonF.clear": (),
-    "PySide2.QtGui.QPolygonF.constData": (),
-    "PySide2.QtGui.QPolygonF.constFirst": (),
-    "PySide2.QtGui.QPolygonF.constLast": (),
-    "PySide2.QtGui.QPolygonF.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.containsPoint": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygonF.count": [(), ('PySide2.QtCore.QPointF',)],
-    "PySide2.QtGui.QPolygonF.data": (),
-    "PySide2.QtGui.QPolygonF.empty": (),
-    "PySide2.QtGui.QPolygonF.endsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.fill": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.first": (),
-    "PySide2.QtGui.QPolygonF.fromList": ('typing.Sequence[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.front": (),
-    "PySide2.QtGui.QPolygonF.indexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.insert": [('int', 'PySide2.QtCore.QPointF'), ('int', 'int', 'PySide2.QtCore.QPointF')],
-    "PySide2.QtGui.QPolygonF.intersected": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.intersects": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.isClosed": (),
-    "PySide2.QtGui.QPolygonF.isEmpty": (),
-    "PySide2.QtGui.QPolygonF.isSharedWith": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.last": (),
-    "PySide2.QtGui.QPolygonF.lastIndexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.length": (),
-    "PySide2.QtGui.QPolygonF.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.pop_back": (),
-    "PySide2.QtGui.QPolygonF.pop_front": (),
-    "PySide2.QtGui.QPolygonF.prepend": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_back": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_front": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygonF.removeAll": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.removeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.removeFirst": (),
-    "PySide2.QtGui.QPolygonF.removeLast": (),
-    "PySide2.QtGui.QPolygonF.removeOne": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.replace": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPolygonF.reserve": ('int',),
-    "PySide2.QtGui.QPolygonF.resize": ('int',),
-    "PySide2.QtGui.QPolygonF.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygonF.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygonF.size": (),
-    "PySide2.QtGui.QPolygonF.squeeze": (),
-    "PySide2.QtGui.QPolygonF.startsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.subtracted": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swap": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.takeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.takeFirst": (),
-    "PySide2.QtGui.QPolygonF.takeLast": (),
-    "PySide2.QtGui.QPolygonF.toList": (),
-    "PySide2.QtGui.QPolygonF.toPolygon": (),
-    "PySide2.QtGui.QPolygonF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.united": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.value": [('int',), ('int', 'PySide2.QtCore.QPointF')],
-# class PySide2.QtGui.QPyTextObject:
-    "PySide2.QtGui.QPyTextObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QPyTextObject.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QPyTextObject.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QQuaternion:
-    "PySide2.QtGui.QQuaternion.__init__": [(), ('PySide2.QtGui.QVector4D',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.__add__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__copy__": (),
-    "PySide2.QtGui.QQuaternion.__iadd__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__imul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__isub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__mul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__neg__": (),
-    "PySide2.QtGui.QQuaternion.__reduce__": (),
-    "PySide2.QtGui.QQuaternion.__repr__": (),
-    "PySide2.QtGui.QQuaternion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__sub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.conjugate": (),
-    "PySide2.QtGui.QQuaternion.conjugated": (),
-    "PySide2.QtGui.QQuaternion.dotProduct": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion'),
-    "PySide2.QtGui.QQuaternion.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromDirection": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromRotationMatrix": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QQuaternion.getAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.inverted": (),
-    "PySide2.QtGui.QQuaternion.isIdentity": (),
-    "PySide2.QtGui.QQuaternion.isNull": (),
-    "PySide2.QtGui.QQuaternion.length": (),
-    "PySide2.QtGui.QQuaternion.lengthSquared": (),
-    "PySide2.QtGui.QQuaternion.nlerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.normalize": (),
-    "PySide2.QtGui.QQuaternion.normalized": (),
-    "PySide2.QtGui.QQuaternion.rotatedVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QQuaternion.rotationTo": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.scalar": (),
-    "PySide2.QtGui.QQuaternion.setScalar": ('float',),
-    "PySide2.QtGui.QQuaternion.setVector": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.setX": ('float',),
-    "PySide2.QtGui.QQuaternion.setY": ('float',),
-    "PySide2.QtGui.QQuaternion.setZ": ('float',),
-    "PySide2.QtGui.QQuaternion.slerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.toEulerAngles": (),
-    "PySide2.QtGui.QQuaternion.toRotationMatrix": (),
-    "PySide2.QtGui.QQuaternion.toVector4D": (),
-    "PySide2.QtGui.QQuaternion.vector": (),
-    "PySide2.QtGui.QQuaternion.x": (),
-    "PySide2.QtGui.QQuaternion.y": (),
-    "PySide2.QtGui.QQuaternion.z": (),
-# class PySide2.QtGui.QRadialGradient:
-    "PySide2.QtGui.QRadialGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QRadialGradient',), ('float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QRadialGradient.__copy__": (),
-    "PySide2.QtGui.QRadialGradient.center": (),
-    "PySide2.QtGui.QRadialGradient.centerRadius": (),
-    "PySide2.QtGui.QRadialGradient.focalPoint": (),
-    "PySide2.QtGui.QRadialGradient.focalRadius": (),
-    "PySide2.QtGui.QRadialGradient.radius": (),
-    "PySide2.QtGui.QRadialGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setCenterRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setFocalPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setFocalRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setRadius": ('float',),
-# class PySide2.QtGui.QRasterWindow:
-    "PySide2.QtGui.QRasterWindow.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QRasterWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QRasterWindow.redirected": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtGui.QRawFont:
-# class PySide2.QtGui.QRawFont.AntialiasingType:
-# class PySide2.QtGui.QRawFont.LayoutFlag:
-# class PySide2.QtGui.QRawFont.LayoutFlags:
-    "PySide2.QtGui.QRawFont.__init__": [(), ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'), ('PySide2.QtGui.QRawFont',), ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference')],
-    "PySide2.QtGui.QRawFont.__copy__": (),
-    "PySide2.QtGui.QRawFont.advancesForGlyphIndexes": [('typing.List[int]',), ('typing.List[int]', 'PySide2.QtGui.QRawFont.LayoutFlags')],
-    "PySide2.QtGui.QRawFont.alphaMapForGlyph": ('int', 'PySide2.QtGui.QRawFont.AntialiasingType', 'PySide2.QtGui.QTransform'),
-    "PySide2.QtGui.QRawFont.ascent": (),
-    "PySide2.QtGui.QRawFont.averageCharWidth": (),
-    "PySide2.QtGui.QRawFont.boundingRect": ('int',),
-    "PySide2.QtGui.QRawFont.capHeight": (),
-    "PySide2.QtGui.QRawFont.descent": (),
-    "PySide2.QtGui.QRawFont.familyName": (),
-    "PySide2.QtGui.QRawFont.fontTable": ('str',),
-    "PySide2.QtGui.QRawFont.fromFont": ('PySide2.QtGui.QFont', 'PySide2.QtGui.QFontDatabase.WritingSystem'),
-    "PySide2.QtGui.QRawFont.glyphIndexesForString": ('str',),
-    "PySide2.QtGui.QRawFont.hintingPreference": (),
-    "PySide2.QtGui.QRawFont.isValid": (),
-    "PySide2.QtGui.QRawFont.leading": (),
-    "PySide2.QtGui.QRawFont.lineThickness": (),
-    "PySide2.QtGui.QRawFont.loadFromData": ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.loadFromFile": ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.maxCharWidth": (),
-    "PySide2.QtGui.QRawFont.pathForGlyph": ('int',),
-    "PySide2.QtGui.QRawFont.pixelSize": (),
-    "PySide2.QtGui.QRawFont.setPixelSize": ('float',),
-    "PySide2.QtGui.QRawFont.style": (),
-    "PySide2.QtGui.QRawFont.styleName": (),
-    "PySide2.QtGui.QRawFont.supportedWritingSystems": (),
-    "PySide2.QtGui.QRawFont.supportsCharacter": [('int',), ('str',)],
-    "PySide2.QtGui.QRawFont.swap": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QRawFont.underlinePosition": (),
-    "PySide2.QtGui.QRawFont.unitsPerEm": (),
-    "PySide2.QtGui.QRawFont.weight": (),
-    "PySide2.QtGui.QRawFont.xHeight": (),
-# class PySide2.QtGui.QRegExpValidator:
-    "PySide2.QtGui.QRegExpValidator.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRegExp', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QRegExpValidator.regExp": (),
-    "PySide2.QtGui.QRegExpValidator.setRegExp": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtGui.QRegExpValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QRegion:
-# class PySide2.QtGui.QRegion.RegionType:
-    "PySide2.QtGui.QRegion.__init__": [(), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion.RegionType'), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion.RegionType')],
-    "PySide2.QtGui.QRegion.__add__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__and__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__copy__": (),
-    "PySide2.QtGui.QRegion.__iadd__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__ior__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__isub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__ixor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QRegion.__or__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__sub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__xor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.begin": (),
-    "PySide2.QtGui.QRegion.boundingRect": (),
-    "PySide2.QtGui.QRegion.cbegin": (),
-    "PySide2.QtGui.QRegion.cend": (),
-    "PySide2.QtGui.QRegion.contains": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QRegion.end": (),
-    "PySide2.QtGui.QRegion.intersected": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.intersects": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.isEmpty": (),
-    "PySide2.QtGui.QRegion.isNull": (),
-    "PySide2.QtGui.QRegion.rectCount": (),
-    "PySide2.QtGui.QRegion.rects": (),
-    "PySide2.QtGui.QRegion.setRects": ('PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtGui.QRegion.subtracted": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.swap": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.united": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.xored": ('PySide2.QtGui.QRegion',),
-# class PySide2.QtGui.QResizeEvent:
-    "PySide2.QtGui.QResizeEvent.__init__": ('PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtGui.QResizeEvent.oldSize": (),
-    "PySide2.QtGui.QResizeEvent.size": (),
-# class PySide2.QtGui.QScreen:
-    "PySide2.QtGui.QScreen.angleBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation'),
-    "PySide2.QtGui.QScreen.availableGeometry": (),
-    "PySide2.QtGui.QScreen.availableSize": (),
-    "PySide2.QtGui.QScreen.availableVirtualGeometry": (),
-    "PySide2.QtGui.QScreen.availableVirtualSize": (),
-    "PySide2.QtGui.QScreen.depth": (),
-    "PySide2.QtGui.QScreen.devicePixelRatio": (),
-    "PySide2.QtGui.QScreen.geometry": (),
-    "PySide2.QtGui.QScreen.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QScreen.isLandscape": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.isPortrait": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.logicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.manufacturer": (),
-    "PySide2.QtGui.QScreen.mapBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.model": (),
-    "PySide2.QtGui.QScreen.name": (),
-    "PySide2.QtGui.QScreen.nativeOrientation": (),
-    "PySide2.QtGui.QScreen.orientation": (),
-    "PySide2.QtGui.QScreen.orientationUpdateMask": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.physicalSize": (),
-    "PySide2.QtGui.QScreen.primaryOrientation": (),
-    "PySide2.QtGui.QScreen.refreshRate": (),
-    "PySide2.QtGui.QScreen.serialNumber": (),
-    "PySide2.QtGui.QScreen.setOrientationUpdateMask": ('PySide2.QtCore.Qt.ScreenOrientations',),
-    "PySide2.QtGui.QScreen.size": (),
-    "PySide2.QtGui.QScreen.transformBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.virtualGeometry": (),
-    "PySide2.QtGui.QScreen.virtualSiblings": (),
-    "PySide2.QtGui.QScreen.virtualSize": (),
-# class PySide2.QtGui.QScrollEvent:
-# class PySide2.QtGui.QScrollEvent.ScrollState:
-    "PySide2.QtGui.QScrollEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QScrollEvent.ScrollState'),
-    "PySide2.QtGui.QScrollEvent.contentPos": (),
-    "PySide2.QtGui.QScrollEvent.overshootDistance": (),
-    "PySide2.QtGui.QScrollEvent.scrollState": (),
-# class PySide2.QtGui.QScrollPrepareEvent:
-    "PySide2.QtGui.QScrollPrepareEvent.__init__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPosRange": (),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPosRange": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setViewportSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QScrollPrepareEvent.startPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.viewportSize": (),
-# class PySide2.QtGui.QSessionManager:
-# class PySide2.QtGui.QSessionManager.RestartHint:
-    "PySide2.QtGui.QSessionManager.allowsErrorInteraction": (),
-    "PySide2.QtGui.QSessionManager.allowsInteraction": (),
-    "PySide2.QtGui.QSessionManager.cancel": (),
-    "PySide2.QtGui.QSessionManager.discardCommand": (),
-    "PySide2.QtGui.QSessionManager.isPhase2": (),
-    "PySide2.QtGui.QSessionManager.release": (),
-    "PySide2.QtGui.QSessionManager.requestPhase2": (),
-    "PySide2.QtGui.QSessionManager.restartCommand": (),
-    "PySide2.QtGui.QSessionManager.restartHint": (),
-    "PySide2.QtGui.QSessionManager.sessionId": (),
-    "PySide2.QtGui.QSessionManager.sessionKey": (),
-    "PySide2.QtGui.QSessionManager.setDiscardCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setManagerProperty": [('str', 'str'), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtGui.QSessionManager.setRestartCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setRestartHint": ('PySide2.QtGui.QSessionManager.RestartHint',),
-# class PySide2.QtGui.QShortcutEvent:
-    "PySide2.QtGui.QShortcutEvent.__init__": ('PySide2.QtGui.QKeySequence', 'int', 'bool'),
-    "PySide2.QtGui.QShortcutEvent.isAmbiguous": (),
-    "PySide2.QtGui.QShortcutEvent.key": (),
-    "PySide2.QtGui.QShortcutEvent.shortcutId": (),
-# class PySide2.QtGui.QShowEvent:
-    "PySide2.QtGui.QShowEvent.__init__": (),
-# class PySide2.QtGui.QStandardItem:
-# class PySide2.QtGui.QStandardItem.ItemType:
-    "PySide2.QtGui.QStandardItem.__init__": [(), ('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QStandardItem',), ('int', 'int'), ('str',)],
-    "PySide2.QtGui.QStandardItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.accessibleDescription": (),
-    "PySide2.QtGui.QStandardItem.accessibleText": (),
-    "PySide2.QtGui.QStandardItem.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItem.appendRows": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.background": (),
-    "PySide2.QtGui.QStandardItem.checkState": (),
-    "PySide2.QtGui.QStandardItem.child": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.clearData": (),
-    "PySide2.QtGui.QStandardItem.clone": (),
-    "PySide2.QtGui.QStandardItem.column": (),
-    "PySide2.QtGui.QStandardItem.columnCount": (),
-    "PySide2.QtGui.QStandardItem.data": ('int',),
-    "PySide2.QtGui.QStandardItem.emitDataChanged": (),
-    "PySide2.QtGui.QStandardItem.flags": (),
-    "PySide2.QtGui.QStandardItem.font": (),
-    "PySide2.QtGui.QStandardItem.foreground": (),
-    "PySide2.QtGui.QStandardItem.hasChildren": (),
-    "PySide2.QtGui.QStandardItem.icon": (),
-    "PySide2.QtGui.QStandardItem.index": (),
-    "PySide2.QtGui.QStandardItem.insertColumn": ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]'),
-    "PySide2.QtGui.QStandardItem.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.insertRow": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.insertRows": [('int', 'int'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.isAutoTristate": (),
-    "PySide2.QtGui.QStandardItem.isCheckable": (),
-    "PySide2.QtGui.QStandardItem.isDragEnabled": (),
-    "PySide2.QtGui.QStandardItem.isDropEnabled": (),
-    "PySide2.QtGui.QStandardItem.isEditable": (),
-    "PySide2.QtGui.QStandardItem.isEnabled": (),
-    "PySide2.QtGui.QStandardItem.isSelectable": (),
-    "PySide2.QtGui.QStandardItem.isTristate": (),
-    "PySide2.QtGui.QStandardItem.isUserTristate": (),
-    "PySide2.QtGui.QStandardItem.model": (),
-    "PySide2.QtGui.QStandardItem.parent": (),
-    "PySide2.QtGui.QStandardItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.removeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.removeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.row": (),
-    "PySide2.QtGui.QStandardItem.rowCount": (),
-    "PySide2.QtGui.QStandardItem.setAccessibleDescription": ('str',),
-    "PySide2.QtGui.QStandardItem.setAccessibleText": ('str',),
-    "PySide2.QtGui.QStandardItem.setAutoTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtGui.QStandardItem.setCheckable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setChild": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItem.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setData": ('typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItem.setDragEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setDropEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEditable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtGui.QStandardItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QStandardItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QStandardItem.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setSelectable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QStandardItem.setStatusTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setText": ('str',),
-    "PySide2.QtGui.QStandardItem.setTextAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QStandardItem.setToolTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setUserTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setWhatsThis": ('str',),
-    "PySide2.QtGui.QStandardItem.sizeHint": (),
-    "PySide2.QtGui.QStandardItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItem.statusTip": (),
-    "PySide2.QtGui.QStandardItem.takeChild": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.text": (),
-    "PySide2.QtGui.QStandardItem.textAlignment": (),
-    "PySide2.QtGui.QStandardItem.toolTip": (),
-    "PySide2.QtGui.QStandardItem.type": (),
-    "PySide2.QtGui.QStandardItem.whatsThis": (),
-    "PySide2.QtGui.QStandardItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QStandardItemModel:
-    "PySide2.QtGui.QStandardItemModel.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QStandardItemModel.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItemModel.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItemModel.clear": (),
-    "PySide2.QtGui.QStandardItemModel.clearItemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtGui.QStandardItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtGui.QStandardItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtGui.QStandardItemModel.horizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.indexFromItem": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.insertColumn": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.insertRow": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.invisibleRootItem": (),
-    "PySide2.QtGui.QStandardItemModel.item": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemPrototype": (),
-    "PySide2.QtGui.QStandardItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtGui.QStandardItemModel.mimeTypes": (),
-    "PySide2.QtGui.QStandardItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtGui.QStandardItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.setItem": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtGui.QStandardItemModel.setItemPrototype": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.setItemRoleNames": ('typing.Dict[int, PySide2.QtCore.QByteArray]',),
-    "PySide2.QtGui.QStandardItemModel.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setSortRole": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItemModel.sortRole": (),
-    "PySide2.QtGui.QStandardItemModel.supportedDropActions": (),
-    "PySide2.QtGui.QStandardItemModel.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeItem": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.verticalHeaderItem": ('int',),
-# class PySide2.QtGui.QStaticText:
-# class PySide2.QtGui.QStaticText.PerformanceHint:
-    "PySide2.QtGui.QStaticText.__init__": [(), ('PySide2.QtGui.QStaticText',), ('str',)],
-    "PySide2.QtGui.QStaticText.__copy__": (),
-    "PySide2.QtGui.QStaticText.performanceHint": (),
-    "PySide2.QtGui.QStaticText.prepare": ('PySide2.QtGui.QTransform', 'PySide2.QtGui.QFont'),
-    "PySide2.QtGui.QStaticText.setPerformanceHint": ('PySide2.QtGui.QStaticText.PerformanceHint',),
-    "PySide2.QtGui.QStaticText.setText": ('str',),
-    "PySide2.QtGui.QStaticText.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtGui.QStaticText.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QStaticText.setTextWidth": ('float',),
-    "PySide2.QtGui.QStaticText.size": (),
-    "PySide2.QtGui.QStaticText.swap": ('PySide2.QtGui.QStaticText',),
-    "PySide2.QtGui.QStaticText.text": (),
-    "PySide2.QtGui.QStaticText.textFormat": (),
-    "PySide2.QtGui.QStaticText.textOption": (),
-    "PySide2.QtGui.QStaticText.textWidth": (),
-# class PySide2.QtGui.QStatusTipEvent:
-    "PySide2.QtGui.QStatusTipEvent.__init__": ('str',),
-    "PySide2.QtGui.QStatusTipEvent.tip": (),
-# class PySide2.QtGui.QStyleHints:
-    "PySide2.QtGui.QStyleHints.cursorFlashTime": (),
-    "PySide2.QtGui.QStyleHints.fontSmoothingGamma": (),
-    "PySide2.QtGui.QStyleHints.keyboardAutoRepeatRate": (),
-    "PySide2.QtGui.QStyleHints.keyboardInputInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickDistance": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickInterval": (),
-    "PySide2.QtGui.QStyleHints.mousePressAndHoldInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseQuickSelectionThreshold": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskCharacter": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskDelay": (),
-    "PySide2.QtGui.QStyleHints.setCursorFlashTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setFocusOnTouchRelease": (),
-    "PySide2.QtGui.QStyleHints.setKeyboardInputInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseDoubleClickInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMousePressAndHoldInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseQuickSelectionThreshold": ('int',),
-    "PySide2.QtGui.QStyleHints.setShowShortcutsInContextMenus": ('bool',),
-    "PySide2.QtGui.QStyleHints.setStartDragDistance": ('int',),
-    "PySide2.QtGui.QStyleHints.setStartDragTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setTabFocusBehavior": ('PySide2.QtCore.Qt.TabFocusBehavior',),
-    "PySide2.QtGui.QStyleHints.setUseHoverEffects": ('bool',),
-    "PySide2.QtGui.QStyleHints.setWheelScrollLines": ('int',),
-    "PySide2.QtGui.QStyleHints.showIsFullScreen": (),
-    "PySide2.QtGui.QStyleHints.showIsMaximized": (),
-    "PySide2.QtGui.QStyleHints.showShortcutsInContextMenus": (),
-    "PySide2.QtGui.QStyleHints.singleClickActivation": (),
-    "PySide2.QtGui.QStyleHints.startDragDistance": (),
-    "PySide2.QtGui.QStyleHints.startDragTime": (),
-    "PySide2.QtGui.QStyleHints.startDragVelocity": (),
-    "PySide2.QtGui.QStyleHints.tabFocusBehavior": (),
-    "PySide2.QtGui.QStyleHints.touchDoubleTapDistance": (),
-    "PySide2.QtGui.QStyleHints.useHoverEffects": (),
-    "PySide2.QtGui.QStyleHints.useRtlExtensions": (),
-    "PySide2.QtGui.QStyleHints.wheelScrollLines": (),
-# class PySide2.QtGui.QSurface:
-# class PySide2.QtGui.QSurface.SurfaceClass:
-# class PySide2.QtGui.QSurface.SurfaceType:
-    "PySide2.QtGui.QSurface.__init__": ('PySide2.QtGui.QSurface.SurfaceClass',),
-    "PySide2.QtGui.QSurface.format": (),
-    "PySide2.QtGui.QSurface.size": (),
-    "PySide2.QtGui.QSurface.supportsOpenGL": (),
-    "PySide2.QtGui.QSurface.surfaceClass": (),
-    "PySide2.QtGui.QSurface.surfaceHandle": (),
-    "PySide2.QtGui.QSurface.surfaceType": (),
-# class PySide2.QtGui.QSurfaceFormat:
-# class PySide2.QtGui.QSurfaceFormat.ColorSpace:
-# class PySide2.QtGui.QSurfaceFormat.FormatOption:
-# class PySide2.QtGui.QSurfaceFormat.FormatOptions:
-# class PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile:
-# class PySide2.QtGui.QSurfaceFormat.RenderableType:
-# class PySide2.QtGui.QSurfaceFormat.SwapBehavior:
-    "PySide2.QtGui.QSurfaceFormat.__init__": [(), ('PySide2.QtGui.QSurfaceFormat',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.__copy__": (),
-    "PySide2.QtGui.QSurfaceFormat.alphaBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.blueBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.colorSpace": (),
-    "PySide2.QtGui.QSurfaceFormat.defaultFormat": (),
-    "PySide2.QtGui.QSurfaceFormat.depthBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.greenBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.hasAlpha": (),
-    "PySide2.QtGui.QSurfaceFormat.majorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.minorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.options": (),
-    "PySide2.QtGui.QSurfaceFormat.profile": (),
-    "PySide2.QtGui.QSurfaceFormat.redBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.renderableType": (),
-    "PySide2.QtGui.QSurfaceFormat.samples": (),
-    "PySide2.QtGui.QSurfaceFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setColorSpace": ('PySide2.QtGui.QSurfaceFormat.ColorSpace',),
-    "PySide2.QtGui.QSurfaceFormat.setDefaultFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QSurfaceFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMajorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMinorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption', 'bool'), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.setOptions": ('PySide2.QtGui.QSurfaceFormat.FormatOptions',),
-    "PySide2.QtGui.QSurfaceFormat.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QSurfaceFormat.setRedBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setRenderableType": ('PySide2.QtGui.QSurfaceFormat.RenderableType',),
-    "PySide2.QtGui.QSurfaceFormat.setSamples": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStereo": ('bool',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapBehavior": ('PySide2.QtGui.QSurfaceFormat.SwapBehavior',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapInterval": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QSurfaceFormat.stencilBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.stereo": (),
-    "PySide2.QtGui.QSurfaceFormat.swapBehavior": (),
-    "PySide2.QtGui.QSurfaceFormat.swapInterval": (),
-    "PySide2.QtGui.QSurfaceFormat.testOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.version": (),
-# class PySide2.QtGui.QSyntaxHighlighter:
-    "PySide2.QtGui.QSyntaxHighlighter.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QTextDocument',)],
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlock": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockUserData": (),
-    "PySide2.QtGui.QSyntaxHighlighter.document": (),
-    "PySide2.QtGui.QSyntaxHighlighter.format": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.highlightBlock": ('str',),
-    "PySide2.QtGui.QSyntaxHighlighter.previousBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlight": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlightBlock": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockState": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QSyntaxHighlighter.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QSyntaxHighlighter.setFormat": [('int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QFont'), ('int', 'int', 'PySide2.QtGui.QTextCharFormat')],
-# class PySide2.QtGui.QTabletEvent:
-# class PySide2.QtGui.QTabletEvent.PointerType:
-# class PySide2.QtGui.QTabletEvent.TabletDevice:
-    "PySide2.QtGui.QTabletEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons')],
-    "PySide2.QtGui.QTabletEvent.button": (),
-    "PySide2.QtGui.QTabletEvent.buttons": (),
-    "PySide2.QtGui.QTabletEvent.device": (),
-    "PySide2.QtGui.QTabletEvent.globalPos": (),
-    "PySide2.QtGui.QTabletEvent.globalPosF": (),
-    "PySide2.QtGui.QTabletEvent.globalX": (),
-    "PySide2.QtGui.QTabletEvent.global""Y": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobalX": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobal""Y": (),
-    "PySide2.QtGui.QTabletEvent.pointerType": (),
-    "PySide2.QtGui.QTabletEvent.pos": (),
-    "PySide2.QtGui.QTabletEvent.posF": (),
-    "PySide2.QtGui.QTabletEvent.pressure": (),
-    "PySide2.QtGui.QTabletEvent.rotation": (),
-    "PySide2.QtGui.QTabletEvent.tangentialPressure": (),
-    "PySide2.QtGui.QTabletEvent.uniqueId": (),
-    "PySide2.QtGui.QTabletEvent.x": (),
-    "PySide2.QtGui.QTabletEvent.xTilt": (),
-    "PySide2.QtGui.QTabletEvent.y": (),
-    "PySide2.QtGui.QTabletEvent.yTilt": (),
-    "PySide2.QtGui.QTabletEvent.z": (),
-# class PySide2.QtGui.QTextBlock:
-# class PySide2.QtGui.QTextBlock.iterator:
-    "PySide2.QtGui.QTextBlock.iterator.__init__": [(), ('PySide2.QtGui.QTextBlock.iterator',)],
-    "PySide2.QtGui.QTextBlock.iterator.__copy__": (),
-    "PySide2.QtGui.QTextBlock.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__iter__": (),
-    "PySide2.QtGui.QTextBlock.iterator.atEnd": (),
-    "PySide2.QtGui.QTextBlock.iterator.fragment": (),
-    "PySide2.QtGui.QTextBlock.__init__": [(), ('PySide2.QtGui.QTextBlock',)],
-    "PySide2.QtGui.QTextBlock.__copy__": (),
-    "PySide2.QtGui.QTextBlock.__iter__": (),
-    "PySide2.QtGui.QTextBlock.begin": (),
-    "PySide2.QtGui.QTextBlock.blockFormat": (),
-    "PySide2.QtGui.QTextBlock.blockFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.blockNumber": (),
-    "PySide2.QtGui.QTextBlock.charFormat": (),
-    "PySide2.QtGui.QTextBlock.charFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.clearLayout": (),
-    "PySide2.QtGui.QTextBlock.contains": ('int',),
-    "PySide2.QtGui.QTextBlock.document": (),
-    "PySide2.QtGui.QTextBlock.end": (),
-    "PySide2.QtGui.QTextBlock.firstLineNumber": (),
-    "PySide2.QtGui.QTextBlock.fragmentIndex": (),
-    "PySide2.QtGui.QTextBlock.isValid": (),
-    "PySide2.QtGui.QTextBlock.isVisible": (),
-    "PySide2.QtGui.QTextBlock.layout": (),
-    "PySide2.QtGui.QTextBlock.length": (),
-    "PySide2.QtGui.QTextBlock.lineCount": (),
-    "PySide2.QtGui.QTextBlock.position": (),
-    "PySide2.QtGui.QTextBlock.previous": (),
-    "PySide2.QtGui.QTextBlock.revision": (),
-    "PySide2.QtGui.QTextBlock.setLineCount": ('int',),
-    "PySide2.QtGui.QTextBlock.setRevision": ('int',),
-    "PySide2.QtGui.QTextBlock.setUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QTextBlock.setUserState": ('int',),
-    "PySide2.QtGui.QTextBlock.setVisible": ('bool',),
-    "PySide2.QtGui.QTextBlock.text": (),
-    "PySide2.QtGui.QTextBlock.textDirection": (),
-    "PySide2.QtGui.QTextBlock.textFormats": (),
-    "PySide2.QtGui.QTextBlock.textList": (),
-    "PySide2.QtGui.QTextBlock.userData": (),
-    "PySide2.QtGui.QTextBlock.userState": (),
-# class PySide2.QtGui.QTextBlockFormat:
-# class PySide2.QtGui.QTextBlockFormat.LineHeightTypes:
-# class PySide2.QtGui.QTextBlockFormat.MarkerType:
-    "PySide2.QtGui.QTextBlockFormat.__init__": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextBlockFormat.__copy__": (),
-    "PySide2.QtGui.QTextBlockFormat.alignment": (),
-    "PySide2.QtGui.QTextBlockFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.headingLevel": (),
-    "PySide2.QtGui.QTextBlockFormat.indent": (),
-    "PySide2.QtGui.QTextBlockFormat.isValid": (),
-    "PySide2.QtGui.QTextBlockFormat.leftMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.lineHeight": [(), ('float', 'float')],
-    "PySide2.QtGui.QTextBlockFormat.lineHeightType": (),
-    "PySide2.QtGui.QTextBlockFormat.marker": (),
-    "PySide2.QtGui.QTextBlockFormat.nonBreakableLines": (),
-    "PySide2.QtGui.QTextBlockFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextBlockFormat.rightMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextBlockFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setHeadingLevel": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setLineHeight": ('float', 'int'),
-    "PySide2.QtGui.QTextBlockFormat.setMarker": ('PySide2.QtGui.QTextBlockFormat.MarkerType',),
-    "PySide2.QtGui.QTextBlockFormat.setNonBreakableLines": ('bool',),
-    "PySide2.QtGui.QTextBlockFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextBlockFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTabPositions": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextBlockFormat.setTextIndent": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.tabPositions": (),
-    "PySide2.QtGui.QTextBlockFormat.textIndent": (),
-    "PySide2.QtGui.QTextBlockFormat.topMargin": (),
-# class PySide2.QtGui.QTextBlockGroup:
-    "PySide2.QtGui.QTextBlockGroup.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextBlockGroup.blockFormatChanged": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockInserted": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockList": (),
-    "PySide2.QtGui.QTextBlockGroup.blockRemoved": ('PySide2.QtGui.QTextBlock',),
-# class PySide2.QtGui.QTextBlockUserData:
-    "PySide2.QtGui.QTextBlockUserData.__init__": (),
-# class PySide2.QtGui.QTextCharFormat:
-# class PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior:
-# class PySide2.QtGui.QTextCharFormat.UnderlineStyle:
-# class PySide2.QtGui.QTextCharFormat.VerticalAlignment:
-    "PySide2.QtGui.QTextCharFormat.__init__": [(), ('PySide2.QtGui.QTextCharFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextCharFormat.__copy__": (),
-    "PySide2.QtGui.QTextCharFormat.anchorHref": (),
-    "PySide2.QtGui.QTextCharFormat.anchorName": (),
-    "PySide2.QtGui.QTextCharFormat.anchorNames": (),
-    "PySide2.QtGui.QTextCharFormat.font": (),
-    "PySide2.QtGui.QTextCharFormat.fontCapitalization": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamilies": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamily": (),
-    "PySide2.QtGui.QTextCharFormat.fontFixedPitch": (),
-    "PySide2.QtGui.QTextCharFormat.fontHintingPreference": (),
-    "PySide2.QtGui.QTextCharFormat.fontItalic": (),
-    "PySide2.QtGui.QTextCharFormat.fontKerning": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacingType": (),
-    "PySide2.QtGui.QTextCharFormat.fontOverline": (),
-    "PySide2.QtGui.QTextCharFormat.fontPointSize": (),
-    "PySide2.QtGui.QTextCharFormat.fontStretch": (),
-    "PySide2.QtGui.QTextCharFormat.fontStrikeOut": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleHint": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleName": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleStrategy": (),
-    "PySide2.QtGui.QTextCharFormat.fontUnderline": (),
-    "PySide2.QtGui.QTextCharFormat.fontWeight": (),
-    "PySide2.QtGui.QTextCharFormat.fontWordSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.isAnchor": (),
-    "PySide2.QtGui.QTextCharFormat.isValid": (),
-    "PySide2.QtGui.QTextCharFormat.setAnchor": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorHref": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorNames": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior')],
-    "PySide2.QtGui.QTextCharFormat.setFontCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamily": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontFixedPitch": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QTextCharFormat.setFontItalic": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontKerning": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacingType": ('PySide2.QtGui.QFont.SpacingType',),
-    "PySide2.QtGui.QTextCharFormat.setFontOverline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontPointSize": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontStretch": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontStrikeOut": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QTextCharFormat.setFontUnderline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontWeight": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontWordSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellColumnSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellRowSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTextOutline": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QTextCharFormat.setToolTip": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineStyle": ('PySide2.QtGui.QTextCharFormat.UnderlineStyle',),
-    "PySide2.QtGui.QTextCharFormat.setVerticalAlignment": ('PySide2.QtGui.QTextCharFormat.VerticalAlignment',),
-    "PySide2.QtGui.QTextCharFormat.tableCellColumnSpan": (),
-    "PySide2.QtGui.QTextCharFormat.tableCellRowSpan": (),
-    "PySide2.QtGui.QTextCharFormat.textOutline": (),
-    "PySide2.QtGui.QTextCharFormat.toolTip": (),
-    "PySide2.QtGui.QTextCharFormat.underlineColor": (),
-    "PySide2.QtGui.QTextCharFormat.underlineStyle": (),
-    "PySide2.QtGui.QTextCharFormat.verticalAlignment": (),
-# class PySide2.QtGui.QTextCursor:
-# class PySide2.QtGui.QTextCursor.MoveMode:
-# class PySide2.QtGui.QTextCursor.MoveOperation:
-# class PySide2.QtGui.QTextCursor.SelectionType:
-    "PySide2.QtGui.QTextCursor.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextFrame',)],
-    "PySide2.QtGui.QTextCursor.__copy__": (),
-    "PySide2.QtGui.QTextCursor.anchor": (),
-    "PySide2.QtGui.QTextCursor.atBlockEnd": (),
-    "PySide2.QtGui.QTextCursor.atBlockStart": (),
-    "PySide2.QtGui.QTextCursor.atEnd": (),
-    "PySide2.QtGui.QTextCursor.atStart": (),
-    "PySide2.QtGui.QTextCursor.beginEditBlock": (),
-    "PySide2.QtGui.QTextCursor.block": (),
-    "PySide2.QtGui.QTextCursor.blockCharFormat": (),
-    "PySide2.QtGui.QTextCursor.blockFormat": (),
-    "PySide2.QtGui.QTextCursor.blockNumber": (),
-    "PySide2.QtGui.QTextCursor.charFormat": (),
-    "PySide2.QtGui.QTextCursor.clearSelection": (),
-    "PySide2.QtGui.QTextCursor.columnNumber": (),
-    "PySide2.QtGui.QTextCursor.createList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.currentFrame": (),
-    "PySide2.QtGui.QTextCursor.currentList": (),
-    "PySide2.QtGui.QTextCursor.currentTable": (),
-    "PySide2.QtGui.QTextCursor.deleteChar": (),
-    "PySide2.QtGui.QTextCursor.deletePreviousChar": (),
-    "PySide2.QtGui.QTextCursor.document": (),
-    "PySide2.QtGui.QTextCursor.endEditBlock": (),
-    "PySide2.QtGui.QTextCursor.hasComplexSelection": (),
-    "PySide2.QtGui.QTextCursor.hasSelection": (),
-    "PySide2.QtGui.QTextCursor.insertBlock": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextBlockFormat', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.insertFragment": ('PySide2.QtGui.QTextDocumentFragment',),
-    "PySide2.QtGui.QTextCursor.insertFrame": ('PySide2.QtGui.QTextFrameFormat',),
-    "PySide2.QtGui.QTextCursor.insertHtml": ('str',),
-    "PySide2.QtGui.QTextCursor.insertImage": [('PySide2.QtGui.QImage', 'str'), ('PySide2.QtGui.QTextImageFormat',), ('PySide2.QtGui.QTextImageFormat', 'PySide2.QtGui.QTextFrameFormat.Position'), ('str',)],
-    "PySide2.QtGui.QTextCursor.insertList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.insertTable": [('int', 'int'), ('int', 'int', 'PySide2.QtGui.QTextTableFormat')],
-    "PySide2.QtGui.QTextCursor.insertText": [('str',), ('str', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.isCopyOf": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.isNull": (),
-    "PySide2.QtGui.QTextCursor.joinPreviousEditBlock": (),
-    "PySide2.QtGui.QTextCursor.keepPositionOnInsert": (),
-    "PySide2.QtGui.QTextCursor.mergeBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.mergeBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.mergeCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.movePosition": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode', 'int'),
-    "PySide2.QtGui.QTextCursor.position": (),
-    "PySide2.QtGui.QTextCursor.positionInBlock": (),
-    "PySide2.QtGui.QTextCursor.removeSelectedText": (),
-    "PySide2.QtGui.QTextCursor.select": ('PySide2.QtGui.QTextCursor.SelectionType',),
-    "PySide2.QtGui.QTextCursor.selectedTableCells": (),
-    "PySide2.QtGui.QTextCursor.selectedText": (),
-    "PySide2.QtGui.QTextCursor.selection": (),
-    "PySide2.QtGui.QTextCursor.selectionEnd": (),
-    "PySide2.QtGui.QTextCursor.selectionStart": (),
-    "PySide2.QtGui.QTextCursor.setBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.setCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setKeepPositionOnInsert": ('bool',),
-    "PySide2.QtGui.QTextCursor.setPosition": ('int', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtGui.QTextCursor.setVerticalMovementX": ('int',),
-    "PySide2.QtGui.QTextCursor.setVisualNavigation": ('bool',),
-    "PySide2.QtGui.QTextCursor.swap": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.verticalMovementX": (),
-    "PySide2.QtGui.QTextCursor.visualNavigation": (),
-# class PySide2.QtGui.QTextDocument:
-# class PySide2.QtGui.QTextDocument.FindFlag:
-# class PySide2.QtGui.QTextDocument.FindFlags:
-# class PySide2.QtGui.QTextDocument.MarkdownFeature:
-# class PySide2.QtGui.QTextDocument.MarkdownFeatures:
-# class PySide2.QtGui.QTextDocument.MetaInformation:
-# class PySide2.QtGui.QTextDocument.ResourceType:
-# class PySide2.QtGui.QTextDocument.Stacks:
-    "PySide2.QtGui.QTextDocument.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QTextDocument.addResource": ('int', 'PySide2.QtCore.QUrl', 'typing.Any'),
-    "PySide2.QtGui.QTextDocument.adjustSize": (),
-    "PySide2.QtGui.QTextDocument.allFormats": (),
-    "PySide2.QtGui.QTextDocument.availableRedoSteps": (),
-    "PySide2.QtGui.QTextDocument.availableUndoSteps": (),
-    "PySide2.QtGui.QTextDocument.baseUrl": (),
-    "PySide2.QtGui.QTextDocument.begin": (),
-    "PySide2.QtGui.QTextDocument.blockCount": (),
-    "PySide2.QtGui.QTextDocument.characterAt": ('int',),
-    "PySide2.QtGui.QTextDocument.characterCount": (),
-    "PySide2.QtGui.QTextDocument.clear": (),
-    "PySide2.QtGui.QTextDocument.clearUndoRedoStacks": ('PySide2.QtGui.QTextDocument.Stacks',),
-    "PySide2.QtGui.QTextDocument.clone": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTextDocument.createObject": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.defaultCursorMoveStyle": (),
-    "PySide2.QtGui.QTextDocument.defaultFont": (),
-    "PySide2.QtGui.QTextDocument.defaultStyleSheet": (),
-    "PySide2.QtGui.QTextDocument.defaultTextOption": (),
-    "PySide2.QtGui.QTextDocument.documentLayout": (),
-    "PySide2.QtGui.QTextDocument.documentMargin": (),
-    "PySide2.QtGui.QTextDocument.drawContents": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextDocument.end": (),
-    "PySide2.QtGui.QTextDocument.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegExp', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'int', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtGui.QTextDocument.findBlock": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByLineNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.firstBlock": (),
-    "PySide2.QtGui.QTextDocument.frameAt": ('int',),
-    "PySide2.QtGui.QTextDocument.idealWidth": (),
-    "PySide2.QtGui.QTextDocument.indentWidth": (),
-    "PySide2.QtGui.QTextDocument.isEmpty": (),
-    "PySide2.QtGui.QTextDocument.isModified": (),
-    "PySide2.QtGui.QTextDocument.isRedoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoRedoEnabled": (),
-    "PySide2.QtGui.QTextDocument.lastBlock": (),
-    "PySide2.QtGui.QTextDocument.lineCount": (),
-    "PySide2.QtGui.QTextDocument.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.markContentsDirty": ('int', 'int'),
-    "PySide2.QtGui.QTextDocument.maximumBlockCount": (),
-    "PySide2.QtGui.QTextDocument.metaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation',),
-    "PySide2.QtGui.QTextDocument.object": ('int',),
-    "PySide2.QtGui.QTextDocument.objectForFormat": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.pageCount": (),
-    "PySide2.QtGui.QTextDocument.pageSize": (),
-    "PySide2.QtGui.QTextDocument.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtGui.QTextDocument.redo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.resource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.revision": (),
-    "PySide2.QtGui.QTextDocument.rootFrame": (),
-    "PySide2.QtGui.QTextDocument.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QTextDocument.setDefaultCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextDocument.setDefaultFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextDocument.setDefaultStyleSheet": ('str',),
-    "PySide2.QtGui.QTextDocument.setDefaultTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextDocument.setDocumentLayout": ('PySide2.QtGui.QAbstractTextDocumentLayout',),
-    "PySide2.QtGui.QTextDocument.setDocumentMargin": ('float',),
-    "PySide2.QtGui.QTextDocument.setHtml": ('str',),
-    "PySide2.QtGui.QTextDocument.setIndentWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setMarkdown": ('str', 'PySide2.QtGui.QTextDocument.MarkdownFeatures'),
-    "PySide2.QtGui.QTextDocument.setMaximumBlockCount": ('int',),
-    "PySide2.QtGui.QTextDocument.setMetaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation', 'str'),
-    "PySide2.QtGui.QTextDocument.setModified": ('bool',),
-    "PySide2.QtGui.QTextDocument.setPageSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTextDocument.setPlainText": ('str',),
-    "PySide2.QtGui.QTextDocument.setTextWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtGui.QTextDocument.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextDocument.size": (),
-    "PySide2.QtGui.QTextDocument.textWidth": (),
-    "PySide2.QtGui.QTextDocument.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocument.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtGui.QTextDocument.toPlainText": (),
-    "PySide2.QtGui.QTextDocument.toRawText": (),
-    "PySide2.QtGui.QTextDocument.undo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.useDesignMetrics": (),
-# class PySide2.QtGui.QTextDocumentFragment:
-    "PySide2.QtGui.QTextDocumentFragment.__init__": [(), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-    "PySide2.QtGui.QTextDocumentFragment.__copy__": (),
-    "PySide2.QtGui.QTextDocumentFragment.fromHtml": [('str',), ('str', 'PySide2.QtGui.QTextDocument')],
-    "PySide2.QtGui.QTextDocumentFragment.fromPlainText": ('str',),
-    "PySide2.QtGui.QTextDocumentFragment.isEmpty": (),
-    "PySide2.QtGui.QTextDocumentFragment.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentFragment.toPlainText": (),
-# class PySide2.QtGui.QTextDocumentWriter:
-    "PySide2.QtGui.QTextDocumentWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QTextDocumentWriter.codec": (),
-    "PySide2.QtGui.QTextDocumentWriter.device": (),
-    "PySide2.QtGui.QTextDocumentWriter.fileName": (),
-    "PySide2.QtGui.QTextDocumentWriter.format": (),
-    "PySide2.QtGui.QTextDocumentWriter.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtGui.QTextDocumentWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QTextDocumentWriter.setFileName": ('str',),
-    "PySide2.QtGui.QTextDocumentWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentWriter.supportedDocumentFormats": (),
-    "PySide2.QtGui.QTextDocumentWriter.write": [('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-# class PySide2.QtGui.QTextFormat:
-# class PySide2.QtGui.QTextFormat.FormatType:
-# class PySide2.QtGui.QTextFormat.ObjectTypes:
-# class PySide2.QtGui.QTextFormat.PageBreakFlag:
-# class PySide2.QtGui.QTextFormat.PageBreakFlags:
-# class PySide2.QtGui.QTextFormat.Property:
-    "PySide2.QtGui.QTextFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('int',)],
-    "PySide2.QtGui.QTextFormat.__copy__": (),
-    "PySide2.QtGui.QTextFormat.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.background": (),
-    "PySide2.QtGui.QTextFormat.boolProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.brushProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.clearBackground": (),
-    "PySide2.QtGui.QTextFormat.clearForeground": (),
-    "PySide2.QtGui.QTextFormat.clearProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.colorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.doubleProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.foreground": (),
-    "PySide2.QtGui.QTextFormat.hasProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.intProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.isBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.isCharFormat": (),
-    "PySide2.QtGui.QTextFormat.isEmpty": (),
-    "PySide2.QtGui.QTextFormat.isFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.isImageFormat": (),
-    "PySide2.QtGui.QTextFormat.isListFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableFormat": (),
-    "PySide2.QtGui.QTextFormat.isValid": (),
-    "PySide2.QtGui.QTextFormat.layoutDirection": (),
-    "PySide2.QtGui.QTextFormat.lengthProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.lengthVectorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.merge": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.objectIndex": (),
-    "PySide2.QtGui.QTextFormat.objectType": (),
-    "PySide2.QtGui.QTextFormat.penProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.properties": (),
-    "PySide2.QtGui.QTextFormat.property": ('int',),
-    "PySide2.QtGui.QTextFormat.propertyCount": (),
-    "PySide2.QtGui.QTextFormat.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextFormat.setObjectIndex": ('int',),
-    "PySide2.QtGui.QTextFormat.setObjectType": ('int',),
-    "PySide2.QtGui.QTextFormat.setProperty": [('int', 'typing.Any'), ('int', 'typing.List[PySide2.QtGui.QTextLength]')],
-    "PySide2.QtGui.QTextFormat.stringProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.swap": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.toBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.toCharFormat": (),
-    "PySide2.QtGui.QTextFormat.toFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.toImageFormat": (),
-    "PySide2.QtGui.QTextFormat.toListFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableFormat": (),
-    "PySide2.QtGui.QTextFormat.type": (),
-# class PySide2.QtGui.QTextFragment:
-    "PySide2.QtGui.QTextFragment.__init__": [(), ('PySide2.QtGui.QTextFragment',)],
-    "PySide2.QtGui.QTextFragment.__copy__": (),
-    "PySide2.QtGui.QTextFragment.charFormat": (),
-    "PySide2.QtGui.QTextFragment.charFormatIndex": (),
-    "PySide2.QtGui.QTextFragment.contains": ('int',),
-    "PySide2.QtGui.QTextFragment.isValid": (),
-    "PySide2.QtGui.QTextFragment.length": (),
-    "PySide2.QtGui.QTextFragment.position": (),
-    "PySide2.QtGui.QTextFragment.text": (),
-# class PySide2.QtGui.QTextFrame:
-# class PySide2.QtGui.QTextFrame.iterator:
-    "PySide2.QtGui.QTextFrame.iterator.__init__": [(), ('PySide2.QtGui.QTextFrame.iterator',)],
-    "PySide2.QtGui.QTextFrame.iterator.__copy__": (),
-    "PySide2.QtGui.QTextFrame.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__iter__": (),
-    "PySide2.QtGui.QTextFrame.iterator.atEnd": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentBlock": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentFrame": (),
-    "PySide2.QtGui.QTextFrame.iterator.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextFrame.__iter__": (),
-    "PySide2.QtGui.QTextFrame.begin": (),
-    "PySide2.QtGui.QTextFrame.childFrames": (),
-    "PySide2.QtGui.QTextFrame.end": (),
-    "PySide2.QtGui.QTextFrame.firstCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.firstPosition": (),
-    "PySide2.QtGui.QTextFrame.frameFormat": (),
-    "PySide2.QtGui.QTextFrame.lastCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.lastPosition": (),
-    "PySide2.QtGui.QTextFrame.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.setFrameFormat": ('PySide2.QtGui.QTextFrameFormat',),
-# class PySide2.QtGui.QTextFrameFormat:
-# class PySide2.QtGui.QTextFrameFormat.BorderStyle:
-# class PySide2.QtGui.QTextFrameFormat.Position:
-    "PySide2.QtGui.QTextFrameFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextFrameFormat',)],
-    "PySide2.QtGui.QTextFrameFormat.__copy__": (),
-    "PySide2.QtGui.QTextFrameFormat.border": (),
-    "PySide2.QtGui.QTextFrameFormat.borderBrush": (),
-    "PySide2.QtGui.QTextFrameFormat.borderStyle": (),
-    "PySide2.QtGui.QTextFrameFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.height": (),
-    "PySide2.QtGui.QTextFrameFormat.isValid": (),
-    "PySide2.QtGui.QTextFrameFormat.leftMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.margin": (),
-    "PySide2.QtGui.QTextFrameFormat.padding": (),
-    "PySide2.QtGui.QTextFrameFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextFrameFormat.position": (),
-    "PySide2.QtGui.QTextFrameFormat.rightMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextFrameFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setHeight": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextFrameFormat.setPosition": ('PySide2.QtGui.QTextFrameFormat.Position',),
-    "PySide2.QtGui.QTextFrameFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setWidth": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.topMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.width": (),
-# class PySide2.QtGui.QTextImageFormat:
-    "PySide2.QtGui.QTextImageFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextImageFormat',)],
-    "PySide2.QtGui.QTextImageFormat.__copy__": (),
-    "PySide2.QtGui.QTextImageFormat.height": (),
-    "PySide2.QtGui.QTextImageFormat.isValid": (),
-    "PySide2.QtGui.QTextImageFormat.name": (),
-    "PySide2.QtGui.QTextImageFormat.quality": (),
-    "PySide2.QtGui.QTextImageFormat.setHeight": ('float',),
-    "PySide2.QtGui.QTextImageFormat.setName": ('str',),
-    "PySide2.QtGui.QTextImageFormat.setQuality": ('int',),
-    "PySide2.QtGui.QTextImageFormat.setWidth": ('float',),
-    "PySide2.QtGui.QTextImageFormat.width": (),
-# class PySide2.QtGui.QTextInlineObject:
-    "PySide2.QtGui.QTextInlineObject.__init__": (),
-    "PySide2.QtGui.QTextInlineObject.__copy__": (),
-    "PySide2.QtGui.QTextInlineObject.ascent": (),
-    "PySide2.QtGui.QTextInlineObject.descent": (),
-    "PySide2.QtGui.QTextInlineObject.format": (),
-    "PySide2.QtGui.QTextInlineObject.formatIndex": (),
-    "PySide2.QtGui.QTextInlineObject.height": (),
-    "PySide2.QtGui.QTextInlineObject.isValid": (),
-    "PySide2.QtGui.QTextInlineObject.rect": (),
-    "PySide2.QtGui.QTextInlineObject.setAscent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setDescent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setWidth": ('float',),
-    "PySide2.QtGui.QTextInlineObject.textDirection": (),
-    "PySide2.QtGui.QTextInlineObject.textPosition": (),
-    "PySide2.QtGui.QTextInlineObject.width": (),
-# class PySide2.QtGui.QTextItem:
-# class PySide2.QtGui.QTextItem.RenderFlag:
-# class PySide2.QtGui.QTextItem.RenderFlags:
-    "PySide2.QtGui.QTextItem.__init__": (),
-    "PySide2.QtGui.QTextItem.ascent": (),
-    "PySide2.QtGui.QTextItem.descent": (),
-    "PySide2.QtGui.QTextItem.font": (),
-    "PySide2.QtGui.QTextItem.renderFlags": (),
-    "PySide2.QtGui.QTextItem.text": (),
-    "PySide2.QtGui.QTextItem.width": (),
-# class PySide2.QtGui.QTextLayout:
-# class PySide2.QtGui.QTextLayout.CursorMode:
-# class PySide2.QtGui.QTextLayout.FormatRange:
-    "PySide2.QtGui.QTextLayout.FormatRange.__init__": [(), ('PySide2.QtGui.QTextLayout.FormatRange',)],
-    "PySide2.QtGui.QTextLayout.FormatRange.__copy__": (),
-    "PySide2.QtGui.QTextLayout.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('str',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice')],
-    "PySide2.QtGui.QTextLayout.additionalFormats": (),
-    "PySide2.QtGui.QTextLayout.beginLayout": (),
-    "PySide2.QtGui.QTextLayout.boundingRect": (),
-    "PySide2.QtGui.QTextLayout.cacheEnabled": (),
-    "PySide2.QtGui.QTextLayout.clearAdditionalFormats": (),
-    "PySide2.QtGui.QTextLayout.clearFormats": (),
-    "PySide2.QtGui.QTextLayout.clearLayout": (),
-    "PySide2.QtGui.QTextLayout.createLine": (),
-    "PySide2.QtGui.QTextLayout.cursorMoveStyle": (),
-    "PySide2.QtGui.QTextLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'typing.List[PySide2.QtGui.QTextLayout.FormatRange]', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextLayout.drawCursor": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int', 'int')],
-    "PySide2.QtGui.QTextLayout.endLayout": (),
-    "PySide2.QtGui.QTextLayout.font": (),
-    "PySide2.QtGui.QTextLayout.formats": (),
-    "PySide2.QtGui.QTextLayout.isValidCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.leftCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.lineAt": ('int',),
-    "PySide2.QtGui.QTextLayout.lineCount": (),
-    "PySide2.QtGui.QTextLayout.lineForTextPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.maximumWidth": (),
-    "PySide2.QtGui.QTextLayout.minimumWidth": (),
-    "PySide2.QtGui.QTextLayout.nextCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.position": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaPosition": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaText": (),
-    "PySide2.QtGui.QTextLayout.previousCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.rightCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.setAdditionalFormats": ('typing.Sequence[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setCacheEnabled": ('bool',),
-    "PySide2.QtGui.QTextLayout.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextLayout.setFlags": ('int',),
-    "PySide2.QtGui.QTextLayout.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextLayout.setFormats": ('typing.List[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLayout.setPreeditArea": ('int', 'str'),
-    "PySide2.QtGui.QTextLayout.setRawFont": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QTextLayout.setText": ('str',),
-    "PySide2.QtGui.QTextLayout.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextLayout.text": (),
-    "PySide2.QtGui.QTextLayout.textOption": (),
-# class PySide2.QtGui.QTextLength:
-# class PySide2.QtGui.QTextLength.Type:
-    "PySide2.QtGui.QTextLength.__init__": [(), ('PySide2.QtGui.QTextLength',), ('PySide2.QtGui.QTextLength.Type', 'float')],
-    "PySide2.QtGui.QTextLength.__copy__": (),
-    "PySide2.QtGui.QTextLength.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.rawValue": (),
-    "PySide2.QtGui.QTextLength.type": (),
-    "PySide2.QtGui.QTextLength.value": ('float',),
-# class PySide2.QtGui.QTextLine:
-# class PySide2.QtGui.QTextLine.CursorPosition:
-# class PySide2.QtGui.QTextLine.Edge:
-    "PySide2.QtGui.QTextLine.__init__": (),
-    "PySide2.QtGui.QTextLine.__copy__": (),
-    "PySide2.QtGui.QTextLine.ascent": (),
-    "PySide2.QtGui.QTextLine.cursorToX": ('int', 'PySide2.QtGui.QTextLine.Edge'),
-    "PySide2.QtGui.QTextLine.descent": (),
-    "PySide2.QtGui.QTextLine.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextLayout.FormatRange'),
-    "PySide2.QtGui.QTextLine.height": (),
-    "PySide2.QtGui.QTextLine.horizontalAdvance": (),
-    "PySide2.QtGui.QTextLine.isValid": (),
-    "PySide2.QtGui.QTextLine.leading": (),
-    "PySide2.QtGui.QTextLine.leadingIncluded": (),
-    "PySide2.QtGui.QTextLine.lineNumber": (),
-    "PySide2.QtGui.QTextLine.naturalTextRect": (),
-    "PySide2.QtGui.QTextLine.naturalTextWidth": (),
-    "PySide2.QtGui.QTextLine.position": (),
-    "PySide2.QtGui.QTextLine.rect": (),
-    "PySide2.QtGui.QTextLine.setLeadingIncluded": ('bool',),
-    "PySide2.QtGui.QTextLine.setLineWidth": ('float',),
-    "PySide2.QtGui.QTextLine.setNumColumns": [('int',), ('int', 'float')],
-    "PySide2.QtGui.QTextLine.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLine.textLength": (),
-    "PySide2.QtGui.QTextLine.textStart": (),
-    "PySide2.QtGui.QTextLine.width": (),
-    "PySide2.QtGui.QTextLine.x": (),
-    "PySide2.QtGui.QTextLine.xToCursor": ('float', 'PySide2.QtGui.QTextLine.CursorPosition'),
-    "PySide2.QtGui.QTextLine.y": (),
-# class PySide2.QtGui.QTextList:
-    "PySide2.QtGui.QTextList.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextList.add": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.count": (),
-    "PySide2.QtGui.QTextList.format": (),
-    "PySide2.QtGui.QTextList.item": ('int',),
-    "PySide2.QtGui.QTextList.itemNumber": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.itemText": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.remove": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.removeItem": ('int',),
-    "PySide2.QtGui.QTextList.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-# class PySide2.QtGui.QTextListFormat:
-# class PySide2.QtGui.QTextListFormat.Style:
-    "PySide2.QtGui.QTextListFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-    "PySide2.QtGui.QTextListFormat.__copy__": (),
-    "PySide2.QtGui.QTextListFormat.indent": (),
-    "PySide2.QtGui.QTextListFormat.isValid": (),
-    "PySide2.QtGui.QTextListFormat.numberPrefix": (),
-    "PySide2.QtGui.QTextListFormat.numberSuffix": (),
-    "PySide2.QtGui.QTextListFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextListFormat.setNumberPrefix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setNumberSuffix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setStyle": ('PySide2.QtGui.QTextListFormat.Style',),
-    "PySide2.QtGui.QTextListFormat.style": (),
-# class PySide2.QtGui.QTextObject:
-    "PySide2.QtGui.QTextObject.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextObject.document": (),
-    "PySide2.QtGui.QTextObject.format": (),
-    "PySide2.QtGui.QTextObject.formatIndex": (),
-    "PySide2.QtGui.QTextObject.objectIndex": (),
-    "PySide2.QtGui.QTextObject.setFormat": ('PySide2.QtGui.QTextFormat',),
-# class PySide2.QtGui.QTextObjectInterface:
-    "PySide2.QtGui.QTextObjectInterface.__init__": (),
-    "PySide2.QtGui.QTextObjectInterface.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QTextObjectInterface.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QTextOption:
-# class PySide2.QtGui.QTextOption.Flag:
-# class PySide2.QtGui.QTextOption.Flags:
-# class PySide2.QtGui.QTextOption.Tab:
-    "PySide2.QtGui.QTextOption.Tab.__init__": [(), ('PySide2.QtGui.QTextOption.Tab',), ('float', 'PySide2.QtGui.QTextOption.TabType', 'str')],
-    "PySide2.QtGui.QTextOption.Tab.__copy__": (),
-# class PySide2.QtGui.QTextOption.TabType:
-# class PySide2.QtGui.QTextOption.WrapMode:
-    "PySide2.QtGui.QTextOption.__init__": [(), ('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtGui.QTextOption',)],
-    "PySide2.QtGui.QTextOption.__copy__": (),
-    "PySide2.QtGui.QTextOption.alignment": (),
-    "PySide2.QtGui.QTextOption.flags": (),
-    "PySide2.QtGui.QTextOption.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextOption.setFlags": ('PySide2.QtGui.QTextOption.Flags',),
-    "PySide2.QtGui.QTextOption.setTabArray": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QTextOption.setTabStop": ('float',),
-    "PySide2.QtGui.QTextOption.setTabStopDistance": ('float',),
-    "PySide2.QtGui.QTextOption.setTabs": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextOption.setTextDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextOption.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextOption.setWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtGui.QTextOption.tabArray": (),
-    "PySide2.QtGui.QTextOption.tabStop": (),
-    "PySide2.QtGui.QTextOption.tabStopDistance": (),
-    "PySide2.QtGui.QTextOption.tabs": (),
-    "PySide2.QtGui.QTextOption.textDirection": (),
-    "PySide2.QtGui.QTextOption.useDesignMetrics": (),
-    "PySide2.QtGui.QTextOption.wrapMode": (),
-# class PySide2.QtGui.QTextTable:
-    "PySide2.QtGui.QTextTable.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextTable.appendColumns": ('int',),
-    "PySide2.QtGui.QTextTable.appendRows": ('int',),
-    "PySide2.QtGui.QTextTable.cellAt": [('PySide2.QtGui.QTextCursor',), ('int',), ('int', 'int')],
-    "PySide2.QtGui.QTextTable.columns": (),
-    "PySide2.QtGui.QTextTable.format": (),
-    "PySide2.QtGui.QTextTable.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.insertRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.mergeCells": [('PySide2.QtGui.QTextCursor',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QTextTable.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.resize": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.rowEnd": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rowStart": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rows": (),
-    "PySide2.QtGui.QTextTable.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTable.splitCell": ('int', 'int', 'int', 'int'),
-# class PySide2.QtGui.QTextTableCell:
-    "PySide2.QtGui.QTextTableCell.__init__": [(), ('PySide2.QtGui.QTextTableCell',)],
-    "PySide2.QtGui.QTextTableCell.__copy__": (),
-    "PySide2.QtGui.QTextTableCell.begin": (),
-    "PySide2.QtGui.QTextTableCell.column": (),
-    "PySide2.QtGui.QTextTableCell.columnSpan": (),
-    "PySide2.QtGui.QTextTableCell.end": (),
-    "PySide2.QtGui.QTextTableCell.firstCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.firstPosition": (),
-    "PySide2.QtGui.QTextTableCell.format": (),
-    "PySide2.QtGui.QTextTableCell.isValid": (),
-    "PySide2.QtGui.QTextTableCell.lastCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.lastPosition": (),
-    "PySide2.QtGui.QTextTableCell.row": (),
-    "PySide2.QtGui.QTextTableCell.rowSpan": (),
-    "PySide2.QtGui.QTextTableCell.setFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextTableCell.tableCellFormatIndex": (),
-# class PySide2.QtGui.QTextTableCellFormat:
-    "PySide2.QtGui.QTextTableCellFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableCellFormat',)],
-    "PySide2.QtGui.QTextTableCellFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.isValid": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.topBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.topPadding": (),
-# class PySide2.QtGui.QTextTableFormat:
-    "PySide2.QtGui.QTextTableFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTableFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableFormat.alignment": (),
-    "PySide2.QtGui.QTextTableFormat.borderCollapse": (),
-    "PySide2.QtGui.QTextTableFormat.cellPadding": (),
-    "PySide2.QtGui.QTextTableFormat.cellSpacing": (),
-    "PySide2.QtGui.QTextTableFormat.clearColumnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columns": (),
-    "PySide2.QtGui.QTextTableFormat.headerRowCount": (),
-    "PySide2.QtGui.QTextTableFormat.isValid": (),
-    "PySide2.QtGui.QTextTableFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextTableFormat.setBorderCollapse": ('bool',),
-    "PySide2.QtGui.QTextTableFormat.setCellPadding": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setCellSpacing": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setColumnWidthConstraints": ('typing.List[PySide2.QtGui.QTextLength]',),
-    "PySide2.QtGui.QTextTableFormat.setColumns": ('int',),
-    "PySide2.QtGui.QTextTableFormat.setHeaderRowCount": ('int',),
-# class PySide2.QtGui.QToolBarChangeEvent:
-    "PySide2.QtGui.QToolBarChangeEvent.__init__": ('bool',),
-    "PySide2.QtGui.QToolBarChangeEvent.toggle": (),
-# class PySide2.QtGui.QTouchDevice:
-# class PySide2.QtGui.QTouchDevice.Capabilities:
-# class PySide2.QtGui.QTouchDevice.CapabilityFlag:
-# class PySide2.QtGui.QTouchDevice.DeviceType:
-    "PySide2.QtGui.QTouchDevice.__init__": (),
-    "PySide2.QtGui.QTouchDevice.capabilities": (),
-    "PySide2.QtGui.QTouchDevice.devices": (),
-    "PySide2.QtGui.QTouchDevice.maximumTouchPoints": (),
-    "PySide2.QtGui.QTouchDevice.name": (),
-    "PySide2.QtGui.QTouchDevice.setCapabilities": ('PySide2.QtGui.QTouchDevice.Capabilities',),
-    "PySide2.QtGui.QTouchDevice.setMaximumTouchPoints": ('int',),
-    "PySide2.QtGui.QTouchDevice.setName": ('str',),
-    "PySide2.QtGui.QTouchDevice.setType": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtGui.QTouchDevice.type": (),
-# class PySide2.QtGui.QTouchEvent:
-# class PySide2.QtGui.QTouchEvent.TouchPoint:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlag:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags:
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__init__": [('PySide2.QtGui.QTouchEvent.TouchPoint',), ('int',)],
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__copy__": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.ellipseDiameters": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.flags": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.id": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.normalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pressure": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rawScreenPositions": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rotation": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.scenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.sceneRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setEllipseDiameters": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setFlags": ('PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPressure": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRawScreenPositions": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRotation": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setState": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setUniqueId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setVelocity": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.state": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.swap": ('PySide2.QtGui.QTouchEvent.TouchPoint',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.uniqueId": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.velocity": (),
-    "PySide2.QtGui.QTouchEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.TouchPointStates', 'typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]'),
-    "PySide2.QtGui.QTouchEvent.device": (),
-    "PySide2.QtGui.QTouchEvent.setDevice": ('PySide2.QtGui.QTouchDevice',),
-    "PySide2.QtGui.QTouchEvent.setTarget": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTouchEvent.setTouchPointStates": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.setTouchPoints": ('typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]',),
-    "PySide2.QtGui.QTouchEvent.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QTouchEvent.target": (),
-    "PySide2.QtGui.QTouchEvent.touchPointStates": (),
-    "PySide2.QtGui.QTouchEvent.touchPoints": (),
-    "PySide2.QtGui.QTouchEvent.window": (),
-# class PySide2.QtGui.QTransform:
-# class PySide2.QtGui.QTransform.TransformationType:
-    "PySide2.QtGui.QTransform.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QTransform.__add__": ('float',),
-    "PySide2.QtGui.QTransform.__copy__": (),
-    "PySide2.QtGui.QTransform.__iadd__": ('float',),
-    "PySide2.QtGui.QTransform.__imul__": [('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__isub__": ('float',),
-    "PySide2.QtGui.QTransform.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__reduce__": (),
-    "PySide2.QtGui.QTransform.__repr__": (),
-    "PySide2.QtGui.QTransform.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__sub__": ('float',),
-    "PySide2.QtGui.QTransform.adjoint": (),
-    "PySide2.QtGui.QTransform.det": (),
-    "PySide2.QtGui.QTransform.determinant": (),
-    "PySide2.QtGui.QTransform.dx": (),
-    "PySide2.QtGui.QTransform.dy": (),
-    "PySide2.QtGui.QTransform.fromScale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.fromTranslate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.inverted": (),
-    "PySide2.QtGui.QTransform.isAffine": (),
-    "PySide2.QtGui.QTransform.isIdentity": (),
-    "PySide2.QtGui.QTransform.isInvertible": (),
-    "PySide2.QtGui.QTransform.isRotating": (),
-    "PySide2.QtGui.QTransform.isScaling": (),
-    "PySide2.QtGui.QTransform.isTranslating": (),
-    "PySide2.QtGui.QTransform.m11": (),
-    "PySide2.QtGui.QTransform.m12": (),
-    "PySide2.QtGui.QTransform.m13": (),
-    "PySide2.QtGui.QTransform.m21": (),
-    "PySide2.QtGui.QTransform.m22": (),
-    "PySide2.QtGui.QTransform.m23": (),
-    "PySide2.QtGui.QTransform.m31": (),
-    "PySide2.QtGui.QTransform.m32": (),
-    "PySide2.QtGui.QTransform.m33": (),
-    "PySide2.QtGui.QTransform.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float')],
-    "PySide2.QtGui.QTransform.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QTransform.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QTransform.quadToQuad": [('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.quadToSquare": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.reset": (),
-    "PySide2.QtGui.QTransform.rotate": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.rotateRadians": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.scale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QTransform.shear": ('float', 'float'),
-    "PySide2.QtGui.QTransform.squareToQuad": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.toAffine": (),
-    "PySide2.QtGui.QTransform.translate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.transposed": (),
-    "PySide2.QtGui.QTransform.type": (),
-# class PySide2.QtGui.QValidator:
-# class PySide2.QtGui.QValidator.State:
-    "PySide2.QtGui.QValidator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QValidator.fixup": ('str',),
-    "PySide2.QtGui.QValidator.locale": (),
-    "PySide2.QtGui.QValidator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtGui.QValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QVector2D:
-    "PySide2.QtGui.QVector2D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',), ('float', 'float')],
-    "PySide2.QtGui.QVector2D.__add__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__copy__": (),
-    "PySide2.QtGui.QVector2D.__iadd__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__imul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__isub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__mul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__neg__": (),
-    "PySide2.QtGui.QVector2D.__reduce__": (),
-    "PySide2.QtGui.QVector2D.__repr__": (),
-    "PySide2.QtGui.QVector2D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__sub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.distanceToLine": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.distanceToPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.dotProduct": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.isNull": (),
-    "PySide2.QtGui.QVector2D.length": (),
-    "PySide2.QtGui.QVector2D.lengthSquared": (),
-    "PySide2.QtGui.QVector2D.normalize": (),
-    "PySide2.QtGui.QVector2D.normalized": (),
-    "PySide2.QtGui.QVector2D.setX": ('float',),
-    "PySide2.QtGui.QVector2D.setY": ('float',),
-    "PySide2.QtGui.QVector2D.toPoint": (),
-    "PySide2.QtGui.QVector2D.toPointF": (),
-    "PySide2.QtGui.QVector2D.toTuple": (),
-    "PySide2.QtGui.QVector2D.toVector3D": (),
-    "PySide2.QtGui.QVector2D.toVector4D": (),
-    "PySide2.QtGui.QVector2D.x": (),
-    "PySide2.QtGui.QVector2D.y": (),
-# class PySide2.QtGui.QVector3D:
-    "PySide2.QtGui.QVector3D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float'), ('PySide2.QtGui.QVector4D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QVector3D.__add__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__copy__": (),
-    "PySide2.QtGui.QVector3D.__iadd__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__imul__": [('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__isub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QQuaternion',), ('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__neg__": (),
-    "PySide2.QtGui.QVector3D.__reduce__": (),
-    "PySide2.QtGui.QVector3D.__repr__": (),
-    "PySide2.QtGui.QVector3D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__sub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.crossProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToLine": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToPlane": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.distanceToPoint": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.dotProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.isNull": (),
-    "PySide2.QtGui.QVector3D.length": (),
-    "PySide2.QtGui.QVector3D.lengthSquared": (),
-    "PySide2.QtGui.QVector3D.normal": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.normalize": (),
-    "PySide2.QtGui.QVector3D.normalized": (),
-    "PySide2.QtGui.QVector3D.project": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.setX": ('float',),
-    "PySide2.QtGui.QVector3D.setY": ('float',),
-    "PySide2.QtGui.QVector3D.setZ": ('float',),
-    "PySide2.QtGui.QVector3D.toPoint": (),
-    "PySide2.QtGui.QVector3D.toPointF": (),
-    "PySide2.QtGui.QVector3D.toTuple": (),
-    "PySide2.QtGui.QVector3D.toVector2D": (),
-    "PySide2.QtGui.QVector3D.toVector4D": (),
-    "PySide2.QtGui.QVector3D.unproject": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.x": (),
-    "PySide2.QtGui.QVector3D.y": (),
-    "PySide2.QtGui.QVector3D.z": (),
-# class PySide2.QtGui.QVector4D:
-    "PySide2.QtGui.QVector4D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float', 'float'), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QVector4D.__add__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__copy__": (),
-    "PySide2.QtGui.QVector4D.__iadd__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__imul__": [('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__isub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__neg__": (),
-    "PySide2.QtGui.QVector4D.__reduce__": (),
-    "PySide2.QtGui.QVector4D.__repr__": (),
-    "PySide2.QtGui.QVector4D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__sub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.dotProduct": ('PySide2.QtGui.QVector4D', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QVector4D.isNull": (),
-    "PySide2.QtGui.QVector4D.length": (),
-    "PySide2.QtGui.QVector4D.lengthSquared": (),
-    "PySide2.QtGui.QVector4D.normalize": (),
-    "PySide2.QtGui.QVector4D.normalized": (),
-    "PySide2.QtGui.QVector4D.setW": ('float',),
-    "PySide2.QtGui.QVector4D.setX": ('float',),
-    "PySide2.QtGui.QVector4D.setY": ('float',),
-    "PySide2.QtGui.QVector4D.setZ": ('float',),
-    "PySide2.QtGui.QVector4D.toPoint": (),
-    "PySide2.QtGui.QVector4D.toPointF": (),
-    "PySide2.QtGui.QVector4D.toTuple": (),
-    "PySide2.QtGui.QVector4D.toVector2D": (),
-    "PySide2.QtGui.QVector4D.toVector2DAffine": (),
-    "PySide2.QtGui.QVector4D.toVector3D": (),
-    "PySide2.QtGui.QVector4D.toVector3DAffine": (),
-    "PySide2.QtGui.QVector4D.w": (),
-    "PySide2.QtGui.QVector4D.x": (),
-    "PySide2.QtGui.QVector4D.y": (),
-    "PySide2.QtGui.QVector4D.z": (),
-# class PySide2.QtGui.QWhatsThisClickedEvent:
-    "PySide2.QtGui.QWhatsThisClickedEvent.__init__": ('str',),
-    "PySide2.QtGui.QWhatsThisClickedEvent.href": (),
-# class PySide2.QtGui.QWheelEvent:
-    "PySide2.QtGui.QWheelEvent.__init__": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'bool', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource', 'bool'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtGui.QWheelEvent.angleDelta": (),
-    "PySide2.QtGui.QWheelEvent.buttons": (),
-    "PySide2.QtGui.QWheelEvent.delta": (),
-    "PySide2.QtGui.QWheelEvent.globalPos": (),
-    "PySide2.QtGui.QWheelEvent.globalPosF": (),
-    "PySide2.QtGui.QWheelEvent.globalPosition": (),
-    "PySide2.QtGui.QWheelEvent.globalX": (),
-    "PySide2.QtGui.QWheelEvent.global""Y": (),
-    "PySide2.QtGui.QWheelEvent.inverted": (),
-    "PySide2.QtGui.QWheelEvent.orientation": (),
-    "PySide2.QtGui.QWheelEvent.phase": (),
-    "PySide2.QtGui.QWheelEvent.pixelDelta": (),
-    "PySide2.QtGui.QWheelEvent.pos": (),
-    "PySide2.QtGui.QWheelEvent.posF": (),
-    "PySide2.QtGui.QWheelEvent.position": (),
-    "PySide2.QtGui.QWheelEvent.source": (),
-    "PySide2.QtGui.QWheelEvent.x": (),
-    "PySide2.QtGui.QWheelEvent.y": (),
-# class PySide2.QtGui.QWindow:
-# class PySide2.QtGui.QWindow.AncestorMode:
-# class PySide2.QtGui.QWindow.Visibility:
-    "PySide2.QtGui.QWindow.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QWindow',)],
-    "PySide2.QtGui.QWindow.accessibleRoot": (),
-    "PySide2.QtGui.QWindow.alert": ('int',),
-    "PySide2.QtGui.QWindow.baseSize": (),
-    "PySide2.QtGui.QWindow.close": (),
-    "PySide2.QtGui.QWindow.contentOrientation": (),
-    "PySide2.QtGui.QWindow.create": (),
-    "PySide2.QtGui.QWindow.cursor": (),
-    "PySide2.QtGui.QWindow.destroy": (),
-    "PySide2.QtGui.QWindow.devicePixelRatio": (),
-    "PySide2.QtGui.QWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QWindow.filePath": (),
-    "PySide2.QtGui.QWindow.flags": (),
-    "PySide2.QtGui.QWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.focusObject": (),
-    "PySide2.QtGui.QWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.format": (),
-    "PySide2.QtGui.QWindow.frameGeometry": (),
-    "PySide2.QtGui.QWindow.frameMargins": (),
-    "PySide2.QtGui.QWindow.framePosition": (),
-    "PySide2.QtGui.QWindow.fromWinId": ('int',),
-    "PySide2.QtGui.QWindow.geometry": (),
-    "PySide2.QtGui.QWindow.height": (),
-    "PySide2.QtGui.QWindow.hide": (),
-    "PySide2.QtGui.QWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtGui.QWindow.icon": (),
-    "PySide2.QtGui.QWindow.isActive": (),
-    "PySide2.QtGui.QWindow.isAncestorOf": ('PySide2.QtGui.QWindow', 'PySide2.QtGui.QWindow.AncestorMode'),
-    "PySide2.QtGui.QWindow.isExposed": (),
-    "PySide2.QtGui.QWindow.isModal": (),
-    "PySide2.QtGui.QWindow.isTopLevel": (),
-    "PySide2.QtGui.QWindow.isVisible": (),
-    "PySide2.QtGui.QWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.lower": (),
-    "PySide2.QtGui.QWindow.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mask": (),
-    "PySide2.QtGui.QWindow.maximumHeight": (),
-    "PySide2.QtGui.QWindow.maximumSize": (),
-    "PySide2.QtGui.QWindow.maximumWidth": (),
-    "PySide2.QtGui.QWindow.minimumHeight": (),
-    "PySide2.QtGui.QWindow.minimumSize": (),
-    "PySide2.QtGui.QWindow.minimumWidth": (),
-    "PySide2.QtGui.QWindow.modality": (),
-    "PySide2.QtGui.QWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtGui.QWindow.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtGui.QWindow.opacity": (),
-    "PySide2.QtGui.QWindow.parent": [(), ('PySide2.QtGui.QWindow.AncestorMode',)],
-    "PySide2.QtGui.QWindow.position": (),
-    "PySide2.QtGui.QWindow.raise_": (),
-    "PySide2.QtGui.QWindow.reportContentOrientationChange": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QWindow.requestActivate": (),
-    "PySide2.QtGui.QWindow.requestUpdate": (),
-    "PySide2.QtGui.QWindow.requestedFormat": (),
-    "PySide2.QtGui.QWindow.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QWindow.screen": (),
-    "PySide2.QtGui.QWindow.setBaseSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QWindow.setFilePath": ('str',),
-    "PySide2.QtGui.QWindow.setFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtGui.QWindow.setFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtGui.QWindow.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QWindow.setFramePosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QWindow.setHeight": ('int',),
-    "PySide2.QtGui.QWindow.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QWindow.setKeyboardGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setMask": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QWindow.setMaximumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMaximumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMaximumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMinimumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtGui.QWindow.setMouseGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setOpacity": ('float',),
-    "PySide2.QtGui.QWindow.setParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setPosition": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QWindow.setSizeIncrement": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setSurfaceType": ('PySide2.QtGui.QSurface.SurfaceType',),
-    "PySide2.QtGui.QWindow.setTitle": ('str',),
-    "PySide2.QtGui.QWindow.setTransientParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setVisibility": ('PySide2.QtGui.QWindow.Visibility',),
-    "PySide2.QtGui.QWindow.setVisible": ('bool',),
-    "PySide2.QtGui.QWindow.setWidth": ('int',),
-    "PySide2.QtGui.QWindow.setWindowState": ('PySide2.QtCore.Qt.WindowState',),
-    "PySide2.QtGui.QWindow.setWindowStates": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtGui.QWindow.setX": ('int',),
-    "PySide2.QtGui.QWindow.setY": ('int',),
-    "PySide2.QtGui.QWindow.show": (),
-    "PySide2.QtGui.QWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtGui.QWindow.showFullScreen": (),
-    "PySide2.QtGui.QWindow.showMaximized": (),
-    "PySide2.QtGui.QWindow.showMinimized": (),
-    "PySide2.QtGui.QWindow.showNormal": (),
-    "PySide2.QtGui.QWindow.size": (),
-    "PySide2.QtGui.QWindow.sizeIncrement": (),
-    "PySide2.QtGui.QWindow.surfaceHandle": (),
-    "PySide2.QtGui.QWindow.surfaceType": (),
-    "PySide2.QtGui.QWindow.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtGui.QWindow.title": (),
-    "PySide2.QtGui.QWindow.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtGui.QWindow.transientParent": (),
-    "PySide2.QtGui.QWindow.type": (),
-    "PySide2.QtGui.QWindow.unsetCursor": (),
-    "PySide2.QtGui.QWindow.visibility": (),
-    "PySide2.QtGui.QWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtGui.QWindow.width": (),
-    "PySide2.QtGui.QWindow.winId": (),
-    "PySide2.QtGui.QWindow.windowState": (),
-    "PySide2.QtGui.QWindow.windowStates": (),
-    "PySide2.QtGui.QWindow.x": (),
-    "PySide2.QtGui.QWindow.y": (),
-# class PySide2.QtGui.QWindowStateChangeEvent:
-    "PySide2.QtGui.QWindowStateChangeEvent.__init__": ('PySide2.QtCore.Qt.WindowStates', 'bool'),
-    "PySide2.QtGui.QWindowStateChangeEvent.isOverride": (),
-    "PySide2.QtGui.QWindowStateChangeEvent.oldState": (),
-# class PySide2.QtGui.Qt:
-    "PySide2.QtGui.Qt.codecForHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.Qt.convertFromPlainText": ('str', 'PySide2.QtCore.Qt.WhiteSpaceMode'),
-    "PySide2.QtGui.Qt.mightBeRichText": ('str',),
-    "PySide2.QtGui.Qt.qAlpha": ('int',),
-    "PySide2.QtGui.Qt.qBlue": ('int',),
-    "PySide2.QtGui.Qt.qGray": [('int',), ('int', 'int', 'int')],
-    "PySide2.QtGui.Qt.qGreen": ('int',),
-    "PySide2.QtGui.Qt.qIsGray": ('int',),
-    "PySide2.QtGui.Qt.qRed": ('int',),
-    "PySide2.QtGui.Qt.qRgb": ('int', 'int', 'int'),
-    "PySide2.QtGui.Qt.qRgba": ('int', 'int', 'int', 'int'),
-    }) if "PySide2.QtGui" in sys.modules else None
-# Module PySide2.QtWidgets
-sig_dict.update({
-# class PySide2.QtWidgets.QAbstractButton:
-    "PySide2.QtWidgets.QAbstractButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractButton.animateClick": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.autoExclusive": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeat": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatDelay": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatInterval": (),
-    "PySide2.QtWidgets.QAbstractButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.checkStateSet": (),
-    "PySide2.QtWidgets.QAbstractButton.click": (),
-    "PySide2.QtWidgets.QAbstractButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.group": (),
-    "PySide2.QtWidgets.QAbstractButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractButton.icon": (),
-    "PySide2.QtWidgets.QAbstractButton.iconSize": (),
-    "PySide2.QtWidgets.QAbstractButton.isCheckable": (),
-    "PySide2.QtWidgets.QAbstractButton.isChecked": (),
-    "PySide2.QtWidgets.QAbstractButton.isDown": (),
-    "PySide2.QtWidgets.QAbstractButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.nextCheckState": (),
-    "PySide2.QtWidgets.QAbstractButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoExclusive": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatDelay": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatInterval": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAbstractButton.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractButton.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAbstractButton.setText": ('str',),
-    "PySide2.QtWidgets.QAbstractButton.shortcut": (),
-    "PySide2.QtWidgets.QAbstractButton.text": (),
-    "PySide2.QtWidgets.QAbstractButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractButton.toggle": (),
-# class PySide2.QtWidgets.QAbstractGraphicsShapeItem:
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.brush": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.opaqueArea": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.pen": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setPen": ('PySide2.QtGui.QPen',),
-# class PySide2.QtWidgets.QAbstractItemDelegate:
-# class PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint:
-    "PySide2.QtWidgets.QAbstractItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.destroyEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.elidedText": ('PySide2.QtGui.QFontMetrics', 'int', 'PySide2.QtCore.Qt.TextElideMode', 'str'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.helpEvent": ('PySide2.QtGui.QHelpEvent', 'PySide2.QtWidgets.QAbstractItemView', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paintingRoles": (),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QAbstractItemView:
-# class PySide2.QtWidgets.QAbstractItemView.CursorAction:
-# class PySide2.QtWidgets.QAbstractItemView.DragDropMode:
-# class PySide2.QtWidgets.QAbstractItemView.DropIndicatorPosition:
-# class PySide2.QtWidgets.QAbstractItemView.EditTrigger:
-# class PySide2.QtWidgets.QAbstractItemView.EditTriggers:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollHint:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollMode:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionBehavior:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionMode:
-# class PySide2.QtWidgets.QAbstractItemView.State:
-    "PySide2.QtWidgets.QAbstractItemView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.alternatingRowColors": (),
-    "PySide2.QtWidgets.QAbstractItemView.autoScrollMargin": (),
-    "PySide2.QtWidgets.QAbstractItemView.clearSelection": (),
-    "PySide2.QtWidgets.QAbstractItemView.closeEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint'),
-    "PySide2.QtWidgets.QAbstractItemView.closePersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.commitData": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemView.currentIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QAbstractItemView.defaultDropAction": (),
-    "PySide2.QtWidgets.QAbstractItemView.dirtyRegionOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.doAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.doItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropOverwriteMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnabled": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropIndicatorPosition": (),
-    "PySide2.QtWidgets.QAbstractItemView.edit": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.EditTrigger', 'PySide2.QtCore.QEvent')],
-    "PySide2.QtWidgets.QAbstractItemView.editTriggers": (),
-    "PySide2.QtWidgets.QAbstractItemView.editorDestroyed": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.executeDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.hasAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.iconSize": (),
-    "PySide2.QtWidgets.QAbstractItemView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractItemView.indexWidget": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractItemView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.isPersistentEditorOpen": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegate": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QAbstractItemView.model": (),
-    "PySide2.QtWidgets.QAbstractItemView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QAbstractItemView.openPersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.reset": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetHorizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetVerticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.rootIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scheduleDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollDirtyRegion": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToBottom": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToTop": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectAll": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectedIndexes": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionBehavior": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionCommand": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionModel": (),
-    "PySide2.QtWidgets.QAbstractItemView.setAlternatingRowColors": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScroll": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScrollMargin": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setCurrentIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setDefaultDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QAbstractItemView.setDirtyRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropMode": ('PySide2.QtWidgets.QAbstractItemView.DragDropMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDropIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setEditTriggers": ('PySide2.QtWidgets.QAbstractItemView.EditTriggers',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractItemView.setIndexWidget": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForColumn": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForRow": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionBehavior": ('PySide2.QtWidgets.QAbstractItemView.SelectionBehavior',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionMode": ('PySide2.QtWidgets.QAbstractItemView.SelectionMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setState": ('PySide2.QtWidgets.QAbstractItemView.State',),
-    "PySide2.QtWidgets.QAbstractItemView.setTabKeyNavigation": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setTextElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.showDropIndicator": (),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.startAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QAbstractItemView.state": (),
-    "PySide2.QtWidgets.QAbstractItemView.stopAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.tabKeyNavigation": (),
-    "PySide2.QtWidgets.QAbstractItemView.textElideMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.update": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorData": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewOptions": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractItemView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QAbstractScrollArea:
-# class PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QAbstractScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.addScrollBarWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QAbstractScrollArea.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.cornerWidget": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.maximumViewportSize": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollBarWidgets": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractScrollArea.setCornerWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setSizeAdjustPolicy": ('PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewportMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QAbstractScrollArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewport": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportMargins": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSlider:
-# class PySide2.QtWidgets.QAbstractSlider.SliderAction:
-# class PySide2.QtWidgets.QAbstractSlider.SliderChange:
-    "PySide2.QtWidgets.QAbstractSlider.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSlider.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.hasTracking": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedAppearance": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedControls": (),
-    "PySide2.QtWidgets.QAbstractSlider.isSliderDown": (),
-    "PySide2.QtWidgets.QAbstractSlider.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.maximum": (),
-    "PySide2.QtWidgets.QAbstractSlider.minimum": (),
-    "PySide2.QtWidgets.QAbstractSlider.orientation": (),
-    "PySide2.QtWidgets.QAbstractSlider.pageStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.repeatAction": (),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedControls": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setMaximum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setMinimum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QAbstractSlider.setPageStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setRepeatAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderPosition": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setValue": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.singleStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QAbstractSlider.sliderPosition": (),
-    "PySide2.QtWidgets.QAbstractSlider.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.triggerAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction',),
-    "PySide2.QtWidgets.QAbstractSlider.value": (),
-    "PySide2.QtWidgets.QAbstractSlider.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSpinBox:
-# class PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols:
-# class PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabled:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabledFlag:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepType:
-    "PySide2.QtWidgets.QAbstractSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSpinBox.alignment": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.buttonSymbols": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.clear": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.correctionMode": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasFrame": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QAbstractSpinBox.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractSpinBox.interpretText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isAccelerated": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isGroupSeparatorShown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isReadOnly": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyboardTracking": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.lineEdit": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.selectAll": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAccelerated": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setButtonSymbols": ('PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setCorrectionMode": ('PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setGroupSeparatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setKeyboardTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setSpecialValueText": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.specialValueText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepBy": ('int',),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepDown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepEnabled": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepUp": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.text": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QAbstractSpinBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.wrapping": (),
-# class PySide2.QtWidgets.QAccessibleWidget:
-    "PySide2.QtWidgets.QAccessibleWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QAccessible.Role', 'str'),
-    "PySide2.QtWidgets.QAccessibleWidget.actionNames": (),
-    "PySide2.QtWidgets.QAccessibleWidget.addControllingSignal": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.backgroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.child": ('int',),
-    "PySide2.QtWidgets.QAccessibleWidget.childCount": (),
-    "PySide2.QtWidgets.QAccessibleWidget.doAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.focusChild": (),
-    "PySide2.QtWidgets.QAccessibleWidget.foregroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtWidgets.QAccessibleWidget.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtWidgets.QAccessibleWidget.isValid": (),
-    "PySide2.QtWidgets.QAccessibleWidget.keyBindingsForAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.parent": (),
-    "PySide2.QtWidgets.QAccessibleWidget.parentObject": (),
-    "PySide2.QtWidgets.QAccessibleWidget.rect": (),
-    "PySide2.QtWidgets.QAccessibleWidget.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtWidgets.QAccessibleWidget.role": (),
-    "PySide2.QtWidgets.QAccessibleWidget.state": (),
-    "PySide2.QtWidgets.QAccessibleWidget.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtWidgets.QAccessibleWidget.widget": (),
-    "PySide2.QtWidgets.QAccessibleWidget.window": (),
-# class PySide2.QtWidgets.QAction:
-# class PySide2.QtWidgets.QAction.ActionEvent:
-# class PySide2.QtWidgets.QAction.MenuRole:
-# class PySide2.QtWidgets.QAction.Priority:
-    "PySide2.QtWidgets.QAction.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QAction.actionGroup": (),
-    "PySide2.QtWidgets.QAction.activate": ('PySide2.QtWidgets.QAction.ActionEvent',),
-    "PySide2.QtWidgets.QAction.associatedGraphicsWidgets": (),
-    "PySide2.QtWidgets.QAction.associatedWidgets": (),
-    "PySide2.QtWidgets.QAction.autoRepeat": (),
-    "PySide2.QtWidgets.QAction.data": (),
-    "PySide2.QtWidgets.QAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAction.font": (),
-    "PySide2.QtWidgets.QAction.hover": (),
-    "PySide2.QtWidgets.QAction.icon": (),
-    "PySide2.QtWidgets.QAction.iconText": (),
-    "PySide2.QtWidgets.QAction.isCheckable": (),
-    "PySide2.QtWidgets.QAction.isChecked": (),
-    "PySide2.QtWidgets.QAction.isEnabled": (),
-    "PySide2.QtWidgets.QAction.isIconVisibleInMenu": (),
-    "PySide2.QtWidgets.QAction.isSeparator": (),
-    "PySide2.QtWidgets.QAction.isShortcutVisibleInContextMenu": (),
-    "PySide2.QtWidgets.QAction.isVisible": (),
-    "PySide2.QtWidgets.QAction.menu": (),
-    "PySide2.QtWidgets.QAction.menuRole": (),
-    "PySide2.QtWidgets.QAction.parentWidget": (),
-    "PySide2.QtWidgets.QAction.priority": (),
-    "PySide2.QtWidgets.QAction.setActionGroup": ('PySide2.QtWidgets.QActionGroup',),
-    "PySide2.QtWidgets.QAction.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAction.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAction.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAction.setData": ('typing.Any',),
-    "PySide2.QtWidgets.QAction.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QAction.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAction.setIconText": ('str',),
-    "PySide2.QtWidgets.QAction.setIconVisibleInMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QAction.setMenuRole": ('PySide2.QtWidgets.QAction.MenuRole',),
-    "PySide2.QtWidgets.QAction.setPriority": ('PySide2.QtWidgets.QAction.Priority',),
-    "PySide2.QtWidgets.QAction.setSeparator": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAction.setShortcutContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QAction.setShortcutVisibleInContextMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcuts": [('PySide2.QtGui.QKeySequence.StandardKey',), ('typing.Sequence[PySide2.QtGui.QKeySequence]',)],
-    "PySide2.QtWidgets.QAction.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QAction.setText": ('str',),
-    "PySide2.QtWidgets.QAction.setToolTip": ('str',),
-    "PySide2.QtWidgets.QAction.setVisible": ('bool',),
-    "PySide2.QtWidgets.QAction.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QAction.shortcut": (),
-    "PySide2.QtWidgets.QAction.shortcutContext": (),
-    "PySide2.QtWidgets.QAction.shortcuts": (),
-    "PySide2.QtWidgets.QAction.showStatusText": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAction.statusTip": (),
-    "PySide2.QtWidgets.QAction.text": (),
-    "PySide2.QtWidgets.QAction.toggle": (),
-    "PySide2.QtWidgets.QAction.toolTip": (),
-    "PySide2.QtWidgets.QAction.trigger": (),
-    "PySide2.QtWidgets.QAction.whatsThis": (),
-# class PySide2.QtWidgets.QActionGroup:
-# class PySide2.QtWidgets.QActionGroup.ExclusionPolicy:
-    "PySide2.QtWidgets.QActionGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QActionGroup.actions": (),
-    "PySide2.QtWidgets.QActionGroup.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction',), ('str',)],
-    "PySide2.QtWidgets.QActionGroup.checkedAction": (),
-    "PySide2.QtWidgets.QActionGroup.exclusionPolicy": (),
-    "PySide2.QtWidgets.QActionGroup.isEnabled": (),
-    "PySide2.QtWidgets.QActionGroup.isExclusive": (),
-    "PySide2.QtWidgets.QActionGroup.isVisible": (),
-    "PySide2.QtWidgets.QActionGroup.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QActionGroup.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setExclusionPolicy": ('PySide2.QtWidgets.QActionGroup.ExclusionPolicy',),
-    "PySide2.QtWidgets.QActionGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setVisible": ('bool',),
-# class PySide2.QtWidgets.QApplication:
-# class PySide2.QtWidgets.QApplication.ColorSpec:
-    "PySide2.QtWidgets.QApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtWidgets.QApplication.aboutQt": (),
-    "PySide2.QtWidgets.QApplication.activeModalWidget": (),
-    "PySide2.QtWidgets.QApplication.activePopupWidget": (),
-    "PySide2.QtWidgets.QApplication.activeWindow": (),
-    "PySide2.QtWidgets.QApplication.alert": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QApplication.allWidgets": (),
-    "PySide2.QtWidgets.QApplication.autoSipEnabled": (),
-    "PySide2.QtWidgets.QApplication.beep": (),
-    "PySide2.QtWidgets.QApplication.closeAllWindows": (),
-    "PySide2.QtWidgets.QApplication.colorSpec": (),
-    "PySide2.QtWidgets.QApplication.cursorFlashTime": (),
-    "PySide2.QtWidgets.QApplication.desktop": (),
-    "PySide2.QtWidgets.QApplication.doubleClickInterval": (),
-    "PySide2.QtWidgets.QApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QApplication.exec_": (),
-    "PySide2.QtWidgets.QApplication.focusWidget": (),
-    "PySide2.QtWidgets.QApplication.font": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.fontMetrics": (),
-    "PySide2.QtWidgets.QApplication.globalStrut": (),
-    "PySide2.QtWidgets.QApplication.isEffectEnabled": ('PySide2.QtCore.Qt.UIEffect',),
-    "PySide2.QtWidgets.QApplication.keyboardInputInterval": (),
-    "PySide2.QtWidgets.QApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QApplication.palette": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setActiveWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QApplication.setAutoSipEnabled": ('bool',),
-    "PySide2.QtWidgets.QApplication.setColorSpec": ('int',),
-    "PySide2.QtWidgets.QApplication.setCursorFlashTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setDoubleClickInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setEffectEnabled": ('PySide2.QtCore.Qt.UIEffect', 'bool'),
-    "PySide2.QtWidgets.QApplication.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtWidgets.QApplication.setGlobalStrut": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QApplication.setKeyboardInputInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setPalette": [('PySide2.QtGui.QPalette',), ('PySide2.QtGui.QPalette', 'str')],
-    "PySide2.QtWidgets.QApplication.setStartDragDistance": ('int',),
-    "PySide2.QtWidgets.QApplication.setStartDragTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setStyle": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QApplication.setWheelScrollLines": ('int',),
-    "PySide2.QtWidgets.QApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QApplication.startDragDistance": (),
-    "PySide2.QtWidgets.QApplication.startDragTime": (),
-    "PySide2.QtWidgets.QApplication.style": (),
-    "PySide2.QtWidgets.QApplication.styleSheet": (),
-    "PySide2.QtWidgets.QApplication.topLevelAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.topLevelWidgets": (),
-    "PySide2.QtWidgets.QApplication.wheelScrollLines": (),
-    "PySide2.QtWidgets.QApplication.widgetAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.windowIcon": (),
-# class PySide2.QtWidgets.QBoxLayout:
-# class PySide2.QtWidgets.QBoxLayout.Direction:
-    "PySide2.QtWidgets.QBoxLayout.__init__": ('PySide2.QtWidgets.QBoxLayout.Direction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QBoxLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QBoxLayout.addLayout": ('PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.addSpacerItem": ('PySide2.QtWidgets.QSpacerItem',),
-    "PySide2.QtWidgets.QBoxLayout.addSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStrut": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QBoxLayout.count": (),
-    "PySide2.QtWidgets.QBoxLayout.direction": (),
-    "PySide2.QtWidgets.QBoxLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QBoxLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QBoxLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.insertItem": ('int', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertLayout": ('int', 'PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacerItem": ('int', 'PySide2.QtWidgets.QSpacerItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacing": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QBoxLayout.invalidate": (),
-    "PySide2.QtWidgets.QBoxLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.maximumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.minimumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.setDirection": ('PySide2.QtWidgets.QBoxLayout.Direction',),
-    "PySide2.QtWidgets.QBoxLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QBoxLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.setStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.setStretchFactor": [('PySide2.QtWidgets.QLayout', 'int'), ('PySide2.QtWidgets.QWidget', 'int')],
-    "PySide2.QtWidgets.QBoxLayout.sizeHint": (),
-    "PySide2.QtWidgets.QBoxLayout.spacing": (),
-    "PySide2.QtWidgets.QBoxLayout.stretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.takeAt": ('int',),
-# class PySide2.QtWidgets.QButtonGroup:
-    "PySide2.QtWidgets.QButtonGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QButtonGroup.addButton": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-    "PySide2.QtWidgets.QButtonGroup.button": ('int',),
-    "PySide2.QtWidgets.QButtonGroup.buttons": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedButton": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedId": (),
-    "PySide2.QtWidgets.QButtonGroup.exclusive": (),
-    "PySide2.QtWidgets.QButtonGroup.id": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QButtonGroup.setId": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-# class PySide2.QtWidgets.QCalendarWidget:
-# class PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat:
-# class PySide2.QtWidgets.QCalendarWidget.SelectionMode:
-# class PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat:
-    "PySide2.QtWidgets.QCalendarWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCalendarWidget.calendar": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateEditAcceptDelay": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateTextFormat": [(), ('PySide2.QtCore.QDate',)],
-    "PySide2.QtWidgets.QCalendarWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCalendarWidget.firstDayOfWeek": (),
-    "PySide2.QtWidgets.QCalendarWidget.headerTextFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.horizontalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.isDateEditEnabled": (),
-    "PySide2.QtWidgets.QCalendarWidget.isGridVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.isNavigationBarVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.maximumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.monthShown": (),
-    "PySide2.QtWidgets.QCalendarWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.paintCell": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.selectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.selectionMode": (),
-    "PySide2.QtWidgets.QCalendarWidget.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QCalendarWidget.setCurrentPage": ('int', 'int'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditAcceptDelay": ('int',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditEnabled": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateTextFormat": ('PySide2.QtCore.QDate', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.setFirstDayOfWeek": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.setGridVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setHeaderTextFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setHorizontalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setNavigationBarVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectedDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectionMode": ('PySide2.QtWidgets.QCalendarWidget.SelectionMode',),
-    "PySide2.QtWidgets.QCalendarWidget.setVerticalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setWeekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.showNextMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showNextYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showSelectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.showToday": (),
-    "PySide2.QtWidgets.QCalendarWidget.sizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.updateCell": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.updateCells": (),
-    "PySide2.QtWidgets.QCalendarWidget.verticalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.weekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.yearShown": (),
-# class PySide2.QtWidgets.QCheckBox:
-    "PySide2.QtWidgets.QCheckBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCheckBox.checkState": (),
-    "PySide2.QtWidgets.QCheckBox.checkStateSet": (),
-    "PySide2.QtWidgets.QCheckBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCheckBox.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QCheckBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QCheckBox.isTristate": (),
-    "PySide2.QtWidgets.QCheckBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCheckBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCheckBox.nextCheckState": (),
-    "PySide2.QtWidgets.QCheckBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCheckBox.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QCheckBox.setTristate": ('bool',),
-    "PySide2.QtWidgets.QCheckBox.sizeHint": (),
-# class PySide2.QtWidgets.QColorDialog:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOption:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOptions:
-    "PySide2.QtWidgets.QColorDialog.__init__": [('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QColorDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QColorDialog.currentColor": (),
-    "PySide2.QtWidgets.QColorDialog.customColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.customCount": (),
-    "PySide2.QtWidgets.QColorDialog.done": ('int',),
-    "PySide2.QtWidgets.QColorDialog.getColor": ('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QColorDialog.ColorDialogOptions'),
-    "PySide2.QtWidgets.QColorDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QColorDialog.options": (),
-    "PySide2.QtWidgets.QColorDialog.selectedColor": (),
-    "PySide2.QtWidgets.QColorDialog.setCurrentColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColorDialog.setCustomColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption', 'bool'),
-    "PySide2.QtWidgets.QColorDialog.setOptions": ('PySide2.QtWidgets.QColorDialog.ColorDialogOptions',),
-    "PySide2.QtWidgets.QColorDialog.setStandardColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QColorDialog.standardColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.testOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption',),
-# class PySide2.QtWidgets.QColormap:
-# class PySide2.QtWidgets.QColormap.Mode:
-    "PySide2.QtWidgets.QColormap.__init__": ('PySide2.QtWidgets.QColormap',),
-    "PySide2.QtWidgets.QColormap.__copy__": (),
-    "PySide2.QtWidgets.QColormap.cleanup": (),
-    "PySide2.QtWidgets.QColormap.colorAt": ('int',),
-    "PySide2.QtWidgets.QColormap.colormap": (),
-    "PySide2.QtWidgets.QColormap.depth": (),
-    "PySide2.QtWidgets.QColormap.initialize": (),
-    "PySide2.QtWidgets.QColormap.instance": ('int',),
-    "PySide2.QtWidgets.QColormap.mode": (),
-    "PySide2.QtWidgets.QColormap.pixel": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColormap.size": (),
-# class PySide2.QtWidgets.QColumnView:
-    "PySide2.QtWidgets.QColumnView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.columnWidths": (),
-    "PySide2.QtWidgets.QColumnView.createColumn": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QColumnView.horizontalOffset": (),
-    "PySide2.QtWidgets.QColumnView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QColumnView.initializeColumn": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QColumnView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QColumnView.previewWidget": (),
-    "PySide2.QtWidgets.QColumnView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QColumnView.resizeGripsVisible": (),
-    "PySide2.QtWidgets.QColumnView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QColumnView.selectAll": (),
-    "PySide2.QtWidgets.QColumnView.setColumnWidths": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QColumnView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QColumnView.setPreviewWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.setResizeGripsVisible": ('bool',),
-    "PySide2.QtWidgets.QColumnView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QColumnView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QColumnView.sizeHint": (),
-    "PySide2.QtWidgets.QColumnView.verticalOffset": (),
-    "PySide2.QtWidgets.QColumnView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QComboBox:
-# class PySide2.QtWidgets.QComboBox.InsertPolicy:
-# class PySide2.QtWidgets.QComboBox.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QComboBox.addItem": [('PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QComboBox.autoCompletion": (),
-    "PySide2.QtWidgets.QComboBox.autoCompletionCaseSensitivity": (),
-    "PySide2.QtWidgets.QComboBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.clear": (),
-    "PySide2.QtWidgets.QComboBox.clearEditText": (),
-    "PySide2.QtWidgets.QComboBox.completer": (),
-    "PySide2.QtWidgets.QComboBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QComboBox.count": (),
-    "PySide2.QtWidgets.QComboBox.currentData": ('int',),
-    "PySide2.QtWidgets.QComboBox.currentIndex": (),
-    "PySide2.QtWidgets.QComboBox.currentText": (),
-    "PySide2.QtWidgets.QComboBox.duplicatesEnabled": (),
-    "PySide2.QtWidgets.QComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.findData": ('typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.findText": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.hasFrame": (),
-    "PySide2.QtWidgets.QComboBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QComboBox.hidePopup": (),
-    "PySide2.QtWidgets.QComboBox.iconSize": (),
-    "PySide2.QtWidgets.QComboBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionComboBox',),
-    "PySide2.QtWidgets.QComboBox.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QComboBox.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItem": [('int', 'PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('int', 'str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QComboBox.insertPolicy": (),
-    "PySide2.QtWidgets.QComboBox.insertSeparator": ('int',),
-    "PySide2.QtWidgets.QComboBox.isEditable": (),
-    "PySide2.QtWidgets.QComboBox.itemData": ('int', 'int'),
-    "PySide2.QtWidgets.QComboBox.itemDelegate": (),
-    "PySide2.QtWidgets.QComboBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QComboBox.itemText": ('int',),
-    "PySide2.QtWidgets.QComboBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.lineEdit": (),
-    "PySide2.QtWidgets.QComboBox.maxCount": (),
-    "PySide2.QtWidgets.QComboBox.maxVisibleItems": (),
-    "PySide2.QtWidgets.QComboBox.minimumContentsLength": (),
-    "PySide2.QtWidgets.QComboBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QComboBox.model": (),
-    "PySide2.QtWidgets.QComboBox.modelColumn": (),
-    "PySide2.QtWidgets.QComboBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QComboBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QComboBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QComboBox.rootModelIndex": (),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletion": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletionCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QComboBox.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QComboBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QComboBox.setCurrentText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setDuplicatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setEditText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setEditable": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QComboBox.setInsertPolicy": ('PySide2.QtWidgets.QComboBox.InsertPolicy',),
-    "PySide2.QtWidgets.QComboBox.setItemData": ('int', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QComboBox.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QComboBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QComboBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QComboBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QComboBox.setMaxCount": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMinimumContentsLength": ('int',),
-    "PySide2.QtWidgets.QComboBox.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QComboBox.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QComboBox.setRootModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QComboBox.setSizeAdjustPolicy": ('PySide2.QtWidgets.QComboBox.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QComboBox.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QComboBox.setView": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QComboBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QComboBox.showPopup": (),
-    "PySide2.QtWidgets.QComboBox.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QComboBox.validator": (),
-    "PySide2.QtWidgets.QComboBox.view": (),
-    "PySide2.QtWidgets.QComboBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QCommandLinkButton:
-    "PySide2.QtWidgets.QCommandLinkButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget'), ('str', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCommandLinkButton.description": (),
-    "PySide2.QtWidgets.QCommandLinkButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QCommandLinkButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCommandLinkButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.setDescription": ('str',),
-    "PySide2.QtWidgets.QCommandLinkButton.sizeHint": (),
-# class PySide2.QtWidgets.QCommonStyle:
-    "PySide2.QtWidgets.QCommonStyle.__init__": (),
-    "PySide2.QtWidgets.QCommonStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QCommonStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QCommonStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QCommonStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QCompleter:
-# class PySide2.QtWidgets.QCompleter.CompletionMode:
-# class PySide2.QtWidgets.QCompleter.ModelSorting:
-    "PySide2.QtWidgets.QCompleter.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QCompleter.caseSensitivity": (),
-    "PySide2.QtWidgets.QCompleter.complete": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QCompleter.completionColumn": (),
-    "PySide2.QtWidgets.QCompleter.completionCount": (),
-    "PySide2.QtWidgets.QCompleter.completionMode": (),
-    "PySide2.QtWidgets.QCompleter.completionModel": (),
-    "PySide2.QtWidgets.QCompleter.completionPrefix": (),
-    "PySide2.QtWidgets.QCompleter.completionRole": (),
-    "PySide2.QtWidgets.QCompleter.currentCompletion": (),
-    "PySide2.QtWidgets.QCompleter.currentIndex": (),
-    "PySide2.QtWidgets.QCompleter.currentRow": (),
-    "PySide2.QtWidgets.QCompleter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCompleter.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCompleter.filterMode": (),
-    "PySide2.QtWidgets.QCompleter.maxVisibleItems": (),
-    "PySide2.QtWidgets.QCompleter.model": (),
-    "PySide2.QtWidgets.QCompleter.modelSorting": (),
-    "PySide2.QtWidgets.QCompleter.pathFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QCompleter.popup": (),
-    "PySide2.QtWidgets.QCompleter.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QCompleter.setCompletionColumn": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCompletionMode": ('PySide2.QtWidgets.QCompleter.CompletionMode',),
-    "PySide2.QtWidgets.QCompleter.setCompletionPrefix": ('str',),
-    "PySide2.QtWidgets.QCompleter.setCompletionRole": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCurrentRow": ('int',),
-    "PySide2.QtWidgets.QCompleter.setFilterMode": ('PySide2.QtCore.Qt.MatchFlags',),
-    "PySide2.QtWidgets.QCompleter.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QCompleter.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QCompleter.setModelSorting": ('PySide2.QtWidgets.QCompleter.ModelSorting',),
-    "PySide2.QtWidgets.QCompleter.setPopup": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QCompleter.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCompleter.setWrapAround": ('bool',),
-    "PySide2.QtWidgets.QCompleter.splitPath": ('str',),
-    "PySide2.QtWidgets.QCompleter.widget": (),
-    "PySide2.QtWidgets.QCompleter.wrapAround": (),
-# class PySide2.QtWidgets.QDataWidgetMapper:
-# class PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy:
-    "PySide2.QtWidgets.QDataWidgetMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QDataWidgetMapper.addMapping": [('PySide2.QtWidgets.QWidget', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtWidgets.QDataWidgetMapper.clearMapping": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.currentIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.itemDelegate": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedPropertyName": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedSection": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedWidgetAt": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.model": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.orientation": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.removeMapping": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.revert": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.rootIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setSubmitPolicy": ('PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy',),
-    "PySide2.QtWidgets.QDataWidgetMapper.submit": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.submitPolicy": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toFirst": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toLast": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toNext": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toPrevious": (),
-# class PySide2.QtWidgets.QDateEdit:
-    "PySide2.QtWidgets.QDateEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDateTimeEdit:
-# class PySide2.QtWidgets.QDateTimeEdit.Section:
-# class PySide2.QtWidgets.QDateTimeEdit.Sections:
-    "PySide2.QtWidgets.QDateTimeEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QDateTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('typing.Any', 'type', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QDateTimeEdit.calendar": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarPopup": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarWidget": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clear": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSection": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSectionIndex": (),
-    "PySide2.QtWidgets.QDateTimeEdit.date": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTimeFromText": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.displayFormat": (),
-    "PySide2.QtWidgets.QDateTimeEdit.displayedSections": (),
-    "PySide2.QtWidgets.QDateTimeEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.fixup": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QDateTimeEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionAt": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionCount": (),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionText": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarPopup": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarWidget": ('PySide2.QtWidgets.QCalendarWidget',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSectionIndex": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTimeRange": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDisplayFormat": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setSelectedSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeRange": ('PySide2.QtCore.QTime', 'PySide2.QtCore.QTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtWidgets.QDateTimeEdit.sizeHint": (),
-    "PySide2.QtWidgets.QDateTimeEdit.stepBy": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.stepEnabled": (),
-    "PySide2.QtWidgets.QDateTimeEdit.textFromDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.time": (),
-    "PySide2.QtWidgets.QDateTimeEdit.timeSpec": (),
-    "PySide2.QtWidgets.QDateTimeEdit.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDateTimeEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QDesktopWidget:
-    "PySide2.QtWidgets.QDesktopWidget.__init__": (),
-    "PySide2.QtWidgets.QDesktopWidget.availableGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.isVirtualDesktop": (),
-    "PySide2.QtWidgets.QDesktopWidget.numScreens": (),
-    "PySide2.QtWidgets.QDesktopWidget.primaryScreen": (),
-    "PySide2.QtWidgets.QDesktopWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDesktopWidget.screen": [(), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenCount": (),
-    "PySide2.QtWidgets.QDesktopWidget.screenGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenNumber": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDial:
-    "PySide2.QtWidgets.QDial.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDial.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDial.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QDial.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDial.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.notchSize": (),
-    "PySide2.QtWidgets.QDial.notchTarget": (),
-    "PySide2.QtWidgets.QDial.notchesVisible": (),
-    "PySide2.QtWidgets.QDial.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDial.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDial.setNotchTarget": ('float',),
-    "PySide2.QtWidgets.QDial.setNotchesVisible": ('bool',),
-    "PySide2.QtWidgets.QDial.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QDial.sizeHint": (),
-    "PySide2.QtWidgets.QDial.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QDial.wrapping": (),
-# class PySide2.QtWidgets.QDialog:
-# class PySide2.QtWidgets.QDialog.DialogCode:
-    "PySide2.QtWidgets.QDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QDialog.accept": (),
-    "PySide2.QtWidgets.QDialog.adjustPosition": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDialog.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QDialog.done": ('int',),
-    "PySide2.QtWidgets.QDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QDialog.exec_": (),
-    "PySide2.QtWidgets.QDialog.extension": (),
-    "PySide2.QtWidgets.QDialog.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QDialog.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDialog.open": (),
-    "PySide2.QtWidgets.QDialog.orientation": (),
-    "PySide2.QtWidgets.QDialog.reject": (),
-    "PySide2.QtWidgets.QDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDialog.result": (),
-    "PySide2.QtWidgets.QDialog.setExtension": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.setModal": ('bool',),
-    "PySide2.QtWidgets.QDialog.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialog.setResult": ('int',),
-    "PySide2.QtWidgets.QDialog.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QDialog.showExtension": ('bool',),
-    "PySide2.QtWidgets.QDialog.sizeHint": (),
-# class PySide2.QtWidgets.QDialogButtonBox:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonLayout:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonRole:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButton:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButtons:
-    "PySide2.QtWidgets.QDialogButtonBox.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QDialogButtonBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',), ('str', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole')],
-    "PySide2.QtWidgets.QDialogButtonBox.button": ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.centerButtons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.clear": (),
-    "PySide2.QtWidgets.QDialogButtonBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.orientation": (),
-    "PySide2.QtWidgets.QDialogButtonBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.setCenterButtons": ('bool',),
-    "PySide2.QtWidgets.QDialogButtonBox.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialogButtonBox.setStandardButtons": ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButtons": (),
-# class PySide2.QtWidgets.QDirModel:
-# class PySide2.QtWidgets.QDirModel.Roles:
-    "PySide2.QtWidgets.QDirModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QDirModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QDirModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QDirModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filter": (),
-    "PySide2.QtWidgets.QDirModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QDirModel.iconProvider": (),
-    "PySide2.QtWidgets.QDirModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QDirModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.isReadOnly": (),
-    "PySide2.QtWidgets.QDirModel.lazyChildCount": (),
-    "PySide2.QtWidgets.QDirModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QDirModel.mimeTypes": (),
-    "PySide2.QtWidgets.QDirModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QDirModel.nameFilters": (),
-    "PySide2.QtWidgets.QDirModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QDirModel.refresh": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QDirModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QDirModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QDirModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QDirModel.setLazyChildCount": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QDirModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtWidgets.QDirModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QDirModel.sorting": (),
-    "PySide2.QtWidgets.QDirModel.supportedDropActions": (),
-# class PySide2.QtWidgets.QDockWidget:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeature:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeatures:
-    "PySide2.QtWidgets.QDockWidget.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QDockWidget.allowedAreas": (),
-    "PySide2.QtWidgets.QDockWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDockWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.features": (),
-    "PySide2.QtWidgets.QDockWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionDockWidget',),
-    "PySide2.QtWidgets.QDockWidget.isAreaAllowed": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QDockWidget.isFloating": (),
-    "PySide2.QtWidgets.QDockWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDockWidget.setAllowedAreas": ('PySide2.QtCore.Qt.DockWidgetAreas',),
-    "PySide2.QtWidgets.QDockWidget.setFeatures": ('PySide2.QtWidgets.QDockWidget.DockWidgetFeatures',),
-    "PySide2.QtWidgets.QDockWidget.setFloating": ('bool',),
-    "PySide2.QtWidgets.QDockWidget.setTitleBarWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.titleBarWidget": (),
-    "PySide2.QtWidgets.QDockWidget.toggleViewAction": (),
-    "PySide2.QtWidgets.QDockWidget.widget": (),
-# class PySide2.QtWidgets.QDoubleSpinBox:
-    "PySide2.QtWidgets.QDoubleSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDoubleSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.decimals": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.maximum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.minimum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.prefix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.setDecimals": ('int',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMaximum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMinimum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setRange": ('float', 'float'),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSingleStep": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.stepType": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.suffix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.textFromValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDoubleSpinBox.value": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QErrorMessage:
-    "PySide2.QtWidgets.QErrorMessage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QErrorMessage.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QErrorMessage.done": ('int',),
-    "PySide2.QtWidgets.QErrorMessage.qtHandler": (),
-    "PySide2.QtWidgets.QErrorMessage.showMessage": [('str',), ('str', 'str')],
-# class PySide2.QtWidgets.QFileDialog:
-# class PySide2.QtWidgets.QFileDialog.AcceptMode:
-# class PySide2.QtWidgets.QFileDialog.DialogLabel:
-# class PySide2.QtWidgets.QFileDialog.FileMode:
-# class PySide2.QtWidgets.QFileDialog.Option:
-# class PySide2.QtWidgets.QFileDialog.Options:
-# class PySide2.QtWidgets.QFileDialog.ViewMode:
-    "PySide2.QtWidgets.QFileDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str')],
-    "PySide2.QtWidgets.QFileDialog.accept": (),
-    "PySide2.QtWidgets.QFileDialog.acceptMode": (),
-    "PySide2.QtWidgets.QFileDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileDialog.confirmOverwrite": (),
-    "PySide2.QtWidgets.QFileDialog.defaultSuffix": (),
-    "PySide2.QtWidgets.QFileDialog.directory": (),
-    "PySide2.QtWidgets.QFileDialog.directoryUrl": (),
-    "PySide2.QtWidgets.QFileDialog.done": ('int',),
-    "PySide2.QtWidgets.QFileDialog.fileMode": (),
-    "PySide2.QtWidgets.QFileDialog.filter": (),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectory": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectoryUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileNames": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrls": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.history": (),
-    "PySide2.QtWidgets.QFileDialog.iconProvider": (),
-    "PySide2.QtWidgets.QFileDialog.isNameFilterDetailsVisible": (),
-    "PySide2.QtWidgets.QFileDialog.isReadOnly": (),
-    "PySide2.QtWidgets.QFileDialog.itemDelegate": (),
-    "PySide2.QtWidgets.QFileDialog.labelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel',),
-    "PySide2.QtWidgets.QFileDialog.mimeTypeFilters": (),
-    "PySide2.QtWidgets.QFileDialog.nameFilters": (),
-    "PySide2.QtWidgets.QFileDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFileDialog.options": (),
-    "PySide2.QtWidgets.QFileDialog.proxyModel": (),
-    "PySide2.QtWidgets.QFileDialog.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileDialog.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QFileDialog.saveFileContent": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtWidgets.QFileDialog.saveState": (),
-    "PySide2.QtWidgets.QFileDialog.selectFile": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectMimeTypeFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.selectedFiles": (),
-    "PySide2.QtWidgets.QFileDialog.selectedMimeTypeFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedNameFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedUrls": (),
-    "PySide2.QtWidgets.QFileDialog.setAcceptMode": ('PySide2.QtWidgets.QFileDialog.AcceptMode',),
-    "PySide2.QtWidgets.QFileDialog.setConfirmOverwrite": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setDefaultSuffix": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setDirectory": [('PySide2.QtCore.QDir',), ('str',)],
-    "PySide2.QtWidgets.QFileDialog.setDirectoryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.setFileMode": ('PySide2.QtWidgets.QFileDialog.FileMode',),
-    "PySide2.QtWidgets.QFileDialog.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileDialog.setHistory": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileDialog.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QFileDialog.setLabelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel', 'str'),
-    "PySide2.QtWidgets.QFileDialog.setMimeTypeFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilterDetailsVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setOption": ('PySide2.QtWidgets.QFileDialog.Option', 'bool'),
-    "PySide2.QtWidgets.QFileDialog.setOptions": ('PySide2.QtWidgets.QFileDialog.Options',),
-    "PySide2.QtWidgets.QFileDialog.setProxyModel": ('PySide2.QtCore.QAbstractProxyModel',),
-    "PySide2.QtWidgets.QFileDialog.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setSidebarUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWidgets.QFileDialog.setSupportedSchemes": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setViewMode": ('PySide2.QtWidgets.QFileDialog.ViewMode',),
-    "PySide2.QtWidgets.QFileDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.sidebarUrls": (),
-    "PySide2.QtWidgets.QFileDialog.supportedSchemes": (),
-    "PySide2.QtWidgets.QFileDialog.testOption": ('PySide2.QtWidgets.QFileDialog.Option',),
-    "PySide2.QtWidgets.QFileDialog.viewMode": (),
-# class PySide2.QtWidgets.QFileIconProvider:
-# class PySide2.QtWidgets.QFileIconProvider.IconType:
-# class PySide2.QtWidgets.QFileIconProvider.Option:
-# class PySide2.QtWidgets.QFileIconProvider.Options:
-    "PySide2.QtWidgets.QFileIconProvider.__init__": (),
-    "PySide2.QtWidgets.QFileIconProvider.icon": [('PySide2.QtCore.QFileInfo',), ('PySide2.QtWidgets.QFileIconProvider.IconType',)],
-    "PySide2.QtWidgets.QFileIconProvider.options": (),
-    "PySide2.QtWidgets.QFileIconProvider.setOptions": ('PySide2.QtWidgets.QFileIconProvider.Options',),
-    "PySide2.QtWidgets.QFileIconProvider.type": ('PySide2.QtCore.QFileInfo',),
-# class PySide2.QtWidgets.QFileSystemModel:
-# class PySide2.QtWidgets.QFileSystemModel.Option:
-# class PySide2.QtWidgets.QFileSystemModel.Options:
-# class PySide2.QtWidgets.QFileSystemModel.Roles:
-    "PySide2.QtWidgets.QFileSystemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QFileSystemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filter": (),
-    "PySide2.QtWidgets.QFileSystemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.iconProvider": (),
-    "PySide2.QtWidgets.QFileSystemModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QFileSystemModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.isReadOnly": (),
-    "PySide2.QtWidgets.QFileSystemModel.lastModified": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeTypes": (),
-    "PySide2.QtWidgets.QFileSystemModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QFileSystemModel.myComputer": ('int',),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilterDisables": (),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilters": (),
-    "PySide2.QtWidgets.QFileSystemModel.options": (),
-    "PySide2.QtWidgets.QFileSystemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QFileSystemModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileSystemModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.rootDirectory": (),
-    "PySide2.QtWidgets.QFileSystemModel.rootPath": (),
-    "PySide2.QtWidgets.QFileSystemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileSystemModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilterDisables": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileSystemModel.setOption": ('PySide2.QtWidgets.QFileSystemModel.Option', 'bool'),
-    "PySide2.QtWidgets.QFileSystemModel.setOptions": ('PySide2.QtWidgets.QFileSystemModel.Options',),
-    "PySide2.QtWidgets.QFileSystemModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setRootPath": ('str',),
-    "PySide2.QtWidgets.QFileSystemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.size": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QFileSystemModel.supportedDropActions": (),
-    "PySide2.QtWidgets.QFileSystemModel.testOption": ('PySide2.QtWidgets.QFileSystemModel.Option',),
-    "PySide2.QtWidgets.QFileSystemModel.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.type": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtWidgets.QFocusFrame:
-    "PySide2.QtWidgets.QFocusFrame.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFocusFrame.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFocusFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QFocusFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFocusFrame.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.widget": (),
-# class PySide2.QtWidgets.QFontComboBox:
-# class PySide2.QtWidgets.QFontComboBox.FontFilter:
-# class PySide2.QtWidgets.QFontComboBox.FontFilters:
-    "PySide2.QtWidgets.QFontComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFontComboBox.currentFont": (),
-    "PySide2.QtWidgets.QFontComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontComboBox.fontFilters": (),
-    "PySide2.QtWidgets.QFontComboBox.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontComboBox.setFontFilters": ('PySide2.QtWidgets.QFontComboBox.FontFilters',),
-    "PySide2.QtWidgets.QFontComboBox.setWritingSystem": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtWidgets.QFontComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QFontComboBox.writingSystem": (),
-# class PySide2.QtWidgets.QFontDialog:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOption:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOptions:
-    "PySide2.QtWidgets.QFontDialog.__init__": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontDialog.currentFont": (),
-    "PySide2.QtWidgets.QFontDialog.done": ('int',),
-    "PySide2.QtWidgets.QFontDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFontDialog.getFont": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QFontDialog.FontDialogOptions'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFontDialog.options": (),
-    "PySide2.QtWidgets.QFontDialog.selectedFont": (),
-    "PySide2.QtWidgets.QFontDialog.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontDialog.setOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption', 'bool'),
-    "PySide2.QtWidgets.QFontDialog.setOptions": ('PySide2.QtWidgets.QFontDialog.FontDialogOptions',),
-    "PySide2.QtWidgets.QFontDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFontDialog.testOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption',),
-# class PySide2.QtWidgets.QFormLayout:
-# class PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy:
-# class PySide2.QtWidgets.QFormLayout.ItemRole:
-# class PySide2.QtWidgets.QFormLayout.RowWrapPolicy:
-    "PySide2.QtWidgets.QFormLayout.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFormLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QFormLayout.addRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QLayout'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.count": (),
-    "PySide2.QtWidgets.QFormLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QFormLayout.fieldGrowthPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.formAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.getItemPosition": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getLayoutPosition": ('PySide2.QtWidgets.QLayout', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getWidgetPosition": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QFormLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QFormLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QFormLayout.insertRow": [('int', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('int', 'str', 'PySide2.QtWidgets.QLayout'), ('int', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.invalidate": (),
-    "PySide2.QtWidgets.QFormLayout.itemAt": [('int',), ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole')],
-    "PySide2.QtWidgets.QFormLayout.labelAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.labelForField": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFormLayout.minimumSize": (),
-    "PySide2.QtWidgets.QFormLayout.removeRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QFormLayout.rowCount": (),
-    "PySide2.QtWidgets.QFormLayout.rowWrapPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.setFieldGrowthPolicy": ('PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setFormAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFormLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setItem": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QFormLayout.setLabelAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setLayout": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayout'),
-    "PySide2.QtWidgets.QFormLayout.setRowWrapPolicy": ('PySide2.QtWidgets.QFormLayout.RowWrapPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setWidget": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QFormLayout.sizeHint": (),
-    "PySide2.QtWidgets.QFormLayout.spacing": (),
-    "PySide2.QtWidgets.QFormLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QFormLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QFrame:
-# class PySide2.QtWidgets.QFrame.Shadow:
-# class PySide2.QtWidgets.QFrame.Shape:
-# class PySide2.QtWidgets.QFrame.StyleMask:
-    "PySide2.QtWidgets.QFrame.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QFrame.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.drawFrame": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.frameRect": (),
-    "PySide2.QtWidgets.QFrame.frameShadow": (),
-    "PySide2.QtWidgets.QFrame.frameShape": (),
-    "PySide2.QtWidgets.QFrame.frameStyle": (),
-    "PySide2.QtWidgets.QFrame.frameWidth": (),
-    "PySide2.QtWidgets.QFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QFrame.lineWidth": (),
-    "PySide2.QtWidgets.QFrame.midLineWidth": (),
-    "PySide2.QtWidgets.QFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFrame.setFrameRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFrame.setFrameShadow": ('PySide2.QtWidgets.QFrame.Shadow',),
-    "PySide2.QtWidgets.QFrame.setFrameShape": ('PySide2.QtWidgets.QFrame.Shape',),
-    "PySide2.QtWidgets.QFrame.setFrameStyle": ('int',),
-    "PySide2.QtWidgets.QFrame.setLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.setMidLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.sizeHint": (),
-# class PySide2.QtWidgets.QGesture:
-# class PySide2.QtWidgets.QGesture.GestureCancelPolicy:
-    "PySide2.QtWidgets.QGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGesture.gestureCancelPolicy": (),
-    "PySide2.QtWidgets.QGesture.gestureType": (),
-    "PySide2.QtWidgets.QGesture.hasHotSpot": (),
-    "PySide2.QtWidgets.QGesture.hotSpot": (),
-    "PySide2.QtWidgets.QGesture.setGestureCancelPolicy": ('PySide2.QtWidgets.QGesture.GestureCancelPolicy',),
-    "PySide2.QtWidgets.QGesture.setHotSpot": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGesture.state": (),
-    "PySide2.QtWidgets.QGesture.unsetHotSpot": (),
-# class PySide2.QtWidgets.QGestureEvent:
-    "PySide2.QtWidgets.QGestureEvent.__init__": ('typing.Sequence[PySide2.QtWidgets.QGesture]',),
-    "PySide2.QtWidgets.QGestureEvent.accept": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.activeGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.canceledGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.gesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGestureEvent.gestures": (),
-    "PySide2.QtWidgets.QGestureEvent.ignore": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.isAccepted": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.mapToGraphicsScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGestureEvent.setAccepted": [('PySide2.QtCore.Qt.GestureType', 'bool'), ('PySide2.QtWidgets.QGesture', 'bool'), ('bool',)],
-    "PySide2.QtWidgets.QGestureEvent.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGestureEvent.widget": (),
-# class PySide2.QtWidgets.QGestureRecognizer:
-# class PySide2.QtWidgets.QGestureRecognizer.Result:
-# class PySide2.QtWidgets.QGestureRecognizer.ResultFlag:
-    "PySide2.QtWidgets.QGestureRecognizer.__init__": (),
-    "PySide2.QtWidgets.QGestureRecognizer.create": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGestureRecognizer.recognize": ('PySide2.QtWidgets.QGesture', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGestureRecognizer.registerRecognizer": ('PySide2.QtWidgets.QGestureRecognizer',),
-    "PySide2.QtWidgets.QGestureRecognizer.reset": ('PySide2.QtWidgets.QGesture',),
-    "PySide2.QtWidgets.QGestureRecognizer.unregisterRecognizer": ('PySide2.QtCore.Qt.GestureType',),
-# class PySide2.QtWidgets.QGraphicsAnchor:
-    "PySide2.QtWidgets.QGraphicsAnchor.setSizePolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QGraphicsAnchor.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchor.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.spacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.unsetSpacing": (),
-# class PySide2.QtWidgets.QGraphicsAnchorLayout:
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Orientations'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addCornerAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.anchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsBlurEffect:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHint:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints:
-    "PySide2.QtWidgets.QGraphicsBlurEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurHints": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurHints": ('PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurRadius": ('float',),
-# class PySide2.QtWidgets.QGraphicsColorizeEffect:
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setStrength": ('float',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.strength": (),
-# class PySide2.QtWidgets.QGraphicsDropShadowEffect:
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.offset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setBlurRadius": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setOffset": [('PySide2.QtCore.QPointF',), ('float',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setXOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setYOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.xOffset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.yOffset": (),
-# class PySide2.QtWidgets.QGraphicsEffect:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlag:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlags:
-# class PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode:
-    "PySide2.QtWidgets.QGraphicsEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.drawSource": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsEffect.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceBoundingRect": ('PySide2.QtCore.Qt.CoordinateSystem',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceChanged": ('PySide2.QtWidgets.QGraphicsEffect.ChangeFlags',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceIsPixmap": (),
-    "PySide2.QtWidgets.QGraphicsEffect.sourcePixmap": ('PySide2.QtCore.Qt.CoordinateSystem', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode'),
-    "PySide2.QtWidgets.QGraphicsEffect.update": (),
-    "PySide2.QtWidgets.QGraphicsEffect.updateBoundingRect": (),
-# class PySide2.QtWidgets.QGraphicsEllipseItem:
-    "PySide2.QtWidgets.QGraphicsEllipseItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setSpanAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setStartAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.spanAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.startAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.type": (),
-# class PySide2.QtWidgets.QGraphicsGridLayout:
-    "PySide2.QtWidgets.QGraphicsGridLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.addItem": [('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnPreferredWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.itemAt": [('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowPreferredHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnFixedWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMaximumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMinimumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnPreferredWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowFixedHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMaximumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMinimumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowPreferredHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsItem:
-# class PySide2.QtWidgets.QGraphicsItem.CacheMode:
-# class PySide2.QtWidgets.QGraphicsItem.Extension:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags:
-# class PySide2.QtWidgets.QGraphicsItem.PanelModality:
-    "PySide2.QtWidgets.QGraphicsItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.acceptDrops": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptHoverEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptTouchEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptedMouseButtons": (),
-    "PySide2.QtWidgets.QGraphicsItem.addToIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.advance": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegion": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegionGranularity": (),
-    "PySide2.QtWidgets.QGraphicsItem.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsItem.childItems": (),
-    "PySide2.QtWidgets.QGraphicsItem.childrenBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.clipPath": (),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidingItems": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsItem.commonAncestorItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.cursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.data": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.deviceTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.effectiveOpacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsItem.filtersChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.flags": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusProxy": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusScopeItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.graphicsEffect": (),
-    "PySide2.QtWidgets.QGraphicsItem.group": (),
-    "PySide2.QtWidgets.QGraphicsItem.handlesChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.hide": (),
-    "PySide2.QtWidgets.QGraphicsItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodHints": (),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsItem.installSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isActive": (),
-    "PySide2.QtWidgets.QGraphicsItem.isAncestorOf": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isBlockedByModalPanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isClipped": (),
-    "PySide2.QtWidgets.QGraphicsItem.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsItem.isObscured": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isPanel": (),
-    "PySide2.QtWidgets.QGraphicsItem.isSelected": (),
-    "PySide2.QtWidgets.QGraphicsItem.isUnderMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisible": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisibleTo": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.isWindow": (),
-    "PySide2.QtWidgets.QGraphicsItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.itemTransform": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mapFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.matrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.moveBy": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItem.opacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItem.panel": (),
-    "PySide2.QtWidgets.QGraphicsItem.panelModality": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.pos": (),
-    "PySide2.QtWidgets.QGraphicsItem.prepareGeometryChange": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeFromIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.rotation": (),
-    "PySide2.QtWidgets.QGraphicsItem.scale": (),
-    "PySide2.QtWidgets.QGraphicsItem.scene": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsItem.sceneMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.scroll": ('float', 'float', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsItem.setActive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setBoundingRegionGranularity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setCacheMode": ('PySide2.QtWidgets.QGraphicsItem.CacheMode', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QGraphicsItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QGraphicsItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFiltersChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFlag": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setFlags": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocusProxy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QGraphicsItem.setGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsItem.setHandlesChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QGraphicsItem.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setPanelModality": ('PySide2.QtWidgets.QGraphicsItem.PanelModality',),
-    "PySide2.QtWidgets.QGraphicsItem.setParentItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setPos": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setRotation": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QGraphicsItem.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setTransformOriginPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setTransformations": ('typing.Sequence[PySide2.QtWidgets.QGraphicsTransform]',),
-    "PySide2.QtWidgets.QGraphicsItem.setVisible": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setX": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setY": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setZValue": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsItem.show": (),
-    "PySide2.QtWidgets.QGraphicsItem.stackBefore": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.toGraphicsObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.toolTip": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.transform": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformOriginPoint": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformations": (),
-    "PySide2.QtWidgets.QGraphicsItem.type": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.unsetCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.updateMicroFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.window": (),
-    "PySide2.QtWidgets.QGraphicsItem.x": (),
-    "PySide2.QtWidgets.QGraphicsItem.y": (),
-    "PySide2.QtWidgets.QGraphicsItem.zValue": (),
-# class PySide2.QtWidgets.QGraphicsItemAnimation:
-    "PySide2.QtWidgets.QGraphicsItemAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.afterAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.beforeAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.clear": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.item": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.matrixAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.reset": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.scaleList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setPosAt": ('float', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setRotationAt": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setScaleAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setShearAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTimeLine": ('PySide2.QtCore.QTimeLine',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTranslationAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.shearList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.timeLine": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.transformAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.translationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.xTranslationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.yTranslationAt": ('float',),
-# class PySide2.QtWidgets.QGraphicsItemGroup:
-    "PySide2.QtWidgets.QGraphicsItemGroup.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.addToGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItemGroup.removeFromGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.type": (),
-# class PySide2.QtWidgets.QGraphicsLayout:
-    "PySide2.QtWidgets.QGraphicsLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.activate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.addChildLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayout.instantInvalidatePropagation": (),
-    "PySide2.QtWidgets.QGraphicsLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.isActivated": (),
-    "PySide2.QtWidgets.QGraphicsLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.setContentsMargins": ('float', 'float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsLayout.setInstantInvalidatePropagation": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayout.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QGraphicsLayoutItem:
-    "PySide2.QtWidgets.QGraphicsLayoutItem.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'bool'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.contentsRect": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.effectiveSizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.graphicsItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.isLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.ownedByLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.parentLayoutItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGraphicsItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setOwnedByLayout": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setParentLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.updateGeometry": (),
-# class PySide2.QtWidgets.QGraphicsLineItem:
-    "PySide2.QtWidgets.QGraphicsLineItem.__init__": [('PySide2.QtCore.QLineF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsLineItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsLineItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsLineItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLineItem.line": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsLineItem.pen": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.setLine": [('PySide2.QtCore.QLineF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLineItem.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtWidgets.QGraphicsLineItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.type": (),
-# class PySide2.QtWidgets.QGraphicsLinearLayout:
-    "PySide2.QtWidgets.QGraphicsLinearLayout.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QGraphicsLayoutItem'), ('PySide2.QtWidgets.QGraphicsLayoutItem',)],
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.dump": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertItem": ('int', 'PySide2.QtWidgets.QGraphicsLayoutItem'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.orientation": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setItemSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setStretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.spacing": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.stretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-# class PySide2.QtWidgets.QGraphicsObject:
-    "PySide2.QtWidgets.QGraphicsObject.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsObject.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QGraphicsObject.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGraphicsObject.updateMicroFocus": (),
-# class PySide2.QtWidgets.QGraphicsOpacityEffect:
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacity": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacityMask": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacityMask": ('PySide2.QtGui.QBrush',),
-# class PySide2.QtWidgets.QGraphicsPathItem:
-    "PySide2.QtWidgets.QGraphicsPathItem.__init__": [('PySide2.QtGui.QPainterPath', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPathItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPathItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPathItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPathItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPathItem.path": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.setPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QGraphicsPathItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPixmapItem:
-# class PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode:
-    "PySide2.QtWidgets.QGraphicsPixmapItem.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.offset": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.pixmap": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setOffset": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setShapeMode": ('PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setTransformationMode": ('PySide2.QtCore.Qt.TransformationMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shapeMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.transformationMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPolygonItem:
-    "PySide2.QtWidgets.QGraphicsPolygonItem.__init__": [('PySide2.QtGui.QPolygonF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPolygonItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.fillRule": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.polygon": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.type": (),
-# class PySide2.QtWidgets.QGraphicsProxyWidget:
-    "PySide2.QtWidgets.QGraphicsProxyWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.createProxyForChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.newProxyWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.subWidgetRect": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.widget": (),
-# class PySide2.QtWidgets.QGraphicsRectItem:
-    "PySide2.QtWidgets.QGraphicsRectItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsRectItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsRectItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsRectItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsRectItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsRectItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsRectItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.type": (),
-# class PySide2.QtWidgets.QGraphicsRotation:
-    "PySide2.QtWidgets.QGraphicsRotation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsRotation.angle": (),
-    "PySide2.QtWidgets.QGraphicsRotation.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsRotation.axis": (),
-    "PySide2.QtWidgets.QGraphicsRotation.origin": (),
-    "PySide2.QtWidgets.QGraphicsRotation.setAngle": ('float',),
-    "PySide2.QtWidgets.QGraphicsRotation.setAxis": [('PySide2.QtCore.Qt.Axis',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtWidgets.QGraphicsRotation.setOrigin": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtWidgets.QGraphicsScale:
-    "PySide2.QtWidgets.QGraphicsScale.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsScale.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsScale.origin": (),
-    "PySide2.QtWidgets.QGraphicsScale.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtWidgets.QGraphicsScale.setXScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setYScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setZScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.xScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.yScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.zScale": (),
-# class PySide2.QtWidgets.QGraphicsScene:
-# class PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayer:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayers:
-    "PySide2.QtWidgets.QGraphicsScene.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QGraphicsScene.activePanel": (),
-    "PySide2.QtWidgets.QGraphicsScene.activeWindow": (),
-    "PySide2.QtWidgets.QGraphicsScene.addEllipse": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.addLine": [('PySide2.QtCore.QLineF', 'PySide2.QtGui.QPen'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen')],
-    "PySide2.QtWidgets.QGraphicsScene.addPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsScene.addPolygon": ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addRect": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addSimpleText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsScene.advance": (),
-    "PySide2.QtWidgets.QGraphicsScene.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.bspTreeDepth": (),
-    "PySide2.QtWidgets.QGraphicsScene.clear": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearSelection": (),
-    "PySide2.QtWidgets.QGraphicsScene.collidingItems": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsScene.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.createItemGroup": ('typing.Sequence[PySide2.QtWidgets.QGraphicsItem]',),
-    "PySide2.QtWidgets.QGraphicsScene.destroyItemGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsScene.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.focusOnTouch": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.font": (),
-    "PySide2.QtWidgets.QGraphicsScene.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.height": (),
-    "PySide2.QtWidgets.QGraphicsScene.helpEvent": ('PySide2.QtWidgets.QGraphicsSceneHelpEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsScene.invalidate": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers')],
-    "PySide2.QtWidgets.QGraphicsScene.isActive": (),
-    "PySide2.QtWidgets.QGraphicsScene.isSortCacheEnabled": (),
-    "PySide2.QtWidgets.QGraphicsScene.itemAt": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTransform'), ('float', 'float', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemIndexMethod": (),
-    "PySide2.QtWidgets.QGraphicsScene.items": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.Qt.SortOrder',), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemsBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.minimumRenderSize": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseGrabberItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.palette": (),
-    "PySide2.QtWidgets.QGraphicsScene.removeItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.render": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'),
-    "PySide2.QtWidgets.QGraphicsScene.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectedItems": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectionArea": (),
-    "PySide2.QtWidgets.QGraphicsScene.sendEvent": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.setActivePanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.setActiveWindow": ('PySide2.QtWidgets.QGraphicsWidget',),
-    "PySide2.QtWidgets.QGraphicsScene.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setBspTreeDepth": ('int',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusOnTouch": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsScene.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setItemIndexMethod": ('PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod',),
-    "PySide2.QtWidgets.QGraphicsScene.setMinimumRenderSize": ('float',),
-    "PySide2.QtWidgets.QGraphicsScene.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsScene.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.setSelectionArea": [('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionOperation', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.setSortCacheEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStickyFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsScene.stickyFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.style": (),
-    "PySide2.QtWidgets.QGraphicsScene.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.views": (),
-    "PySide2.QtWidgets.QGraphicsScene.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.width": (),
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent:
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason:
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.reason": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setReason": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneDragDropEvent:
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.acceptProposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.dropAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.mimeData": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.possibleActions": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.proposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPossibleActions": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setProposedAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneEvent:
-    "PySide2.QtWidgets.QGraphicsSceneEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneEvent.widget": (),
-# class PySide2.QtWidgets.QGraphicsSceneHelpEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneHoverEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneMouseEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.button": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScenePos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.flags": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScenePos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setFlags": ('PySide2.QtCore.Qt.MouseEventFlags',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setSource": ('PySide2.QtCore.Qt.MouseEventSource',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneMoveEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.newPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.oldPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setNewPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setOldPos": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QGraphicsSceneResizeEvent:
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.newSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.oldSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setNewSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setOldSize": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtWidgets.QGraphicsSceneWheelEvent:
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.delta": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.orientation": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setDelta": ('int',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSimpleTextItem:
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setText": ('str',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.text": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTextItem:
-    "PySide2.QtWidgets.QGraphicsTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsTextItem.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsTextItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.defaultTextColor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.document": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.openExternalLinks": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsTextItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDefaultTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setHtml": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setPlainText": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.tabChangesFocus": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textCursor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textInteractionFlags": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textWidth": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toHtml": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toPlainText": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTransform:
-    "PySide2.QtWidgets.QGraphicsTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsTransform.update": (),
-# class PySide2.QtWidgets.QGraphicsView:
-# class PySide2.QtWidgets.QGraphicsView.CacheMode:
-# class PySide2.QtWidgets.QGraphicsView.CacheModeFlag:
-# class PySide2.QtWidgets.QGraphicsView.DragMode:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlag:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlags:
-# class PySide2.QtWidgets.QGraphicsView.ViewportAnchor:
-# class PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode:
-    "PySide2.QtWidgets.QGraphicsView.__init__": [('PySide2.QtWidgets.QGraphicsScene', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGraphicsView.alignment": (),
-    "PySide2.QtWidgets.QGraphicsView.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsView.centerOn": [('PySide2.QtCore.QPointF',), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragMode": (),
-    "PySide2.QtWidgets.QGraphicsView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawItems": ('PySide2.QtGui.QPainter', 'int', 'typing.Sequence[PySide2.QtWidgets.QGraphicsItem]', 'typing.Sequence[PySide2.QtWidgets.QStyleOptionGraphicsItem]'),
-    "PySide2.QtWidgets.QGraphicsView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QGraphicsView.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('PySide2.QtWidgets.QGraphicsItem', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.fitInView": [('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsView.invalidateScene": ('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'),
-    "PySide2.QtWidgets.QGraphicsView.isInteractive": (),
-    "PySide2.QtWidgets.QGraphicsView.isTransformed": (),
-    "PySide2.QtWidgets.QGraphicsView.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.items": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ItemSelectionMode')],
-    "PySide2.QtWidgets.QGraphicsView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.mapToScene": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('int', 'int'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.matrix": (),
-    "PySide2.QtWidgets.QGraphicsView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.optimizationFlags": (),
-    "PySide2.QtWidgets.QGraphicsView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGraphicsView.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.renderHints": (),
-    "PySide2.QtWidgets.QGraphicsView.resetCachedContent": (),
-    "PySide2.QtWidgets.QGraphicsView.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsView.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsView.rotate": ('float',),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandRect": (),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandSelectionMode": (),
-    "PySide2.QtWidgets.QGraphicsView.scale": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.scene": (),
-    "PySide2.QtWidgets.QGraphicsView.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsView.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QGraphicsView.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setCacheMode": ('PySide2.QtWidgets.QGraphicsView.CacheMode',),
-    "PySide2.QtWidgets.QGraphicsView.setDragMode": ('PySide2.QtWidgets.QGraphicsView.DragMode',),
-    "PySide2.QtWidgets.QGraphicsView.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setInteractive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlag": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlags": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlags',),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints',),
-    "PySide2.QtWidgets.QGraphicsView.setResizeAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setRubberBandSelectionMode": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsView.setScene": ('PySide2.QtWidgets.QGraphicsScene',),
-    "PySide2.QtWidgets.QGraphicsView.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setTransformationAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setViewportUpdateMode": ('PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode',),
-    "PySide2.QtWidgets.QGraphicsView.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsView.shear": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsView.sizeHint": (),
-    "PySide2.QtWidgets.QGraphicsView.transform": (),
-    "PySide2.QtWidgets.QGraphicsView.transformationAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.translate": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.updateScene": ('typing.Sequence[PySide2.QtCore.QRectF]',),
-    "PySide2.QtWidgets.QGraphicsView.updateSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.viewportTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.viewportUpdateMode": (),
-    "PySide2.QtWidgets.QGraphicsView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QGraphicsWidget:
-    "PySide2.QtWidgets.QGraphicsWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsWidget.actions": (),
-    "PySide2.QtWidgets.QGraphicsWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QGraphicsWidget.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QGraphicsWidget.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.close": (),
-    "PySide2.QtWidgets.QGraphicsWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QGraphicsWidget.focusWidget": (),
-    "PySide2.QtWidgets.QGraphicsWidget.font": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.grabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QGraphicsWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QGraphicsWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QGraphicsWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QGraphicsWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QGraphicsWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.layout": (),
-    "PySide2.QtWidgets.QGraphicsWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.moveEvent": ('PySide2.QtWidgets.QGraphicsSceneMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.paintWindowFrame": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.palette": (),
-    "PySide2.QtWidgets.QGraphicsWidget.polishEvent": (),
-    "PySide2.QtWidgets.QGraphicsWidget.propertyChange": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.rect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QGraphicsWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.resize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.setContentsMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QGraphicsWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsWidget.setGeometry": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setLayout": ('PySide2.QtWidgets.QGraphicsLayout',),
-    "PySide2.QtWidgets.QGraphicsWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QGraphicsWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsWidget.setTabOrder": ('PySide2.QtWidgets.QGraphicsWidget', 'PySide2.QtWidgets.QGraphicsWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFrameMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QGraphicsWidget.shape": (),
-    "PySide2.QtWidgets.QGraphicsWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.size": (),
-    "PySide2.QtWidgets.QGraphicsWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsWidget.style": (),
-    "PySide2.QtWidgets.QGraphicsWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QGraphicsWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFlags": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameSectionAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowTitle": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowType": (),
-# class PySide2.QtWidgets.QGridLayout:
-    "PySide2.QtWidgets.QGridLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGridLayout.addItem": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addLayout": [('PySide2.QtWidgets.QLayout', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QLayout', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.cellRect": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.columnStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.count": (),
-    "PySide2.QtWidgets.QGridLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QGridLayout.getItemPosition": ('int',),
-    "PySide2.QtWidgets.QGridLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QGridLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGridLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.itemAtPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.maximumSize": (),
-    "PySide2.QtWidgets.QGridLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.minimumSize": (),
-    "PySide2.QtWidgets.QGridLayout.originCorner": (),
-    "PySide2.QtWidgets.QGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGridLayout.rowStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setColumnMinimumWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setColumnStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setDefaultPositioning": ('int', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QGridLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QGridLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setOriginCorner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QGridLayout.setRowMinimumHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setRowStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.sizeHint": (),
-    "PySide2.QtWidgets.QGridLayout.spacing": (),
-    "PySide2.QtWidgets.QGridLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGroupBox:
-    "PySide2.QtWidgets.QGroupBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QGroupBox.alignment": (),
-    "PySide2.QtWidgets.QGroupBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QGroupBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGroupBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionGroupBox',),
-    "PySide2.QtWidgets.QGroupBox.isCheckable": (),
-    "PySide2.QtWidgets.QGroupBox.isChecked": (),
-    "PySide2.QtWidgets.QGroupBox.isFlat": (),
-    "PySide2.QtWidgets.QGroupBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QGroupBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGroupBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGroupBox.setAlignment": ('int',),
-    "PySide2.QtWidgets.QGroupBox.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setChecked": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setFlat": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setTitle": ('str',),
-    "PySide2.QtWidgets.QGroupBox.title": (),
-# class PySide2.QtWidgets.QHBoxLayout:
-    "PySide2.QtWidgets.QHBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QHeaderView:
-# class PySide2.QtWidgets.QHeaderView.ResizeMode:
-    "PySide2.QtWidgets.QHeaderView.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QHeaderView.cascadingSectionResizes": (),
-    "PySide2.QtWidgets.QHeaderView.count": (),
-    "PySide2.QtWidgets.QHeaderView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QHeaderView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QHeaderView.defaultAlignment": (),
-    "PySide2.QtWidgets.QHeaderView.defaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.doItemsLayout": (),
-    "PySide2.QtWidgets.QHeaderView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.headerDataChanged": ('PySide2.QtCore.Qt.Orientation', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.hiddenSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.hideSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.highlightSections": (),
-    "PySide2.QtWidgets.QHeaderView.horizontalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QHeaderView.initStyleOption": [('PySide2.QtWidgets.QStyleOptionFrame',), ('PySide2.QtWidgets.QStyleOptionHeader',)],
-    "PySide2.QtWidgets.QHeaderView.initialize": (),
-    "PySide2.QtWidgets.QHeaderView.initializeSections": [(), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.isFirstSectionMovable": (),
-    "PySide2.QtWidgets.QHeaderView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.isSectionHidden": ('int',),
-    "PySide2.QtWidgets.QHeaderView.isSortIndicatorShown": (),
-    "PySide2.QtWidgets.QHeaderView.length": (),
-    "PySide2.QtWidgets.QHeaderView.logicalIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.logicalIndexAt": [('PySide2.QtCore.QPoint',), ('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.maximumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.minimumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QHeaderView.moveSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.offset": (),
-    "PySide2.QtWidgets.QHeaderView.orientation": (),
-    "PySide2.QtWidgets.QHeaderView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QHeaderView.paintSection": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtWidgets.QHeaderView.reset": (),
-    "PySide2.QtWidgets.QHeaderView.resetDefaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.resizeContentsPrecision": (),
-    "PySide2.QtWidgets.QHeaderView.resizeSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.resizeSections": [(), ('PySide2.QtWidgets.QHeaderView.ResizeMode',)],
-    "PySide2.QtWidgets.QHeaderView.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QHeaderView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.saveState": (),
-    "PySide2.QtWidgets.QHeaderView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QHeaderView.sectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionResizeMode": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeFromContents": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeHint": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionViewportPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsClickable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsHidden": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsMovable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsMoved": (),
-    "PySide2.QtWidgets.QHeaderView.setCascadingSectionResizes": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setFirstSectionMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setHighlightSections": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setMaximumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setMinimumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QHeaderView.setOffset": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToSectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setResizeContentsPrecision": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setSectionHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QHeaderView.setSectionResizeMode": [('PySide2.QtWidgets.QHeaderView.ResizeMode',), ('int', 'PySide2.QtWidgets.QHeaderView.ResizeMode')],
-    "PySide2.QtWidgets.QHeaderView.setSectionsClickable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSectionsMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicator": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setStretchLastSection": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setVisible": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.showSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sizeHint": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorOrder": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.swapSections": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.updateGeometries": (),
-    "PySide2.QtWidgets.QHeaderView.updateSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.verticalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.visualIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualIndexAt": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QInputDialog:
-# class PySide2.QtWidgets.QInputDialog.InputDialogOption:
-# class PySide2.QtWidgets.QInputDialog.InputMode:
-    "PySide2.QtWidgets.QInputDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.cancelButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.comboBoxItems": (),
-    "PySide2.QtWidgets.QInputDialog.done": ('int',),
-    "PySide2.QtWidgets.QInputDialog.doubleDecimals": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleStep": (),
-    "PySide2.QtWidgets.QInputDialog.doubleValue": (),
-    "PySide2.QtWidgets.QInputDialog.getDouble": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags', 'float')],
-    "PySide2.QtWidgets.QInputDialog.getInt": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.getItem": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'typing.Sequence[str]', 'int', 'bool', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getMultiLineText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QLineEdit.EchoMode', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.inputMode": (),
-    "PySide2.QtWidgets.QInputDialog.intMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.intMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.intStep": (),
-    "PySide2.QtWidgets.QInputDialog.intValue": (),
-    "PySide2.QtWidgets.QInputDialog.isComboBoxEditable": (),
-    "PySide2.QtWidgets.QInputDialog.labelText": (),
-    "PySide2.QtWidgets.QInputDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.okButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QInputDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxEditable": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleDecimals": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMaximum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMinimum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleRange": ('float', 'float'),
-    "PySide2.QtWidgets.QInputDialog.setDoubleStep": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleValue": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setInputMode": ('PySide2.QtWidgets.QInputDialog.InputMode',),
-    "PySide2.QtWidgets.QInputDialog.setIntMaximum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntMinimum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntRange": ('int', 'int'),
-    "PySide2.QtWidgets.QInputDialog.setIntStep": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntValue": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOkButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption', 'bool'),
-    "PySide2.QtWidgets.QInputDialog.setTextEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QInputDialog.setTextValue": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.sizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.testOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption',),
-    "PySide2.QtWidgets.QInputDialog.textEchoMode": (),
-    "PySide2.QtWidgets.QInputDialog.textValue": (),
-# class PySide2.QtWidgets.QItemDelegate:
-    "PySide2.QtWidgets.QItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.decoration": ('PySide2.QtWidgets.QStyleOptionViewItem', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.doCheck": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.drawCheck": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QItemDelegate.drawDecoration": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QItemDelegate.drawDisplay": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.drawFocus": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QItemDelegate.hasClipping": (),
-    "PySide2.QtWidgets.QItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.rect": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QItemDelegate.selectedPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPalette', 'bool'),
-    "PySide2.QtWidgets.QItemDelegate.setClipping": ('bool',),
-    "PySide2.QtWidgets.QItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setOptions": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QStyleOptionViewItem'),
-    "PySide2.QtWidgets.QItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.textRectangle": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QFont', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QItemEditorCreatorBase:
-    "PySide2.QtWidgets.QItemEditorCreatorBase.__init__": (),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.valuePropertyName": (),
-# class PySide2.QtWidgets.QItemEditorFactory:
-    "PySide2.QtWidgets.QItemEditorFactory.__init__": (),
-    "PySide2.QtWidgets.QItemEditorFactory.createEditor": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QItemEditorFactory.defaultFactory": (),
-    "PySide2.QtWidgets.QItemEditorFactory.registerEditor": ('int', 'PySide2.QtWidgets.QItemEditorCreatorBase'),
-    "PySide2.QtWidgets.QItemEditorFactory.setDefaultFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemEditorFactory.valuePropertyName": ('int',),
-# class PySide2.QtWidgets.QKeyEventTransition:
-    "PySide2.QtWidgets.QKeyEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QKeyEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.key": (),
-    "PySide2.QtWidgets.QKeyEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QKeyEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.setKey": ('int',),
-    "PySide2.QtWidgets.QKeyEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QKeySequenceEdit:
-    "PySide2.QtWidgets.QKeySequenceEdit.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QKeySequenceEdit.clear": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keySequence": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.setKeySequence": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QKeySequenceEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QLCDNumber:
-# class PySide2.QtWidgets.QLCDNumber.Mode:
-# class PySide2.QtWidgets.QLCDNumber.SegmentStyle:
-    "PySide2.QtWidgets.QLCDNumber.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLCDNumber.checkOverflow": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLCDNumber.digitCount": (),
-    "PySide2.QtWidgets.QLCDNumber.display": [('float',), ('int',), ('str',)],
-    "PySide2.QtWidgets.QLCDNumber.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLCDNumber.intValue": (),
-    "PySide2.QtWidgets.QLCDNumber.mode": (),
-    "PySide2.QtWidgets.QLCDNumber.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLCDNumber.segmentStyle": (),
-    "PySide2.QtWidgets.QLCDNumber.setBinMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDecMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDigitCount": ('int',),
-    "PySide2.QtWidgets.QLCDNumber.setHexMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setMode": ('PySide2.QtWidgets.QLCDNumber.Mode',),
-    "PySide2.QtWidgets.QLCDNumber.setOctMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setSegmentStyle": ('PySide2.QtWidgets.QLCDNumber.SegmentStyle',),
-    "PySide2.QtWidgets.QLCDNumber.setSmallDecimalPoint": ('bool',),
-    "PySide2.QtWidgets.QLCDNumber.sizeHint": (),
-    "PySide2.QtWidgets.QLCDNumber.smallDecimalPoint": (),
-    "PySide2.QtWidgets.QLCDNumber.value": (),
-# class PySide2.QtWidgets.QLabel:
-    "PySide2.QtWidgets.QLabel.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QLabel.alignment": (),
-    "PySide2.QtWidgets.QLabel.buddy": (),
-    "PySide2.QtWidgets.QLabel.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.clear": (),
-    "PySide2.QtWidgets.QLabel.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLabel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QLabel.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.hasScaledContents": (),
-    "PySide2.QtWidgets.QLabel.hasSelectedText": (),
-    "PySide2.QtWidgets.QLabel.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLabel.indent": (),
-    "PySide2.QtWidgets.QLabel.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLabel.margin": (),
-    "PySide2.QtWidgets.QLabel.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLabel.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.movie": (),
-    "PySide2.QtWidgets.QLabel.openExternalLinks": (),
-    "PySide2.QtWidgets.QLabel.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLabel.picture": (),
-    "PySide2.QtWidgets.QLabel.pixmap": (),
-    "PySide2.QtWidgets.QLabel.selectedText": (),
-    "PySide2.QtWidgets.QLabel.selectionStart": (),
-    "PySide2.QtWidgets.QLabel.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLabel.setBuddy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLabel.setIndent": ('int',),
-    "PySide2.QtWidgets.QLabel.setMargin": ('int',),
-    "PySide2.QtWidgets.QLabel.setMovie": ('PySide2.QtGui.QMovie',),
-    "PySide2.QtWidgets.QLabel.setNum": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLabel.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QLabel.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtWidgets.QLabel.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QLabel.setScaledContents": ('bool',),
-    "PySide2.QtWidgets.QLabel.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLabel.setText": ('str',),
-    "PySide2.QtWidgets.QLabel.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QLabel.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QLabel.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QLabel.sizeHint": (),
-    "PySide2.QtWidgets.QLabel.text": (),
-    "PySide2.QtWidgets.QLabel.textFormat": (),
-    "PySide2.QtWidgets.QLabel.textInteractionFlags": (),
-    "PySide2.QtWidgets.QLabel.wordWrap": (),
-# class PySide2.QtWidgets.QLayout:
-# class PySide2.QtWidgets.QLayout.SizeConstraint:
-    "PySide2.QtWidgets.QLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.activate": (),
-    "PySide2.QtWidgets.QLayout.addChildLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.addChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.adoptLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.alignmentRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QLayout.closestAcceptableSize": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QLayout.contentsMargins": (),
-    "PySide2.QtWidgets.QLayout.contentsRect": (),
-    "PySide2.QtWidgets.QLayout.controlTypes": (),
-    "PySide2.QtWidgets.QLayout.count": (),
-    "PySide2.QtWidgets.QLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QLayout.geometry": (),
-    "PySide2.QtWidgets.QLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QLayout.indexOf": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.invalidate": (),
-    "PySide2.QtWidgets.QLayout.isEmpty": (),
-    "PySide2.QtWidgets.QLayout.isEnabled": (),
-    "PySide2.QtWidgets.QLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QLayout.layout": (),
-    "PySide2.QtWidgets.QLayout.margin": (),
-    "PySide2.QtWidgets.QLayout.maximumSize": (),
-    "PySide2.QtWidgets.QLayout.menuBar": (),
-    "PySide2.QtWidgets.QLayout.minimumSize": (),
-    "PySide2.QtWidgets.QLayout.parentWidget": (),
-    "PySide2.QtWidgets.QLayout.removeItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.replaceWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.FindChildOptions'),
-    "PySide2.QtWidgets.QLayout.setAlignment": [('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtWidgets.QLayout', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QLayout.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLayout.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.setMargin": ('int',),
-    "PySide2.QtWidgets.QLayout.setMenuBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.setSizeConstraint": ('PySide2.QtWidgets.QLayout.SizeConstraint',),
-    "PySide2.QtWidgets.QLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QLayout.sizeConstraint": (),
-    "PySide2.QtWidgets.QLayout.spacing": (),
-    "PySide2.QtWidgets.QLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QLayout.totalHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayout.totalMaximumSize": (),
-    "PySide2.QtWidgets.QLayout.totalMinimumSize": (),
-    "PySide2.QtWidgets.QLayout.totalSizeHint": (),
-    "PySide2.QtWidgets.QLayout.update": (),
-    "PySide2.QtWidgets.QLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QLayoutItem:
-    "PySide2.QtWidgets.QLayoutItem.__init__": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.alignment": (),
-    "PySide2.QtWidgets.QLayoutItem.controlTypes": (),
-    "PySide2.QtWidgets.QLayoutItem.expandingDirections": (),
-    "PySide2.QtWidgets.QLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QLayoutItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QLayoutItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.invalidate": (),
-    "PySide2.QtWidgets.QLayoutItem.isEmpty": (),
-    "PySide2.QtWidgets.QLayoutItem.layout": (),
-    "PySide2.QtWidgets.QLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayoutItem.sizeHint": (),
-    "PySide2.QtWidgets.QLayoutItem.spacerItem": (),
-    "PySide2.QtWidgets.QLayoutItem.widget": (),
-# class PySide2.QtWidgets.QLineEdit:
-# class PySide2.QtWidgets.QLineEdit.ActionPosition:
-# class PySide2.QtWidgets.QLineEdit.EchoMode:
-    "PySide2.QtWidgets.QLineEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLineEdit.addAction": [('PySide2.QtGui.QIcon', 'PySide2.QtWidgets.QLineEdit.ActionPosition'), ('PySide2.QtWidgets.QAction',), ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QLineEdit.ActionPosition')],
-    "PySide2.QtWidgets.QLineEdit.alignment": (),
-    "PySide2.QtWidgets.QLineEdit.backspace": (),
-    "PySide2.QtWidgets.QLineEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.clear": (),
-    "PySide2.QtWidgets.QLineEdit.completer": (),
-    "PySide2.QtWidgets.QLineEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLineEdit.copy": (),
-    "PySide2.QtWidgets.QLineEdit.createStandardContextMenu": (),
-    "PySide2.QtWidgets.QLineEdit.cursorBackward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorForward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorMoveStyle": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPosition": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPositionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QLineEdit.cursorRect": (),
-    "PySide2.QtWidgets.QLineEdit.cursorWordBackward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cursorWordForward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cut": (),
-    "PySide2.QtWidgets.QLineEdit.del_": (),
-    "PySide2.QtWidgets.QLineEdit.deselect": (),
-    "PySide2.QtWidgets.QLineEdit.displayText": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QLineEdit.echoMode": (),
-    "PySide2.QtWidgets.QLineEdit.end": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.getTextMargins": (),
-    "PySide2.QtWidgets.QLineEdit.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QLineEdit.hasFrame": (),
-    "PySide2.QtWidgets.QLineEdit.hasSelectedText": (),
-    "PySide2.QtWidgets.QLineEdit.home": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QLineEdit.inputMask": (),
-    "PySide2.QtWidgets.QLineEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QLineEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QLineEdit.insert": ('str',),
-    "PySide2.QtWidgets.QLineEdit.isClearButtonEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.isModified": (),
-    "PySide2.QtWidgets.QLineEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QLineEdit.isRedoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.isUndoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLineEdit.maxLength": (),
-    "PySide2.QtWidgets.QLineEdit.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLineEdit.paste": (),
-    "PySide2.QtWidgets.QLineEdit.placeholderText": (),
-    "PySide2.QtWidgets.QLineEdit.redo": (),
-    "PySide2.QtWidgets.QLineEdit.selectAll": (),
-    "PySide2.QtWidgets.QLineEdit.selectedText": (),
-    "PySide2.QtWidgets.QLineEdit.selectionEnd": (),
-    "PySide2.QtWidgets.QLineEdit.selectionLength": (),
-    "PySide2.QtWidgets.QLineEdit.selectionStart": (),
-    "PySide2.QtWidgets.QLineEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLineEdit.setClearButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QLineEdit.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtWidgets.QLineEdit.setCursorPosition": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QLineEdit.setFrame": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setInputMask": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setMaxLength": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setModified": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLineEdit.setText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setTextMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLineEdit.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QLineEdit.sizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.text": (),
-    "PySide2.QtWidgets.QLineEdit.textMargins": (),
-    "PySide2.QtWidgets.QLineEdit.undo": (),
-    "PySide2.QtWidgets.QLineEdit.validator": (),
-# class PySide2.QtWidgets.QListView:
-# class PySide2.QtWidgets.QListView.Flow:
-# class PySide2.QtWidgets.QListView.LayoutMode:
-# class PySide2.QtWidgets.QListView.Movement:
-# class PySide2.QtWidgets.QListView.ResizeMode:
-# class PySide2.QtWidgets.QListView.ViewMode:
-    "PySide2.QtWidgets.QListView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListView.batchSize": (),
-    "PySide2.QtWidgets.QListView.clearPropertyFlags": (),
-    "PySide2.QtWidgets.QListView.contentsSize": (),
-    "PySide2.QtWidgets.QListView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QListView.doItemsLayout": (),
-    "PySide2.QtWidgets.QListView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QListView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QListView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListView.flow": (),
-    "PySide2.QtWidgets.QListView.gridSize": (),
-    "PySide2.QtWidgets.QListView.horizontalOffset": (),
-    "PySide2.QtWidgets.QListView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QListView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QListView.isSelectionRectVisible": (),
-    "PySide2.QtWidgets.QListView.isWrapping": (),
-    "PySide2.QtWidgets.QListView.itemAlignment": (),
-    "PySide2.QtWidgets.QListView.layoutMode": (),
-    "PySide2.QtWidgets.QListView.modelColumn": (),
-    "PySide2.QtWidgets.QListView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QListView.movement": (),
-    "PySide2.QtWidgets.QListView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QListView.rectForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.reset": (),
-    "PySide2.QtWidgets.QListView.resizeContents": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QListView.resizeMode": (),
-    "PySide2.QtWidgets.QListView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListView.selectedIndexes": (),
-    "PySide2.QtWidgets.QListView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QListView.setBatchSize": ('int',),
-    "PySide2.QtWidgets.QListView.setFlow": ('PySide2.QtWidgets.QListView.Flow',),
-    "PySide2.QtWidgets.QListView.setGridSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListView.setItemAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QListView.setLayoutMode": ('PySide2.QtWidgets.QListView.LayoutMode',),
-    "PySide2.QtWidgets.QListView.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QListView.setMovement": ('PySide2.QtWidgets.QListView.Movement',),
-    "PySide2.QtWidgets.QListView.setPositionForIndex": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.setResizeMode": ('PySide2.QtWidgets.QListView.ResizeMode',),
-    "PySide2.QtWidgets.QListView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QListView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QListView.setSelectionRectVisible": ('bool',),
-    "PySide2.QtWidgets.QListView.setSpacing": ('int',),
-    "PySide2.QtWidgets.QListView.setUniformItemSizes": ('bool',),
-    "PySide2.QtWidgets.QListView.setViewMode": ('PySide2.QtWidgets.QListView.ViewMode',),
-    "PySide2.QtWidgets.QListView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QListView.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QListView.spacing": (),
-    "PySide2.QtWidgets.QListView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QListView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QListView.uniformItemSizes": (),
-    "PySide2.QtWidgets.QListView.updateGeometries": (),
-    "PySide2.QtWidgets.QListView.verticalOffset": (),
-    "PySide2.QtWidgets.QListView.viewMode": (),
-    "PySide2.QtWidgets.QListView.viewOptions": (),
-    "PySide2.QtWidgets.QListView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QListView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QListView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QListView.wordWrap": (),
-# class PySide2.QtWidgets.QListWidget:
-    "PySide2.QtWidgets.QListWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListWidget.addItem": [('PySide2.QtWidgets.QListWidgetItem',), ('str',)],
-    "PySide2.QtWidgets.QListWidget.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QListWidget.clear": (),
-    "PySide2.QtWidgets.QListWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.count": (),
-    "PySide2.QtWidgets.QListWidget.currentItem": (),
-    "PySide2.QtWidgets.QListWidget.currentRow": (),
-    "PySide2.QtWidgets.QListWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListWidget.dropMimeData": ('int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QListWidget.editItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QListWidget.indexFromItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.insertItem": [('int', 'PySide2.QtWidgets.QListWidgetItem'), ('int', 'str')],
-    "PySide2.QtWidgets.QListWidget.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QListWidget.isItemHidden": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isItemSelected": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QListWidget.item": ('int',),
-    "PySide2.QtWidgets.QListWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QListWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListWidget.itemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QListWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QListWidgetItem]',),
-    "PySide2.QtWidgets.QListWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QListWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.removeItemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.row": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.scrollToItem": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListWidget.selectedItems": (),
-    "PySide2.QtWidgets.QListWidget.setCurrentItem": [('PySide2.QtWidgets.QListWidgetItem',), ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setCurrentRow": [('int',), ('int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setItemHidden": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemSelected": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemWidget": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QListWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QListWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QListWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QListWidget.sortItems": ('PySide2.QtCore.Qt.SortOrder',),
-    "PySide2.QtWidgets.QListWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QListWidget.takeItem": ('int',),
-    "PySide2.QtWidgets.QListWidget.visualItemRect": ('PySide2.QtWidgets.QListWidgetItem',),
-# class PySide2.QtWidgets.QListWidgetItem:
-# class PySide2.QtWidgets.QListWidgetItem.ItemType:
-    "PySide2.QtWidgets.QListWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidgetItem',), ('str', 'PySide2.QtWidgets.QListWidget', 'int')],
-    "PySide2.QtWidgets.QListWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.background": (),
-    "PySide2.QtWidgets.QListWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QListWidgetItem.clone": (),
-    "PySide2.QtWidgets.QListWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.flags": (),
-    "PySide2.QtWidgets.QListWidgetItem.font": (),
-    "PySide2.QtWidgets.QListWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QListWidgetItem.icon": (),
-    "PySide2.QtWidgets.QListWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QListWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QListWidgetItem.listWidget": (),
-    "PySide2.QtWidgets.QListWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QListWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QListWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QListWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QListWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QListWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QListWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.text": (),
-    "PySide2.QtWidgets.QListWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QListWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.type": (),
-    "PySide2.QtWidgets.QListWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QListWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QMainWindow:
-# class PySide2.QtWidgets.QMainWindow.DockOption:
-# class PySide2.QtWidgets.QMainWindow.DockOptions:
-    "PySide2.QtWidgets.QMainWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMainWindow.addDockWidget": [('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget'), ('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtWidgets.QMainWindow.addToolBar": [('PySide2.QtCore.Qt.ToolBarArea', 'PySide2.QtWidgets.QToolBar'), ('PySide2.QtWidgets.QToolBar',), ('str',)],
-    "PySide2.QtWidgets.QMainWindow.addToolBarBreak": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QMainWindow.centralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMainWindow.corner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMainWindow.createPopupMenu": (),
-    "PySide2.QtWidgets.QMainWindow.dockOptions": (),
-    "PySide2.QtWidgets.QMainWindow.dockWidgetArea": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.documentMode": (),
-    "PySide2.QtWidgets.QMainWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMainWindow.iconSize": (),
-    "PySide2.QtWidgets.QMainWindow.insertToolBar": ('PySide2.QtWidgets.QToolBar', 'PySide2.QtWidgets.QToolBar'),
-    "PySide2.QtWidgets.QMainWindow.insertToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.isAnimated": (),
-    "PySide2.QtWidgets.QMainWindow.isDockNestingEnabled": (),
-    "PySide2.QtWidgets.QMainWindow.isSeparator": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMainWindow.menuBar": (),
-    "PySide2.QtWidgets.QMainWindow.menuWidget": (),
-    "PySide2.QtWidgets.QMainWindow.removeDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBar": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.resizeDocks": ('typing.Sequence[PySide2.QtWidgets.QDockWidget]', 'typing.Sequence[int]', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.restoreDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.restoreState": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QMainWindow.saveState": ('int',),
-    "PySide2.QtWidgets.QMainWindow.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setCentralWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setCorner": ('PySide2.QtCore.Qt.Corner', 'PySide2.QtCore.Qt.DockWidgetArea'),
-    "PySide2.QtWidgets.QMainWindow.setDockNestingEnabled": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setDockOptions": ('PySide2.QtWidgets.QMainWindow.DockOptions',),
-    "PySide2.QtWidgets.QMainWindow.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QMainWindow.setMenuBar": ('PySide2.QtWidgets.QMenuBar',),
-    "PySide2.QtWidgets.QMainWindow.setMenuWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setStatusBar": ('PySide2.QtWidgets.QStatusBar',),
-    "PySide2.QtWidgets.QMainWindow.setTabPosition": ('PySide2.QtCore.Qt.DockWidgetAreas', 'PySide2.QtWidgets.QTabWidget.TabPosition'),
-    "PySide2.QtWidgets.QMainWindow.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMainWindow.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QMainWindow.setUnifiedTitleAndToolBarOnMac": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.splitDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.statusBar": (),
-    "PySide2.QtWidgets.QMainWindow.tabPosition": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QMainWindow.tabShape": (),
-    "PySide2.QtWidgets.QMainWindow.tabifiedDockWidgets": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.tabifyDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget'),
-    "PySide2.QtWidgets.QMainWindow.takeCentralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.toolBarArea": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolButtonStyle": (),
-    "PySide2.QtWidgets.QMainWindow.unifiedTitleAndToolBarOnMac": (),
-# class PySide2.QtWidgets.QMdiArea:
-# class PySide2.QtWidgets.QMdiArea.AreaOption:
-# class PySide2.QtWidgets.QMdiArea.AreaOptions:
-# class PySide2.QtWidgets.QMdiArea.ViewMode:
-# class PySide2.QtWidgets.QMdiArea.WindowOrder:
-    "PySide2.QtWidgets.QMdiArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.activateNextSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activatePreviousSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activationOrder": (),
-    "PySide2.QtWidgets.QMdiArea.activeSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.addSubWindow": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiArea.background": (),
-    "PySide2.QtWidgets.QMdiArea.cascadeSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiArea.closeActiveSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.closeAllSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.currentSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.documentMode": (),
-    "PySide2.QtWidgets.QMdiArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiArea.removeSubWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QMdiArea.setActivationOrder": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.setActiveSubWindow": ('PySide2.QtWidgets.QMdiSubWindow',),
-    "PySide2.QtWidgets.QMdiArea.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QMdiArea.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setOption": ('PySide2.QtWidgets.QMdiArea.AreaOption', 'bool'),
-    "PySide2.QtWidgets.QMdiArea.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QMdiArea.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMdiArea.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setTabsMovable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setViewMode": ('PySide2.QtWidgets.QMdiArea.ViewMode',),
-    "PySide2.QtWidgets.QMdiArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiArea.sizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.subWindowList": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.tabPosition": (),
-    "PySide2.QtWidgets.QMdiArea.tabShape": (),
-    "PySide2.QtWidgets.QMdiArea.tabsClosable": (),
-    "PySide2.QtWidgets.QMdiArea.tabsMovable": (),
-    "PySide2.QtWidgets.QMdiArea.testOption": ('PySide2.QtWidgets.QMdiArea.AreaOption',),
-    "PySide2.QtWidgets.QMdiArea.tileSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiArea.viewMode": (),
-    "PySide2.QtWidgets.QMdiArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QMdiSubWindow:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOption:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOptions:
-    "PySide2.QtWidgets.QMdiSubWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiSubWindow.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiSubWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.isShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardPageStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardSingleStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedButtonsWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedSystemMenuIconWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mdiArea": (),
-    "PySide2.QtWidgets.QMdiSubWindow.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardPageStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardSingleStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption', 'bool'),
-    "PySide2.QtWidgets.QMdiSubWindow.setSystemMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QMdiSubWindow.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiSubWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.showShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.showSystemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.sizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.systemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.testOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption',),
-    "PySide2.QtWidgets.QMdiSubWindow.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.widget": (),
-# class PySide2.QtWidgets.QMenu:
-    "PySide2.QtWidgets.QMenu.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenu.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenu.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.activeAction": (),
-    "PySide2.QtWidgets.QMenu.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtGui.QIcon', 'str', 'object', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('str', 'object', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtWidgets.QMenu.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSection": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSeparator": (),
-    "PySide2.QtWidgets.QMenu.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.clear": (),
-    "PySide2.QtWidgets.QMenu.columnCount": (),
-    "PySide2.QtWidgets.QMenu.defaultAction": (),
-    "PySide2.QtWidgets.QMenu.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.exec_": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'), ('typing.Sequence[PySide2.QtWidgets.QAction]', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QMenu.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMenu.hideTearOffMenu": (),
-    "PySide2.QtWidgets.QMenu.icon": (),
-    "PySide2.QtWidgets.QMenu.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenu.insertSection": [('PySide2.QtWidgets.QAction', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction', 'str')],
-    "PySide2.QtWidgets.QMenu.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.isEmpty": (),
-    "PySide2.QtWidgets.QMenu.isTearOffEnabled": (),
-    "PySide2.QtWidgets.QMenu.isTearOffMenuVisible": (),
-    "PySide2.QtWidgets.QMenu.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenu.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.menuAction": (),
-    "PySide2.QtWidgets.QMenu.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenu.popup": ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.separatorsCollapsible": (),
-    "PySide2.QtWidgets.QMenu.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setAsDockMenu": (),
-    "PySide2.QtWidgets.QMenu.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QMenu.setSeparatorsCollapsible": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTearOffEnabled": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTitle": ('str',),
-    "PySide2.QtWidgets.QMenu.setToolTipsVisible": ('bool',),
-    "PySide2.QtWidgets.QMenu.showTearOffMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QMenu.sizeHint": (),
-    "PySide2.QtWidgets.QMenu.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMenu.title": (),
-    "PySide2.QtWidgets.QMenu.toolTipsVisible": (),
-    "PySide2.QtWidgets.QMenu.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QMenuBar:
-    "PySide2.QtWidgets.QMenuBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMenuBar.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenuBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenuBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.activeAction": (),
-    "PySide2.QtWidgets.QMenuBar.addAction": [('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'object')],
-    "PySide2.QtWidgets.QMenuBar.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenuBar.addSeparator": (),
-    "PySide2.QtWidgets.QMenuBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.clear": (),
-    "PySide2.QtWidgets.QMenuBar.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMenuBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMenuBar.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QMenuBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenuBar.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenuBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.isDefaultUp": (),
-    "PySide2.QtWidgets.QMenuBar.isNativeMenuBar": (),
-    "PySide2.QtWidgets.QMenuBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenuBar.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenuBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMenuBar.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QMenuBar.setDefaultUp": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setNativeMenuBar": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setVisible": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.sizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QMessageBox:
-# class PySide2.QtWidgets.QMessageBox.ButtonRole:
-# class PySide2.QtWidgets.QMessageBox.Icon:
-# class PySide2.QtWidgets.QMessageBox.StandardButton:
-# class PySide2.QtWidgets.QMessageBox.StandardButtons:
-    "PySide2.QtWidgets.QMessageBox.__init__": [('PySide2.QtWidgets.QMessageBox.Icon', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QMessageBox.about": ('PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QMessageBox.aboutQt": ('PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtWidgets.QMessageBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QMessageBox.ButtonRole'), ('PySide2.QtWidgets.QMessageBox.StandardButton',), ('str', 'PySide2.QtWidgets.QMessageBox.ButtonRole')],
-    "PySide2.QtWidgets.QMessageBox.button": ('PySide2.QtWidgets.QMessageBox.StandardButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonText": ('int',),
-    "PySide2.QtWidgets.QMessageBox.buttons": (),
-    "PySide2.QtWidgets.QMessageBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.checkBox": (),
-    "PySide2.QtWidgets.QMessageBox.clickedButton": (),
-    "PySide2.QtWidgets.QMessageBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMessageBox.critical": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.defaultButton": (),
-    "PySide2.QtWidgets.QMessageBox.detailedText": (),
-    "PySide2.QtWidgets.QMessageBox.escapeButton": (),
-    "PySide2.QtWidgets.QMessageBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.icon": (),
-    "PySide2.QtWidgets.QMessageBox.iconPixmap": (),
-    "PySide2.QtWidgets.QMessageBox.information": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.informativeText": (),
-    "PySide2.QtWidgets.QMessageBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMessageBox.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QMessageBox.question": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMessageBox.setButtonText": ('int', 'str'),
-    "PySide2.QtWidgets.QMessageBox.setCheckBox": ('PySide2.QtWidgets.QCheckBox',),
-    "PySide2.QtWidgets.QMessageBox.setDefaultButton": [('PySide2.QtWidgets.QMessageBox.StandardButton',), ('PySide2.QtWidgets.QPushButton',)],
-    "PySide2.QtWidgets.QMessageBox.setDetailedText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setEscapeButton": [('PySide2.QtWidgets.QAbstractButton',), ('PySide2.QtWidgets.QMessageBox.StandardButton',)],
-    "PySide2.QtWidgets.QMessageBox.setIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.setIconPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QMessageBox.setInformativeText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setStandardButtons": ('PySide2.QtWidgets.QMessageBox.StandardButtons',),
-    "PySide2.QtWidgets.QMessageBox.setText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QMessageBox.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QMessageBox.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QMessageBox.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QMessageBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMessageBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.standardButtons": (),
-    "PySide2.QtWidgets.QMessageBox.standardIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.text": (),
-    "PySide2.QtWidgets.QMessageBox.textFormat": (),
-    "PySide2.QtWidgets.QMessageBox.textInteractionFlags": (),
-    "PySide2.QtWidgets.QMessageBox.warning": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-# class PySide2.QtWidgets.QMouseEventTransition:
-    "PySide2.QtWidgets.QMouseEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QMouseEventTransition.button": (),
-    "PySide2.QtWidgets.QMouseEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.hitTestPath": (),
-    "PySide2.QtWidgets.QMouseEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QMouseEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QMouseEventTransition.setHitTestPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QMouseEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QOpenGLWidget:
-# class PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior:
-    "PySide2.QtWidgets.QOpenGLWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QOpenGLWidget.context": (),
-    "PySide2.QtWidgets.QOpenGLWidget.defaultFramebufferObject": (),
-    "PySide2.QtWidgets.QOpenGLWidget.doneCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.format": (),
-    "PySide2.QtWidgets.QOpenGLWidget.grabFramebuffer": (),
-    "PySide2.QtWidgets.QOpenGLWidget.initializeGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.isValid": (),
-    "PySide2.QtWidgets.QOpenGLWidget.makeCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEngine": (),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtWidgets.QOpenGLWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtWidgets.QOpenGLWidget.setTextureFormat": ('int',),
-    "PySide2.QtWidgets.QOpenGLWidget.setUpdateBehavior": ('PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior',),
-    "PySide2.QtWidgets.QOpenGLWidget.textureFormat": (),
-    "PySide2.QtWidgets.QOpenGLWidget.updateBehavior": (),
-# class PySide2.QtWidgets.QPanGesture:
-    "PySide2.QtWidgets.QPanGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPanGesture.acceleration": (),
-    "PySide2.QtWidgets.QPanGesture.delta": (),
-    "PySide2.QtWidgets.QPanGesture.lastOffset": (),
-    "PySide2.QtWidgets.QPanGesture.offset": (),
-    "PySide2.QtWidgets.QPanGesture.setAcceleration": ('float',),
-    "PySide2.QtWidgets.QPanGesture.setLastOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPanGesture.setOffset": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QPinchGesture:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlag:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlags:
-    "PySide2.QtWidgets.QPinchGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPinchGesture.centerPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.changeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.lastCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.lastRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.lastScaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.rotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.scaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.setCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setLastCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setLastRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setLastScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setStartCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.startCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.totalChangeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.totalRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.totalScaleFactor": (),
-# class PySide2.QtWidgets.QPlainTextDocumentLayout:
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentSize": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.ensureBlockLayout": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.pageCount": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.requestUpdate": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.setCursorWidth": ('int',),
-# class PySide2.QtWidgets.QPlainTextEdit:
-# class PySide2.QtWidgets.QPlainTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QPlainTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPlainTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendHtml": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.backgroundVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingGeometry": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerOnScroll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.clear": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contentOffset": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.copy": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QPlainTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QPlainTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cut": (),
-    "PySide2.QtWidgets.QPlainTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.document": (),
-    "PySide2.QtWidgets.QPlainTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QPlainTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QPlainTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QPlainTextEdit.firstVisibleBlock": (),
-    "PySide2.QtWidgets.QPlainTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.getPaintContext": (),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QPlainTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QPlainTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QPlainTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QPlainTextEdit.maximumBlockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QPlainTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.paste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QPlainTextEdit.redo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QPlainTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.setBackgroundVisible": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCenterOnScroll": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QPlainTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QPlainTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.setMaximumBlockCount": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QPlainTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QPlainTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.undo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QProgressBar:
-# class PySide2.QtWidgets.QProgressBar.Direction:
-    "PySide2.QtWidgets.QProgressBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QProgressBar.alignment": (),
-    "PySide2.QtWidgets.QProgressBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressBar.format": (),
-    "PySide2.QtWidgets.QProgressBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionProgressBar',),
-    "PySide2.QtWidgets.QProgressBar.invertedAppearance": (),
-    "PySide2.QtWidgets.QProgressBar.isTextVisible": (),
-    "PySide2.QtWidgets.QProgressBar.maximum": (),
-    "PySide2.QtWidgets.QProgressBar.minimum": (),
-    "PySide2.QtWidgets.QProgressBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.orientation": (),
-    "PySide2.QtWidgets.QProgressBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QProgressBar.reset": (),
-    "PySide2.QtWidgets.QProgressBar.resetFormat": (),
-    "PySide2.QtWidgets.QProgressBar.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QProgressBar.setFormat": ('str',),
-    "PySide2.QtWidgets.QProgressBar.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QProgressBar.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressBar.setTextDirection": ('PySide2.QtWidgets.QProgressBar.Direction',),
-    "PySide2.QtWidgets.QProgressBar.setTextVisible": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressBar.sizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.text": (),
-    "PySide2.QtWidgets.QProgressBar.textDirection": (),
-    "PySide2.QtWidgets.QProgressBar.value": (),
-# class PySide2.QtWidgets.QProgressDialog:
-    "PySide2.QtWidgets.QProgressDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'str', 'int', 'int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QProgressDialog.autoClose": (),
-    "PySide2.QtWidgets.QProgressDialog.autoReset": (),
-    "PySide2.QtWidgets.QProgressDialog.cancel": (),
-    "PySide2.QtWidgets.QProgressDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QProgressDialog.forceShow": (),
-    "PySide2.QtWidgets.QProgressDialog.labelText": (),
-    "PySide2.QtWidgets.QProgressDialog.maximum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimumDuration": (),
-    "PySide2.QtWidgets.QProgressDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QProgressDialog.reset": (),
-    "PySide2.QtWidgets.QProgressDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoClose": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoReset": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setBar": ('PySide2.QtWidgets.QProgressBar',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButton": ('PySide2.QtWidgets.QPushButton',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setLabel": ('PySide2.QtWidgets.QLabel',),
-    "PySide2.QtWidgets.QProgressDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimumDuration": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressDialog.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QProgressDialog.sizeHint": (),
-    "PySide2.QtWidgets.QProgressDialog.value": (),
-    "PySide2.QtWidgets.QProgressDialog.wasCanceled": (),
-# class PySide2.QtWidgets.QProxyStyle:
-    "PySide2.QtWidgets.QProxyStyle.__init__": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QProxyStyle.baseStyle": (),
-    "PySide2.QtWidgets.QProxyStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QProxyStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProxyStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QProxyStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QProxyStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QProxyStyle.setBaseStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QProxyStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardPalette": (),
-    "PySide2.QtWidgets.QProxyStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QProxyStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QPushButton:
-    "PySide2.QtWidgets.QPushButton.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPushButton.autoDefault": (),
-    "PySide2.QtWidgets.QPushButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPushButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QPushButton.isDefault": (),
-    "PySide2.QtWidgets.QPushButton.isFlat": (),
-    "PySide2.QtWidgets.QPushButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPushButton.menu": (),
-    "PySide2.QtWidgets.QPushButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QPushButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPushButton.setAutoDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setFlat": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QPushButton.showMenu": (),
-    "PySide2.QtWidgets.QPushButton.sizeHint": (),
-# class PySide2.QtWidgets.QRadioButton:
-    "PySide2.QtWidgets.QRadioButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QRadioButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRadioButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QRadioButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QRadioButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QRadioButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QRadioButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRadioButton.sizeHint": (),
-# class PySide2.QtWidgets.QRubberBand:
-# class PySide2.QtWidgets.QRubberBand.Shape:
-    "PySide2.QtWidgets.QRubberBand.__init__": ('PySide2.QtWidgets.QRubberBand.Shape', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QRubberBand.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.initStyleOption": ('PySide2.QtWidgets.QStyleOptionRubberBand',),
-    "PySide2.QtWidgets.QRubberBand.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QRubberBand.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRubberBand.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QRubberBand.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.shape": (),
-    "PySide2.QtWidgets.QRubberBand.showEvent": ('PySide2.QtGui.QShowEvent',),
-# class PySide2.QtWidgets.QScrollArea:
-    "PySide2.QtWidgets.QScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.alignment": (),
-    "PySide2.QtWidgets.QScrollArea.ensureVisible": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.ensureWidgetVisible": ('PySide2.QtWidgets.QWidget', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QScrollArea.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QScrollArea.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.setWidgetResizable": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.takeWidget": (),
-    "PySide2.QtWidgets.QScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.widget": (),
-    "PySide2.QtWidgets.QScrollArea.widgetResizable": (),
-# class PySide2.QtWidgets.QScrollBar:
-    "PySide2.QtWidgets.QScrollBar.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QScrollBar.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QScrollBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QScrollBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QScrollBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QScrollBar.sizeHint": (),
-    "PySide2.QtWidgets.QScrollBar.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QScrollBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QScroller:
-# class PySide2.QtWidgets.QScroller.Input:
-# class PySide2.QtWidgets.QScroller.ScrollerGestureType:
-# class PySide2.QtWidgets.QScroller.State:
-    "PySide2.QtWidgets.QScroller.activeScrollers": (),
-    "PySide2.QtWidgets.QScroller.ensureVisible": [('PySide2.QtCore.QRectF', 'float', 'float'), ('PySide2.QtCore.QRectF', 'float', 'float', 'int')],
-    "PySide2.QtWidgets.QScroller.finalPosition": (),
-    "PySide2.QtWidgets.QScroller.grabGesture": ('PySide2.QtCore.QObject', 'PySide2.QtWidgets.QScroller.ScrollerGestureType'),
-    "PySide2.QtWidgets.QScroller.grabbedGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.handleInput": ('PySide2.QtWidgets.QScroller.Input', 'PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtWidgets.QScroller.hasScroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.pixelPerMeter": (),
-    "PySide2.QtWidgets.QScroller.resendPrepareEvent": (),
-    "PySide2.QtWidgets.QScroller.scrollTo": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtWidgets.QScroller.scroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.scrollerProperties": (),
-    "PySide2.QtWidgets.QScroller.setScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScroller.setSnapPositionsX": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.setSnapPositionsY": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.state": (),
-    "PySide2.QtWidgets.QScroller.stop": (),
-    "PySide2.QtWidgets.QScroller.target": (),
-    "PySide2.QtWidgets.QScroller.ungrabGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.velocity": (),
-# class PySide2.QtWidgets.QScrollerProperties:
-# class PySide2.QtWidgets.QScrollerProperties.FrameRates:
-# class PySide2.QtWidgets.QScrollerProperties.OvershootPolicy:
-# class PySide2.QtWidgets.QScrollerProperties.ScrollMetric:
-    "PySide2.QtWidgets.QScrollerProperties.__init__": [(), ('PySide2.QtWidgets.QScrollerProperties',)],
-    "PySide2.QtWidgets.QScrollerProperties.__copy__": (),
-    "PySide2.QtWidgets.QScrollerProperties.scrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric',),
-    "PySide2.QtWidgets.QScrollerProperties.setDefaultScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScrollerProperties.setScrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric', 'typing.Any'),
-    "PySide2.QtWidgets.QScrollerProperties.unsetDefaultScrollerProperties": (),
-# class PySide2.QtWidgets.QShortcut:
-    "PySide2.QtWidgets.QShortcut.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'typing.Callable', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QShortcut.autoRepeat": (),
-    "PySide2.QtWidgets.QShortcut.context": (),
-    "PySide2.QtWidgets.QShortcut.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QShortcut.id": (),
-    "PySide2.QtWidgets.QShortcut.isEnabled": (),
-    "PySide2.QtWidgets.QShortcut.key": (),
-    "PySide2.QtWidgets.QShortcut.parentWidget": (),
-    "PySide2.QtWidgets.QShortcut.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QShortcut.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setKey": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QShortcut.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QShortcut.whatsThis": (),
-# class PySide2.QtWidgets.QSizeGrip:
-    "PySide2.QtWidgets.QSizeGrip.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSizeGrip.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSizeGrip.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QSizeGrip.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QSizeGrip.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSizeGrip.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSizeGrip.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QSizeGrip.sizeHint": (),
-# class PySide2.QtWidgets.QSizePolicy:
-# class PySide2.QtWidgets.QSizePolicy.ControlType:
-# class PySide2.QtWidgets.QSizePolicy.ControlTypes:
-# class PySide2.QtWidgets.QSizePolicy.Policy:
-# class PySide2.QtWidgets.QSizePolicy.PolicyFlag:
-    "PySide2.QtWidgets.QSizePolicy.__init__": [(), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QSizePolicy.__copy__": (),
-    "PySide2.QtWidgets.QSizePolicy.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.controlType": (),
-    "PySide2.QtWidgets.QSizePolicy.expandingDirections": (),
-    "PySide2.QtWidgets.QSizePolicy.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QSizePolicy.hasWidthForHeight": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalStretch": (),
-    "PySide2.QtWidgets.QSizePolicy.retainSizeWhenHidden": (),
-    "PySide2.QtWidgets.QSizePolicy.setControlType": ('PySide2.QtWidgets.QSizePolicy.ControlType',),
-    "PySide2.QtWidgets.QSizePolicy.setHeightForWidth": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setRetainSizeWhenHidden": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setWidthForHeight": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.transpose": (),
-    "PySide2.QtWidgets.QSizePolicy.transposed": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalStretch": (),
-# class PySide2.QtWidgets.QSlider:
-# class PySide2.QtWidgets.QSlider.TickPosition:
-    "PySide2.QtWidgets.QSlider.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSlider.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QSlider.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSlider.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSlider.setTickInterval": ('int',),
-    "PySide2.QtWidgets.QSlider.setTickPosition": ('PySide2.QtWidgets.QSlider.TickPosition',),
-    "PySide2.QtWidgets.QSlider.sizeHint": (),
-    "PySide2.QtWidgets.QSlider.tickInterval": (),
-    "PySide2.QtWidgets.QSlider.tickPosition": (),
-# class PySide2.QtWidgets.QSpacerItem:
-    "PySide2.QtWidgets.QSpacerItem.__init__": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.changeSize": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.expandingDirections": (),
-    "PySide2.QtWidgets.QSpacerItem.geometry": (),
-    "PySide2.QtWidgets.QSpacerItem.isEmpty": (),
-    "PySide2.QtWidgets.QSpacerItem.maximumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.minimumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QSpacerItem.sizeHint": (),
-    "PySide2.QtWidgets.QSpacerItem.sizePolicy": (),
-    "PySide2.QtWidgets.QSpacerItem.spacerItem": (),
-# class PySide2.QtWidgets.QSpinBox:
-    "PySide2.QtWidgets.QSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QSpinBox.displayIntegerBase": (),
-    "PySide2.QtWidgets.QSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QSpinBox.maximum": (),
-    "PySide2.QtWidgets.QSpinBox.minimum": (),
-    "PySide2.QtWidgets.QSpinBox.prefix": (),
-    "PySide2.QtWidgets.QSpinBox.setDisplayIntegerBase": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMaximum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMinimum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QSpinBox.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QSpinBox.stepType": (),
-    "PySide2.QtWidgets.QSpinBox.suffix": (),
-    "PySide2.QtWidgets.QSpinBox.textFromValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QSpinBox.value": (),
-    "PySide2.QtWidgets.QSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QSplashScreen:
-    "PySide2.QtWidgets.QSplashScreen.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QSplashScreen.clearMessage": (),
-    "PySide2.QtWidgets.QSplashScreen.drawContents": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QSplashScreen.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplashScreen.finish": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplashScreen.message": (),
-    "PySide2.QtWidgets.QSplashScreen.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplashScreen.pixmap": (),
-    "PySide2.QtWidgets.QSplashScreen.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QSplashScreen.showMessage": ('str', 'int', 'PySide2.QtGui.QColor'),
-# class PySide2.QtWidgets.QSplitter:
-    "PySide2.QtWidgets.QSplitter.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSplitter.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.__rshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QSplitter.childrenCollapsible": (),
-    "PySide2.QtWidgets.QSplitter.closestLegalPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.count": (),
-    "PySide2.QtWidgets.QSplitter.createHandle": (),
-    "PySide2.QtWidgets.QSplitter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.getRange": ('int',),
-    "PySide2.QtWidgets.QSplitter.handle": ('int',),
-    "PySide2.QtWidgets.QSplitter.handleWidth": (),
-    "PySide2.QtWidgets.QSplitter.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.isCollapsible": ('int',),
-    "PySide2.QtWidgets.QSplitter.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSplitter.moveSplitter": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitter.orientation": (),
-    "PySide2.QtWidgets.QSplitter.refresh": (),
-    "PySide2.QtWidgets.QSplitter.replaceWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitter.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QSplitter.saveState": (),
-    "PySide2.QtWidgets.QSplitter.setChildrenCollapsible": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setCollapsible": ('int', 'bool'),
-    "PySide2.QtWidgets.QSplitter.setHandleWidth": ('int',),
-    "PySide2.QtWidgets.QSplitter.setOpaqueResize": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitter.setRubberBand": ('int',),
-    "PySide2.QtWidgets.QSplitter.setSizes": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QSplitter.setStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.sizeHint": (),
-    "PySide2.QtWidgets.QSplitter.sizes": (),
-    "PySide2.QtWidgets.QSplitter.widget": ('int',),
-# class PySide2.QtWidgets.QSplitterHandle:
-    "PySide2.QtWidgets.QSplitterHandle.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QSplitter'),
-    "PySide2.QtWidgets.QSplitterHandle.closestLegalPosition": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.moveSplitter": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitterHandle.orientation": (),
-    "PySide2.QtWidgets.QSplitterHandle.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitterHandle.sizeHint": (),
-    "PySide2.QtWidgets.QSplitterHandle.splitter": (),
-# class PySide2.QtWidgets.QStackedLayout:
-# class PySide2.QtWidgets.QStackedLayout.StackingMode:
-    "PySide2.QtWidgets.QStackedLayout.__init__": [(), ('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStackedLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QStackedLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.count": (),
-    "PySide2.QtWidgets.QStackedLayout.currentIndex": (),
-    "PySide2.QtWidgets.QStackedLayout.currentWidget": (),
-    "PySide2.QtWidgets.QStackedLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QStackedLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.minimumSize": (),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QStackedLayout.setStackingMode": ('PySide2.QtWidgets.QStackedLayout.StackingMode',),
-    "PySide2.QtWidgets.QStackedLayout.sizeHint": (),
-    "PySide2.QtWidgets.QStackedLayout.stackingMode": (),
-    "PySide2.QtWidgets.QStackedLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.widget": [(), ('int',)],
-# class PySide2.QtWidgets.QStackedWidget:
-    "PySide2.QtWidgets.QStackedWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.count": (),
-    "PySide2.QtWidgets.QStackedWidget.currentIndex": (),
-    "PySide2.QtWidgets.QStackedWidget.currentWidget": (),
-    "PySide2.QtWidgets.QStackedWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStackedWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedWidget.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.widget": ('int',),
-# class PySide2.QtWidgets.QStatusBar:
-    "PySide2.QtWidgets.QStatusBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.addPermanentWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.addWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.clearMessage": (),
-    "PySide2.QtWidgets.QStatusBar.currentMessage": (),
-    "PySide2.QtWidgets.QStatusBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStatusBar.hideOrShow": (),
-    "PySide2.QtWidgets.QStatusBar.insertPermanentWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QStatusBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QStatusBar.reformat": (),
-    "PySide2.QtWidgets.QStatusBar.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QStatusBar.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QStatusBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QStatusBar.showMessage": ('str', 'int'),
-# class PySide2.QtWidgets.QStyle:
-# class PySide2.QtWidgets.QStyle.ComplexControl:
-# class PySide2.QtWidgets.QStyle.ContentsType:
-# class PySide2.QtWidgets.QStyle.ControlElement:
-# class PySide2.QtWidgets.QStyle.PixelMetric:
-# class PySide2.QtWidgets.QStyle.PrimitiveElement:
-# class PySide2.QtWidgets.QStyle.RequestSoftwareInputPanel:
-# class PySide2.QtWidgets.QStyle.StandardPixmap:
-# class PySide2.QtWidgets.QStyle.State:
-# class PySide2.QtWidgets.QStyle.StateFlag:
-# class PySide2.QtWidgets.QStyle.StyleHint:
-# class PySide2.QtWidgets.QStyle.SubControl:
-# class PySide2.QtWidgets.QStyle.SubControls:
-# class PySide2.QtWidgets.QStyle.SubElement:
-    "PySide2.QtWidgets.QStyle.__init__": (),
-    "PySide2.QtWidgets.QStyle.alignedRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QStyle.combinedLayoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.proxy": (),
-    "PySide2.QtWidgets.QStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.sliderPositionFromValue": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.sliderValueFromPosition": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.standardPalette": (),
-    "PySide2.QtWidgets.QStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.visualAlignment": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QStyle.visualPos": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QStyle.visualRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QRect'),
-# class PySide2.QtWidgets.QStyleFactory:
-    "PySide2.QtWidgets.QStyleFactory.__init__": (),
-    "PySide2.QtWidgets.QStyleFactory.create": ('str',),
-    "PySide2.QtWidgets.QStyleFactory.keys": (),
-# class PySide2.QtWidgets.QStyleHintReturn:
-# class PySide2.QtWidgets.QStyleHintReturn.HintReturnType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturn.__init__": ('int', 'int'),
-# class PySide2.QtWidgets.QStyleHintReturnMask:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnMask.__init__": (),
-# class PySide2.QtWidgets.QStyleHintReturnVariant:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnVariant.__init__": (),
-# class PySide2.QtWidgets.QStyleOption:
-# class PySide2.QtWidgets.QStyleOption.OptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOption.__init__": [('PySide2.QtWidgets.QStyleOption',), ('int', 'int')],
-    "PySide2.QtWidgets.QStyleOption.init": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStyleOption.initFrom": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QStyleOptionButton:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeatures:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComboBox:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComboBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionComboBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComplex:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComplex.__init__": [('PySide2.QtWidgets.QStyleOptionComplex',), ('int', 'int')],
-# class PySide2.QtWidgets.QStyleOptionDockWidget:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionDockWidget.__init__": [(), ('PySide2.QtWidgets.QStyleOptionDockWidget',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFocusRect:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFocusRect.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFocusRect',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFrame:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeature:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeatures:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGraphicsItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.levelOfDetailFromTransform": ('PySide2.QtGui.QTransform',),
-# class PySide2.QtWidgets.QStyleOptionGroupBox:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGroupBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGroupBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionHeader:
-# class PySide2.QtWidgets.QStyleOptionHeader.SectionPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SortIndicator:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionHeader.__init__": [(), ('PySide2.QtWidgets.QStyleOptionHeader',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionMenuItem:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.CheckType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.MenuItemType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionMenuItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionMenuItem',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionProgressBar:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionProgressBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionProgressBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionRubberBand:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionRubberBand.__init__": [(), ('PySide2.QtWidgets.QStyleOptionRubberBand',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSizeGrip:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSizeGrip.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSizeGrip',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSlider:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSlider.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSlider',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSpinBox:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSpinBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSpinBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTab:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidget:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidgets:
-# class PySide2.QtWidgets.QStyleOptionTab.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeature:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeatures:
-# class PySide2.QtWidgets.QStyleOptionTab.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionTab.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTab',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabBarBase:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabBarBase.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabBarBase',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabWidgetFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTitleBar:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTitleBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTitleBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBar:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeature:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeatures:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBox:
-# class PySide2.QtWidgets.QStyleOptionToolBox.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBox.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolButton:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeatures:
-    "PySide2.QtWidgets.QStyleOptionToolButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionViewItem:
-# class PySide2.QtWidgets.QStyleOptionViewItem.Position:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeature:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeatures:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemPosition:
-    "PySide2.QtWidgets.QStyleOptionViewItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionViewItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionViewItem.__copy__": (),
-# class PySide2.QtWidgets.QStylePainter:
-    "PySide2.QtWidgets.QStylePainter.__init__": [(), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.begin": [('PySide2.QtGui.QPaintDevice',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex'),
-    "PySide2.QtWidgets.QStylePainter.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.drawItemPixmap": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStylePainter.drawItemText": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStylePainter.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.style": (),
-# class PySide2.QtWidgets.QStyledItemDelegate:
-    "PySide2.QtWidgets.QStyledItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QStyledItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.displayText": ('typing.Any', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtWidgets.QStyledItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QStyledItemDelegate.initStyleOption": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QStyledItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QStyledItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QSwipeGesture:
-# class PySide2.QtWidgets.QSwipeGesture.SwipeDirection:
-    "PySide2.QtWidgets.QSwipeGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QSwipeGesture.horizontalDirection": (),
-    "PySide2.QtWidgets.QSwipeGesture.setSwipeAngle": ('float',),
-    "PySide2.QtWidgets.QSwipeGesture.swipeAngle": (),
-    "PySide2.QtWidgets.QSwipeGesture.verticalDirection": (),
-# class PySide2.QtWidgets.QSystemTrayIcon:
-# class PySide2.QtWidgets.QSystemTrayIcon.ActivationReason:
-# class PySide2.QtWidgets.QSystemTrayIcon.MessageIcon:
-    "PySide2.QtWidgets.QSystemTrayIcon.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QSystemTrayIcon.contextMenu": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSystemTrayIcon.geometry": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.hide": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.icon": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isSystemTrayAvailable": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isVisible": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.setContextMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setToolTip": ('str',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSystemTrayIcon.show": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.showMessage": [('str', 'str', 'PySide2.QtGui.QIcon', 'int'), ('str', 'str', 'PySide2.QtWidgets.QSystemTrayIcon.MessageIcon', 'int')],
-    "PySide2.QtWidgets.QSystemTrayIcon.supportsMessages": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.toolTip": (),
-# class PySide2.QtWidgets.QTabBar:
-# class PySide2.QtWidgets.QTabBar.ButtonPosition:
-# class PySide2.QtWidgets.QTabBar.SelectionBehavior:
-# class PySide2.QtWidgets.QTabBar.Shape:
-    "PySide2.QtWidgets.QTabBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabBar.accessibleTabName": ('int',),
-    "PySide2.QtWidgets.QTabBar.addTab": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QTabBar.autoHide": (),
-    "PySide2.QtWidgets.QTabBar.changeCurrentOnDrag": (),
-    "PySide2.QtWidgets.QTabBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.count": (),
-    "PySide2.QtWidgets.QTabBar.currentIndex": (),
-    "PySide2.QtWidgets.QTabBar.documentMode": (),
-    "PySide2.QtWidgets.QTabBar.drawBase": (),
-    "PySide2.QtWidgets.QTabBar.elideMode": (),
-    "PySide2.QtWidgets.QTabBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.expanding": (),
-    "PySide2.QtWidgets.QTabBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QTabBar.iconSize": (),
-    "PySide2.QtWidgets.QTabBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTab', 'int'),
-    "PySide2.QtWidgets.QTabBar.insertTab": [('int', 'PySide2.QtGui.QIcon', 'str'), ('int', 'str')],
-    "PySide2.QtWidgets.QTabBar.isMovable": (),
-    "PySide2.QtWidgets.QTabBar.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabBar.minimumTabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.moveTab": ('int', 'int'),
-    "PySide2.QtWidgets.QTabBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabBar.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabBar.selectionBehaviorOnRemove": (),
-    "PySide2.QtWidgets.QTabBar.setAccessibleTabName": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setChangeCurrentOnDrag": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabBar.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setDrawBase": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabBar.setExpanding": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setSelectionBehaviorOnRemove": ('PySide2.QtWidgets.QTabBar.SelectionBehavior',),
-    "PySide2.QtWidgets.QTabBar.setShape": ('PySide2.QtWidgets.QTabBar.Shape',),
-    "PySide2.QtWidgets.QTabBar.setTabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTabBar.setTabData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTabBar.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabBar.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabBar.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTabBar.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabBar.shape": (),
-    "PySide2.QtWidgets.QTabBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabBar.sizeHint": (),
-    "PySide2.QtWidgets.QTabBar.tabAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTabBar.tabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition'),
-    "PySide2.QtWidgets.QTabBar.tabData": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabLayoutChange": (),
-    "PySide2.QtWidgets.QTabBar.tabRect": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabText": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabTextColor": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabsClosable": (),
-    "PySide2.QtWidgets.QTabBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTabBar.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QTabWidget:
-# class PySide2.QtWidgets.QTabWidget.TabPosition:
-# class PySide2.QtWidgets.QTabWidget.TabShape:
-    "PySide2.QtWidgets.QTabWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.addTab": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.clear": (),
-    "PySide2.QtWidgets.QTabWidget.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QTabWidget.count": (),
-    "PySide2.QtWidgets.QTabWidget.currentIndex": (),
-    "PySide2.QtWidgets.QTabWidget.currentWidget": (),
-    "PySide2.QtWidgets.QTabWidget.documentMode": (),
-    "PySide2.QtWidgets.QTabWidget.elideMode": (),
-    "PySide2.QtWidgets.QTabWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QTabWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QTabWidget.iconSize": (),
-    "PySide2.QtWidgets.QTabWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',),
-    "PySide2.QtWidgets.QTabWidget.insertTab": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.isMovable": (),
-    "PySide2.QtWidgets.QTabWidget.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabWidget.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabWidget.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QTabWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabWidget.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabWidget.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabBar": ('PySide2.QtWidgets.QTabBar',),
-    "PySide2.QtWidgets.QTabWidget.setTabBarAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabWidget.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabWidget.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QTabWidget.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QTabWidget.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabWidget.sizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.tabBar": (),
-    "PySide2.QtWidgets.QTabWidget.tabBarAutoHide": (),
-    "PySide2.QtWidgets.QTabWidget.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabPosition": (),
-    "PySide2.QtWidgets.QTabWidget.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabShape": (),
-    "PySide2.QtWidgets.QTabWidget.tabText": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabsClosable": (),
-    "PySide2.QtWidgets.QTabWidget.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabWidget.widget": ('int',),
-# class PySide2.QtWidgets.QTableView:
-    "PySide2.QtWidgets.QTableView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTableView.clearSpans": (),
-    "PySide2.QtWidgets.QTableView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTableView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTableView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTableView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTableView.gridStyle": (),
-    "PySide2.QtWidgets.QTableView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.hideRow": ('int',),
-    "PySide2.QtWidgets.QTableView.horizontalHeader": (),
-    "PySide2.QtWidgets.QTableView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTableView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTableView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isCornerButtonEnabled": (),
-    "PySide2.QtWidgets.QTableView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTableView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTableView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeColumnsToContents": (),
-    "PySide2.QtWidgets.QTableView.resizeRowToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeRowsToContents": (),
-    "PySide2.QtWidgets.QTableView.rowAt": ('int',),
-    "PySide2.QtWidgets.QTableView.rowCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowHeight": ('int',),
-    "PySide2.QtWidgets.QTableView.rowMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableView.selectColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.selectRow": ('int',),
-    "PySide2.QtWidgets.QTableView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTableView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTableView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setCornerButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setGridStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtWidgets.QTableView.setHorizontalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.setRowHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTableView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTableView.setShowGrid": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSpan": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.setVerticalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTableView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.showGrid": (),
-    "PySide2.QtWidgets.QTableView.showRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTableView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTableView.updateGeometries": (),
-    "PySide2.QtWidgets.QTableView.verticalHeader": (),
-    "PySide2.QtWidgets.QTableView.verticalOffset": (),
-    "PySide2.QtWidgets.QTableView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.viewOptions": (),
-    "PySide2.QtWidgets.QTableView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTableView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTableView.wordWrap": (),
-# class PySide2.QtWidgets.QTableWidget:
-    "PySide2.QtWidgets.QTableWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTableWidget.cellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.clear": (),
-    "PySide2.QtWidgets.QTableWidget.clearContents": (),
-    "PySide2.QtWidgets.QTableWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.column": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.columnCount": (),
-    "PySide2.QtWidgets.QTableWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTableWidget.currentItem": (),
-    "PySide2.QtWidgets.QTableWidget.currentRow": (),
-    "PySide2.QtWidgets.QTableWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTableWidget.dropMimeData": ('int', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTableWidget.editItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTableWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QTableWidget.horizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.indexFromItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.insertColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.insertRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.isItemSelected": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableWidget.item": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTableWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableWidget.itemPrototype": (),
-    "PySide2.QtWidgets.QTableWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTableWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTableWidgetItem]',),
-    "PySide2.QtWidgets.QTableWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTableWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.removeCellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.removeColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.removeRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.row": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.rowCount": (),
-    "PySide2.QtWidgets.QTableWidget.scrollToItem": ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTableWidget.selectedRanges": (),
-    "PySide2.QtWidgets.QTableWidget.setCellWidget": ('int', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTableWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setCurrentCell": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setCurrentItem": [('PySide2.QtWidgets.QTableWidgetItem',), ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.setItem": ('int', 'int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setItemPrototype": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.setItemSelected": ('PySide2.QtWidgets.QTableWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableWidget.setRangeSelected": ('PySide2.QtWidgets.QTableWidgetSelectionRange', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setRowCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTableWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTableWidget.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.takeItem": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.verticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualItemRect": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.visualRow": ('int',),
-# class PySide2.QtWidgets.QTableWidgetItem:
-# class PySide2.QtWidgets.QTableWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTableWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'int'), ('PySide2.QtWidgets.QTableWidgetItem',), ('int',), ('str', 'int')],
-    "PySide2.QtWidgets.QTableWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.background": (),
-    "PySide2.QtWidgets.QTableWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QTableWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTableWidgetItem.column": (),
-    "PySide2.QtWidgets.QTableWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTableWidgetItem.font": (),
-    "PySide2.QtWidgets.QTableWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QTableWidgetItem.icon": (),
-    "PySide2.QtWidgets.QTableWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTableWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.row": (),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QTableWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTableWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTableWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTableWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTableWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QTableWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.tableWidget": (),
-    "PySide2.QtWidgets.QTableWidgetItem.text": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.type": (),
-    "PySide2.QtWidgets.QTableWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QTableWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTableWidgetSelectionRange:
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__init__": [(), ('PySide2.QtWidgets.QTableWidgetSelectionRange',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__copy__": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.bottomRow": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.columnCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.leftColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rightColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rowCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.topRow": (),
-# class PySide2.QtWidgets.QTapAndHoldGesture:
-    "PySide2.QtWidgets.QTapAndHoldGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.position": (),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setTimeout": ('int',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.timeout": (),
-# class PySide2.QtWidgets.QTapGesture:
-    "PySide2.QtWidgets.QTapGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapGesture.position": (),
-    "PySide2.QtWidgets.QTapGesture.setPosition": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QTextBrowser:
-    "PySide2.QtWidgets.QTextBrowser.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTextBrowser.backward": (),
-    "PySide2.QtWidgets.QTextBrowser.backwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.clearHistory": (),
-    "PySide2.QtWidgets.QTextBrowser.doSetSource": ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType'),
-    "PySide2.QtWidgets.QTextBrowser.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextBrowser.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextBrowser.forward": (),
-    "PySide2.QtWidgets.QTextBrowser.forwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.historyTitle": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.historyUrl": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.home": (),
-    "PySide2.QtWidgets.QTextBrowser.isBackwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.isForwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextBrowser.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextBrowser.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.openExternalLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.openLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextBrowser.reload": (),
-    "PySide2.QtWidgets.QTextBrowser.searchPaths": (),
-    "PySide2.QtWidgets.QTextBrowser.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setOpenLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTextBrowser.setSource": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType')],
-    "PySide2.QtWidgets.QTextBrowser.source": (),
-    "PySide2.QtWidgets.QTextBrowser.sourceType": (),
-# class PySide2.QtWidgets.QTextEdit:
-# class PySide2.QtWidgets.QTextEdit.AutoFormatting:
-# class PySide2.QtWidgets.QTextEdit.AutoFormattingFlag:
-# class PySide2.QtWidgets.QTextEdit.ExtraSelection:
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__init__": [(), ('PySide2.QtWidgets.QTextEdit.ExtraSelection',)],
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__copy__": (),
-# class PySide2.QtWidgets.QTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTextEdit.acceptRichText": (),
-    "PySide2.QtWidgets.QTextEdit.alignment": (),
-    "PySide2.QtWidgets.QTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.append": ('str',),
-    "PySide2.QtWidgets.QTextEdit.autoFormatting": (),
-    "PySide2.QtWidgets.QTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.clear": (),
-    "PySide2.QtWidgets.QTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QTextEdit.copy": (),
-    "PySide2.QtWidgets.QTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QTextEdit.currentFont": (),
-    "PySide2.QtWidgets.QTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QTextEdit.cut": (),
-    "PySide2.QtWidgets.QTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.document": (),
-    "PySide2.QtWidgets.QTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.fontFamily": (),
-    "PySide2.QtWidgets.QTextEdit.fontItalic": (),
-    "PySide2.QtWidgets.QTextEdit.fontPointSize": (),
-    "PySide2.QtWidgets.QTextEdit.fontUnderline": (),
-    "PySide2.QtWidgets.QTextEdit.fontWeight": (),
-    "PySide2.QtWidgets.QTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.insertHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.lineWrapColumnOrWidth": (),
-    "PySide2.QtWidgets.QTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextEdit.paste": (),
-    "PySide2.QtWidgets.QTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QTextEdit.redo": (),
-    "PySide2.QtWidgets.QTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTextEdit.scrollToAnchor": ('str',),
-    "PySide2.QtWidgets.QTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QTextEdit.setAcceptRichText": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QTextEdit.setAutoFormatting": ('PySide2.QtWidgets.QTextEdit.AutoFormatting',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QTextEdit.setFontFamily": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setFontItalic": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontPointSize": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setFontUnderline": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontWeight": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapColumnOrWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QTextEdit.setMarkdown": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setTextBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QTextEdit.textBackgroundColor": (),
-    "PySide2.QtWidgets.QTextEdit.textColor": (),
-    "PySide2.QtWidgets.QTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTextEdit.toHtml": (),
-    "PySide2.QtWidgets.QTextEdit.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtWidgets.QTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QTextEdit.undo": (),
-    "PySide2.QtWidgets.QTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QTileRules:
-    "PySide2.QtWidgets.QTileRules.__init__": [('PySide2.QtCore.Qt.TileRule',), ('PySide2.QtCore.Qt.TileRule', 'PySide2.QtCore.Qt.TileRule'), ('PySide2.QtWidgets.QTileRules',)],
-    "PySide2.QtWidgets.QTileRules.__copy__": (),
-# class PySide2.QtWidgets.QTimeEdit:
-    "PySide2.QtWidgets.QTimeEdit.__init__": [('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QToolBar:
-    "PySide2.QtWidgets.QToolBar.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QToolBar.actionAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QToolBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QToolBar.addSeparator": (),
-    "PySide2.QtWidgets.QToolBar.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBar.allowedAreas": (),
-    "PySide2.QtWidgets.QToolBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.clear": (),
-    "PySide2.QtWidgets.QToolBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.iconSize": (),
-    "PySide2.QtWidgets.QToolBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolBar',),
-    "PySide2.QtWidgets.QToolBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.insertWidget": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QToolBar.isAreaAllowed": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QToolBar.isFloatable": (),
-    "PySide2.QtWidgets.QToolBar.isFloating": (),
-    "PySide2.QtWidgets.QToolBar.isMovable": (),
-    "PySide2.QtWidgets.QToolBar.orientation": (),
-    "PySide2.QtWidgets.QToolBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolBar.setAllowedAreas": ('PySide2.QtCore.Qt.ToolBarAreas',),
-    "PySide2.QtWidgets.QToolBar.setFloatable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QToolBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QToolBar.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolBar.toggleViewAction": (),
-    "PySide2.QtWidgets.QToolBar.toolButtonStyle": (),
-    "PySide2.QtWidgets.QToolBar.widgetForAction": ('PySide2.QtWidgets.QAction',),
-# class PySide2.QtWidgets.QToolBox:
-    "PySide2.QtWidgets.QToolBox.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QToolBox.addItem": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.count": (),
-    "PySide2.QtWidgets.QToolBox.currentIndex": (),
-    "PySide2.QtWidgets.QToolBox.currentWidget": (),
-    "PySide2.QtWidgets.QToolBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.insertItem": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.isItemEnabled": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemInserted": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemRemoved": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemText": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemToolTip": ('int',),
-    "PySide2.QtWidgets.QToolBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.setItemEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QToolBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QToolBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.setItemToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QToolBox.widget": ('int',),
-# class PySide2.QtWidgets.QToolButton:
-# class PySide2.QtWidgets.QToolButton.ToolButtonPopupMode:
-    "PySide2.QtWidgets.QToolButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolButton.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolButton.arrowType": (),
-    "PySide2.QtWidgets.QToolButton.autoRaise": (),
-    "PySide2.QtWidgets.QToolButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.defaultAction": (),
-    "PySide2.QtWidgets.QToolButton.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QToolButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolButton',),
-    "PySide2.QtWidgets.QToolButton.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.menu": (),
-    "PySide2.QtWidgets.QToolButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QToolButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.nextCheckState": (),
-    "PySide2.QtWidgets.QToolButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolButton.popupMode": (),
-    "PySide2.QtWidgets.QToolButton.setArrowType": ('PySide2.QtCore.Qt.ArrowType',),
-    "PySide2.QtWidgets.QToolButton.setAutoRaise": ('bool',),
-    "PySide2.QtWidgets.QToolButton.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QToolButton.setPopupMode": ('PySide2.QtWidgets.QToolButton.ToolButtonPopupMode',),
-    "PySide2.QtWidgets.QToolButton.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolButton.showMenu": (),
-    "PySide2.QtWidgets.QToolButton.sizeHint": (),
-    "PySide2.QtWidgets.QToolButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QToolButton.toolButtonStyle": (),
-# class PySide2.QtWidgets.QToolTip:
-    "PySide2.QtWidgets.QToolTip.font": (),
-    "PySide2.QtWidgets.QToolTip.hideText": (),
-    "PySide2.QtWidgets.QToolTip.isVisible": (),
-    "PySide2.QtWidgets.QToolTip.palette": (),
-    "PySide2.QtWidgets.QToolTip.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QToolTip.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QToolTip.showText": [('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect', 'int')],
-    "PySide2.QtWidgets.QToolTip.text": (),
-# class PySide2.QtWidgets.QTreeView:
-    "PySide2.QtWidgets.QTreeView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeView.allColumnsShowFocus": (),
-    "PySide2.QtWidgets.QTreeView.autoExpandDelay": (),
-    "PySide2.QtWidgets.QTreeView.collapse": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.collapseAll": (),
-    "PySide2.QtWidgets.QTreeView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnMoved": (),
-    "PySide2.QtWidgets.QTreeView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTreeView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QTreeView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTreeView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTreeView.drawBranches": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawRow": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawTree": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QRegion'),
-    "PySide2.QtWidgets.QTreeView.expand": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.expandAll": (),
-    "PySide2.QtWidgets.QTreeView.expandRecursively": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QTreeView.expandToDepth": ('int',),
-    "PySide2.QtWidgets.QTreeView.expandsOnDoubleClick": (),
-    "PySide2.QtWidgets.QTreeView.header": (),
-    "PySide2.QtWidgets.QTreeView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTreeView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTreeView.indentation": (),
-    "PySide2.QtWidgets.QTreeView.indexAbove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTreeView.indexBelow": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexRowSizeHint": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isAnimated": (),
-    "PySide2.QtWidgets.QTreeView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTreeView.isExpanded": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isHeaderHidden": (),
-    "PySide2.QtWidgets.QTreeView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isRowHidden": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTreeView.itemsExpandable": (),
-    "PySide2.QtWidgets.QTreeView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTreeView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QTreeView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTreeView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTreeView.reexpand": (),
-    "PySide2.QtWidgets.QTreeView.reset": (),
-    "PySide2.QtWidgets.QTreeView.resetIndentation": (),
-    "PySide2.QtWidgets.QTreeView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTreeView.rootIsDecorated": (),
-    "PySide2.QtWidgets.QTreeView.rowHeight": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeView.selectAll": (),
-    "PySide2.QtWidgets.QTreeView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTreeView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTreeView.setAllColumnsShowFocus": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAutoExpandDelay": ('int',),
-    "PySide2.QtWidgets.QTreeView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.setExpanded": ('PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setExpandsOnDoubleClick": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTreeView.setHeaderHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setIndentation": ('int',),
-    "PySide2.QtWidgets.QTreeView.setItemsExpandable": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.setRootIsDecorated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setRowHidden": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTreeView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setTreePosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.setUniformRowHeights": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTreeView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTreeView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTreeView.treePosition": (),
-    "PySide2.QtWidgets.QTreeView.uniformRowHeights": (),
-    "PySide2.QtWidgets.QTreeView.updateGeometries": (),
-    "PySide2.QtWidgets.QTreeView.verticalOffset": (),
-    "PySide2.QtWidgets.QTreeView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QTreeView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTreeView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTreeView.wordWrap": (),
-# class PySide2.QtWidgets.QTreeWidget:
-    "PySide2.QtWidgets.QTreeWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItems": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.clear": (),
-    "PySide2.QtWidgets.QTreeWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.collapseItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.currentItem": (),
-    "PySide2.QtWidgets.QTreeWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTreeWidget.dropMimeData": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTreeWidget.editItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeWidget.expandItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.headerItem": (),
-    "PySide2.QtWidgets.QTreeWidget.indexFromItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.indexOfTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItem": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItems": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidget.invisibleRootItem": (),
-    "PySide2.QtWidgets.QTreeWidget.isFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemAbove": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemBelow": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeWidget.itemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTreeWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTreeWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.removeItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.scrollToItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTreeWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.setCurrentItem": [('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTreeWidget.setFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabel": ('str',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTreeWidget.setItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTreeWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeWidget.sortColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTreeWidget.takeTopLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItemCount": (),
-    "PySide2.QtWidgets.QTreeWidget.visualItemRect": ('PySide2.QtWidgets.QTreeWidgetItem',),
-# class PySide2.QtWidgets.QTreeWidgetItem:
-# class PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy:
-# class PySide2.QtWidgets.QTreeWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTreeWidgetItem.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'typing.Sequence[str]', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'typing.Sequence[str]', 'int'), ('int',), ('typing.Sequence[str]', 'int')],
-    "PySide2.QtWidgets.QTreeWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChildren": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidgetItem.background": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.backgroundColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.checkState": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.child": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.childCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.childIndicatorPolicy": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.data": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.emitDataChanged": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.font": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.foreground": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.icon": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.indexOfChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChild": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChildren": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidgetItem.isDisabled": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isExpanded": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isFirstColumnSpanned": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.parent": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.removeChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackgroundColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setCheckState": ('int', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setChildIndicatorPolicy": ('PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setData": ('int', 'int', 'typing.Any'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setExpanded": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFirstColumnSpanned": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFont": ('int', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setForeground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSizeHint": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setStatusTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setText": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextAlignment": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.sizeHint": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidgetItem.statusTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChild": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChildren": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.text": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textAlignment": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.toolTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.treeWidget": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.type": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.whatsThis": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTreeWidgetItemIterator:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlag:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags:
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItemIterator',)],
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__copy__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iadd__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__isub__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iter__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.value": (),
-# class PySide2.QtWidgets.QUndoCommand:
-    "PySide2.QtWidgets.QUndoCommand.__init__": [('PySide2.QtWidgets.QUndoCommand',), ('str', 'PySide2.QtWidgets.QUndoCommand')],
-    "PySide2.QtWidgets.QUndoCommand.actionText": (),
-    "PySide2.QtWidgets.QUndoCommand.child": ('int',),
-    "PySide2.QtWidgets.QUndoCommand.childCount": (),
-    "PySide2.QtWidgets.QUndoCommand.id": (),
-    "PySide2.QtWidgets.QUndoCommand.isObsolete": (),
-    "PySide2.QtWidgets.QUndoCommand.mergeWith": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoCommand.redo": (),
-    "PySide2.QtWidgets.QUndoCommand.setObsolete": ('bool',),
-    "PySide2.QtWidgets.QUndoCommand.setText": ('str',),
-    "PySide2.QtWidgets.QUndoCommand.text": (),
-    "PySide2.QtWidgets.QUndoCommand.undo": (),
-# class PySide2.QtWidgets.QUndoGroup:
-    "PySide2.QtWidgets.QUndoGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoGroup.activeStack": (),
-    "PySide2.QtWidgets.QUndoGroup.addStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.canRedo": (),
-    "PySide2.QtWidgets.QUndoGroup.canUndo": (),
-    "PySide2.QtWidgets.QUndoGroup.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.isClean": (),
-    "PySide2.QtWidgets.QUndoGroup.redo": (),
-    "PySide2.QtWidgets.QUndoGroup.redoText": (),
-    "PySide2.QtWidgets.QUndoGroup.removeStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.setActiveStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.stacks": (),
-    "PySide2.QtWidgets.QUndoGroup.undo": (),
-    "PySide2.QtWidgets.QUndoGroup.undoText": (),
-# class PySide2.QtWidgets.QUndoStack:
-    "PySide2.QtWidgets.QUndoStack.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoStack.beginMacro": ('str',),
-    "PySide2.QtWidgets.QUndoStack.canRedo": (),
-    "PySide2.QtWidgets.QUndoStack.canUndo": (),
-    "PySide2.QtWidgets.QUndoStack.cleanIndex": (),
-    "PySide2.QtWidgets.QUndoStack.clear": (),
-    "PySide2.QtWidgets.QUndoStack.command": ('int',),
-    "PySide2.QtWidgets.QUndoStack.count": (),
-    "PySide2.QtWidgets.QUndoStack.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.endMacro": (),
-    "PySide2.QtWidgets.QUndoStack.index": (),
-    "PySide2.QtWidgets.QUndoStack.isActive": (),
-    "PySide2.QtWidgets.QUndoStack.isClean": (),
-    "PySide2.QtWidgets.QUndoStack.push": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoStack.redo": (),
-    "PySide2.QtWidgets.QUndoStack.redoText": (),
-    "PySide2.QtWidgets.QUndoStack.resetClean": (),
-    "PySide2.QtWidgets.QUndoStack.setActive": ('bool',),
-    "PySide2.QtWidgets.QUndoStack.setClean": (),
-    "PySide2.QtWidgets.QUndoStack.setIndex": ('int',),
-    "PySide2.QtWidgets.QUndoStack.setUndoLimit": ('int',),
-    "PySide2.QtWidgets.QUndoStack.text": ('int',),
-    "PySide2.QtWidgets.QUndoStack.undo": (),
-    "PySide2.QtWidgets.QUndoStack.undoLimit": (),
-    "PySide2.QtWidgets.QUndoStack.undoText": (),
-# class PySide2.QtWidgets.QUndoView:
-    "PySide2.QtWidgets.QUndoView.__init__": [('PySide2.QtWidgets.QUndoGroup', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QUndoStack', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QUndoView.cleanIcon": (),
-    "PySide2.QtWidgets.QUndoView.emptyLabel": (),
-    "PySide2.QtWidgets.QUndoView.group": (),
-    "PySide2.QtWidgets.QUndoView.setCleanIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QUndoView.setEmptyLabel": ('str',),
-    "PySide2.QtWidgets.QUndoView.setGroup": ('PySide2.QtWidgets.QUndoGroup',),
-    "PySide2.QtWidgets.QUndoView.setStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoView.stack": (),
-# class PySide2.QtWidgets.QVBoxLayout:
-    "PySide2.QtWidgets.QVBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QWhatsThis:
-    "PySide2.QtWidgets.QWhatsThis.createAction": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWhatsThis.enterWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.hideText": (),
-    "PySide2.QtWidgets.QWhatsThis.inWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.leaveWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.showText": ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'),
-# class PySide2.QtWidgets.QWidget:
-# class PySide2.QtWidgets.QWidget.RenderFlag:
-# class PySide2.QtWidgets.QWidget.RenderFlags:
-    "PySide2.QtWidgets.QWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.acceptDrops": (),
-    "PySide2.QtWidgets.QWidget.accessibleDescription": (),
-    "PySide2.QtWidgets.QWidget.accessibleName": (),
-    "PySide2.QtWidgets.QWidget.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QWidget.actions": (),
-    "PySide2.QtWidgets.QWidget.activateWindow": (),
-    "PySide2.QtWidgets.QWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QWidget.adjustSize": (),
-    "PySide2.QtWidgets.QWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QWidget.backgroundRole": (),
-    "PySide2.QtWidgets.QWidget.backingStore": (),
-    "PySide2.QtWidgets.QWidget.baseSize": (),
-    "PySide2.QtWidgets.QWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.childAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.childrenRect": (),
-    "PySide2.QtWidgets.QWidget.childrenRegion": (),
-    "PySide2.QtWidgets.QWidget.clearFocus": (),
-    "PySide2.QtWidgets.QWidget.clearMask": (),
-    "PySide2.QtWidgets.QWidget.close": (),
-    "PySide2.QtWidgets.QWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QWidget.contentsMargins": (),
-    "PySide2.QtWidgets.QWidget.contentsRect": (),
-    "PySide2.QtWidgets.QWidget.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QWidget.contextMenuPolicy": (),
-    "PySide2.QtWidgets.QWidget.create": ('int', 'bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.createWinId": (),
-    "PySide2.QtWidgets.QWidget.createWindowContainer": ('PySide2.QtGui.QWindow', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.cursor": (),
-    "PySide2.QtWidgets.QWidget.destroy": ('bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.devType": (),
-    "PySide2.QtWidgets.QWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QWidget.effectiveWinId": (),
-    "PySide2.QtWidgets.QWidget.ensurePolished": (),
-    "PySide2.QtWidgets.QWidget.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.find": ('int',),
-    "PySide2.QtWidgets.QWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusNextChild": (),
-    "PySide2.QtWidgets.QWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QWidget.focusPreviousChild": (),
-    "PySide2.QtWidgets.QWidget.focusProxy": (),
-    "PySide2.QtWidgets.QWidget.focusWidget": (),
-    "PySide2.QtWidgets.QWidget.font": (),
-    "PySide2.QtWidgets.QWidget.fontInfo": (),
-    "PySide2.QtWidgets.QWidget.fontMetrics": (),
-    "PySide2.QtWidgets.QWidget.foregroundRole": (),
-    "PySide2.QtWidgets.QWidget.frameGeometry": (),
-    "PySide2.QtWidgets.QWidget.frameSize": (),
-    "PySide2.QtWidgets.QWidget.geometry": (),
-    "PySide2.QtWidgets.QWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QWidget.grab": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidget.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QWidget.grabKeyboard": (),
-    "PySide2.QtWidgets.QWidget.grabMouse": [(), ('PySide2.QtGui.QCursor',)],
-    "PySide2.QtWidgets.QWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QWidget.graphicsEffect": (),
-    "PySide2.QtWidgets.QWidget.graphicsProxyWidget": (),
-    "PySide2.QtWidgets.QWidget.hasFocus": (),
-    "PySide2.QtWidgets.QWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidget.hasMouseTracking": (),
-    "PySide2.QtWidgets.QWidget.hasTabletTracking": (),
-    "PySide2.QtWidgets.QWidget.height": (),
-    "PySide2.QtWidgets.QWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.hide": (),
-    "PySide2.QtWidgets.QWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QWidget.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QWidget.inputMethodHints": (),
-    "PySide2.QtWidgets.QWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QWidget.internalWinId": (),
-    "PySide2.QtWidgets.QWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QWidget.isAncestorOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabled": (),
-    "PySide2.QtWidgets.QWidget.isEnabledTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabledToTLW": (),
-    "PySide2.QtWidgets.QWidget.isFullScreen": (),
-    "PySide2.QtWidgets.QWidget.isHidden": (),
-    "PySide2.QtWidgets.QWidget.isLeftToRight": (),
-    "PySide2.QtWidgets.QWidget.isMaximized": (),
-    "PySide2.QtWidgets.QWidget.isMinimized": (),
-    "PySide2.QtWidgets.QWidget.isModal": (),
-    "PySide2.QtWidgets.QWidget.isRightToLeft": (),
-    "PySide2.QtWidgets.QWidget.isTopLevel": (),
-    "PySide2.QtWidgets.QWidget.isVisible": (),
-    "PySide2.QtWidgets.QWidget.isVisibleTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isWindow": (),
-    "PySide2.QtWidgets.QWidget.isWindowModified": (),
-    "PySide2.QtWidgets.QWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyboardGrabber": (),
-    "PySide2.QtWidgets.QWidget.layout": (),
-    "PySide2.QtWidgets.QWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QWidget.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.locale": (),
-    "PySide2.QtWidgets.QWidget.lower": (),
-    "PySide2.QtWidgets.QWidget.mapFrom": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapFromParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapTo": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapToParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mask": (),
-    "PySide2.QtWidgets.QWidget.maximumHeight": (),
-    "PySide2.QtWidgets.QWidget.maximumSize": (),
-    "PySide2.QtWidgets.QWidget.maximumWidth": (),
-    "PySide2.QtWidgets.QWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QWidget.minimumHeight": (),
-    "PySide2.QtWidgets.QWidget.minimumSize": (),
-    "PySide2.QtWidgets.QWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QWidget.minimumWidth": (),
-    "PySide2.QtWidgets.QWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseGrabber": (),
-    "PySide2.QtWidgets.QWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QWidget.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QWidget.nativeParentWidget": (),
-    "PySide2.QtWidgets.QWidget.nextInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.normalGeometry": (),
-    "PySide2.QtWidgets.QWidget.overrideWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.overrideWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.paintEngine": (),
-    "PySide2.QtWidgets.QWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWidget.palette": (),
-    "PySide2.QtWidgets.QWidget.parentWidget": (),
-    "PySide2.QtWidgets.QWidget.pos": (),
-    "PySide2.QtWidgets.QWidget.previousInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.raise_": (),
-    "PySide2.QtWidgets.QWidget.rect": (),
-    "PySide2.QtWidgets.QWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.releaseKeyboard": (),
-    "PySide2.QtWidgets.QWidget.releaseMouse": (),
-    "PySide2.QtWidgets.QWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags')],
-    "PySide2.QtWidgets.QWidget.repaint": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWidget.restoreGeometry": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QWidget.saveGeometry": (),
-    "PySide2.QtWidgets.QWidget.screen": (),
-    "PySide2.QtWidgets.QWidget.scroll": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QRect')],
-    "PySide2.QtWidgets.QWidget.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QWidget.setAccessibleDescription": ('str',),
-    "PySide2.QtWidgets.QWidget.setAccessibleName": ('str',),
-    "PySide2.QtWidgets.QWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QWidget.setBackgroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setBaseSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContextMenuPolicy": ('PySide2.QtCore.Qt.ContextMenuPolicy',),
-    "PySide2.QtWidgets.QWidget.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QWidget.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setFixedHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setFixedSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setFixedWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtWidgets.QWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QWidget.setFocusProxy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QWidget.setForegroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QWidget.setHidden": ('bool',),
-    "PySide2.QtWidgets.QWidget.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QWidget.setLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QWidget.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtWidgets.QWidget.setMask": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtWidgets.QWidget.setMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMaximumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMouseTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QWidget.setParent": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setSizeIncrement": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy')],
-    "PySide2.QtWidgets.QWidget.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QWidget.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QWidget.setTabOrder": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QWidget.setTabletTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setToolTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setToolTipDuration": ('int',),
-    "PySide2.QtWidgets.QWidget.setUpdatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFilePath": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtWidgets.QWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QWidget.setWindowIconText": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QWidget.setWindowModified": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWindowOpacity": ('float',),
-    "PySide2.QtWidgets.QWidget.setWindowRole": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QWidget.sharedPainter": (),
-    "PySide2.QtWidgets.QWidget.show": (),
-    "PySide2.QtWidgets.QWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QWidget.showFullScreen": (),
-    "PySide2.QtWidgets.QWidget.showMaximized": (),
-    "PySide2.QtWidgets.QWidget.showMinimized": (),
-    "PySide2.QtWidgets.QWidget.showNormal": (),
-    "PySide2.QtWidgets.QWidget.size": (),
-    "PySide2.QtWidgets.QWidget.sizeHint": (),
-    "PySide2.QtWidgets.QWidget.sizeIncrement": (),
-    "PySide2.QtWidgets.QWidget.sizePolicy": (),
-    "PySide2.QtWidgets.QWidget.stackUnder": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.statusTip": (),
-    "PySide2.QtWidgets.QWidget.style": (),
-    "PySide2.QtWidgets.QWidget.styleSheet": (),
-    "PySide2.QtWidgets.QWidget.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtWidgets.QWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QWidget.toolTip": (),
-    "PySide2.QtWidgets.QWidget.toolTipDuration": (),
-    "PySide2.QtWidgets.QWidget.topLevelWidget": (),
-    "PySide2.QtWidgets.QWidget.underMouse": (),
-    "PySide2.QtWidgets.QWidget.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QWidget.unsetCursor": (),
-    "PySide2.QtWidgets.QWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QWidget.unsetLocale": (),
-    "PySide2.QtWidgets.QWidget.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QWidget.updateMicroFocus": (),
-    "PySide2.QtWidgets.QWidget.updatesEnabled": (),
-    "PySide2.QtWidgets.QWidget.visibleRegion": (),
-    "PySide2.QtWidgets.QWidget.whatsThis": (),
-    "PySide2.QtWidgets.QWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QWidget.width": (),
-    "PySide2.QtWidgets.QWidget.winId": (),
-    "PySide2.QtWidgets.QWidget.window": (),
-    "PySide2.QtWidgets.QWidget.windowFilePath": (),
-    "PySide2.QtWidgets.QWidget.windowFlags": (),
-    "PySide2.QtWidgets.QWidget.windowHandle": (),
-    "PySide2.QtWidgets.QWidget.windowIcon": (),
-    "PySide2.QtWidgets.QWidget.windowIconText": (),
-    "PySide2.QtWidgets.QWidget.windowModality": (),
-    "PySide2.QtWidgets.QWidget.windowOpacity": (),
-    "PySide2.QtWidgets.QWidget.windowRole": (),
-    "PySide2.QtWidgets.QWidget.windowState": (),
-    "PySide2.QtWidgets.QWidget.windowTitle": (),
-    "PySide2.QtWidgets.QWidget.windowType": (),
-    "PySide2.QtWidgets.QWidget.x": (),
-    "PySide2.QtWidgets.QWidget.y": (),
-# class PySide2.QtWidgets.QWidgetAction:
-    "PySide2.QtWidgets.QWidgetAction.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWidgetAction.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.createdWidgets": (),
-    "PySide2.QtWidgets.QWidgetAction.defaultWidget": (),
-    "PySide2.QtWidgets.QWidgetAction.deleteWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidgetAction.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QWidgetAction.releaseWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.requestWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.setDefaultWidget": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QWidgetItem:
-    "PySide2.QtWidgets.QWidgetItem.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetItem.controlTypes": (),
-    "PySide2.QtWidgets.QWidgetItem.expandingDirections": (),
-    "PySide2.QtWidgets.QWidgetItem.geometry": (),
-    "PySide2.QtWidgets.QWidgetItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidgetItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidgetItem.isEmpty": (),
-    "PySide2.QtWidgets.QWidgetItem.maximumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.minimumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QWidgetItem.widget": (),
-# class PySide2.QtWidgets.QWizard:
-# class PySide2.QtWidgets.QWizard.WizardButton:
-# class PySide2.QtWidgets.QWizard.WizardOption:
-# class PySide2.QtWidgets.QWizard.WizardOptions:
-# class PySide2.QtWidgets.QWizard.WizardPixmap:
-# class PySide2.QtWidgets.QWizard.WizardStyle:
-    "PySide2.QtWidgets.QWizard.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWizard.addPage": ('PySide2.QtWidgets.QWizardPage',),
-    "PySide2.QtWidgets.QWizard.back": (),
-    "PySide2.QtWidgets.QWizard.button": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.cleanupPage": ('int',),
-    "PySide2.QtWidgets.QWizard.currentId": (),
-    "PySide2.QtWidgets.QWizard.currentPage": (),
-    "PySide2.QtWidgets.QWizard.done": ('int',),
-    "PySide2.QtWidgets.QWizard.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWizard.field": ('str',),
-    "PySide2.QtWidgets.QWizard.hasVisitedPage": ('int',),
-    "PySide2.QtWidgets.QWizard.initializePage": ('int',),
-    "PySide2.QtWidgets.QWizard.nextId": (),
-    "PySide2.QtWidgets.QWizard.options": (),
-    "PySide2.QtWidgets.QWizard.page": ('int',),
-    "PySide2.QtWidgets.QWizard.pageIds": (),
-    "PySide2.QtWidgets.QWizard.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWizard.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizard.removePage": ('int',),
-    "PySide2.QtWidgets.QWizard.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWizard.restart": (),
-    "PySide2.QtWidgets.QWizard.setButton": ('PySide2.QtWidgets.QWizard.WizardButton', 'PySide2.QtWidgets.QAbstractButton'),
-    "PySide2.QtWidgets.QWizard.setButtonLayout": ('typing.Sequence[PySide2.QtWidgets.QWizard.WizardButton]',),
-    "PySide2.QtWidgets.QWizard.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizard.setDefaultProperty": ('str', 'str', 'str'),
-    "PySide2.QtWidgets.QWizard.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizard.setOption": ('PySide2.QtWidgets.QWizard.WizardOption', 'bool'),
-    "PySide2.QtWidgets.QWizard.setOptions": ('PySide2.QtWidgets.QWizard.WizardOptions',),
-    "PySide2.QtWidgets.QWizard.setPage": ('int', 'PySide2.QtWidgets.QWizardPage'),
-    "PySide2.QtWidgets.QWizard.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizard.setSideWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizard.setStartId": ('int',),
-    "PySide2.QtWidgets.QWizard.setSubTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWizard.setWizardStyle": ('PySide2.QtWidgets.QWizard.WizardStyle',),
-    "PySide2.QtWidgets.QWizard.sideWidget": (),
-    "PySide2.QtWidgets.QWizard.sizeHint": (),
-    "PySide2.QtWidgets.QWizard.startId": (),
-    "PySide2.QtWidgets.QWizard.subTitleFormat": (),
-    "PySide2.QtWidgets.QWizard.testOption": ('PySide2.QtWidgets.QWizard.WizardOption',),
-    "PySide2.QtWidgets.QWizard.titleFormat": (),
-    "PySide2.QtWidgets.QWizard.validateCurrentPage": (),
-    "PySide2.QtWidgets.QWizard.visitedPages": (),
-    "PySide2.QtWidgets.QWizard.wizardStyle": (),
-# class PySide2.QtWidgets.QWizardPage:
-    "PySide2.QtWidgets.QWizardPage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizardPage.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizardPage.cleanupPage": (),
-    "PySide2.QtWidgets.QWizardPage.field": ('str',),
-    "PySide2.QtWidgets.QWizardPage.initializePage": (),
-    "PySide2.QtWidgets.QWizardPage.isCommitPage": (),
-    "PySide2.QtWidgets.QWizardPage.isComplete": (),
-    "PySide2.QtWidgets.QWizardPage.isFinalPage": (),
-    "PySide2.QtWidgets.QWizardPage.nextId": (),
-    "PySide2.QtWidgets.QWizardPage.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizardPage.registerField": ('str', 'PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setCommitPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizardPage.setFinalPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizardPage.setSubTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.setTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.subTitle": (),
-    "PySide2.QtWidgets.QWizardPage.title": (),
-    "PySide2.QtWidgets.QWizardPage.validatePage": (),
-    "PySide2.QtWidgets.QWizardPage.wizard": (),
-    }) if "PySide2.QtWidgets" in sys.modules else None
-# Module PySide2.QtPrintSupport
-sig_dict.update({
-# class PySide2.QtPrintSupport.QAbstractPrintDialog:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange:
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.__init__": ('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.addEnabledOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.enabledOptions": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.fromPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.isOptionEnabled": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.maxPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.minPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printRange": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printer": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setEnabledOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setMinMax": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setOptionTabs": ('typing.Sequence[PySide2.QtWidgets.QWidget]',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setPrintRange": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.toPage": (),
-# class PySide2.QtPrintSupport.QPageSetupDialog:
-    "PySide2.QtPrintSupport.QPageSetupDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPageSetupDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPageSetupDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPageSetupDialog.printer": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintDialog:
-    "PySide2.QtPrintSupport.QPrintDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPrintDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPrintDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintDialog.options": (),
-    "PySide2.QtPrintSupport.QPrintDialog.setOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption', 'bool'),
-    "PySide2.QtPrintSupport.QPrintDialog.setOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QPrintDialog.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintDialog.testOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-# class PySide2.QtPrintSupport.QPrintEngine:
-# class PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey:
-    "PySide2.QtPrintSupport.QPrintEngine.__init__": (),
-    "PySide2.QtPrintSupport.QPrintEngine.abort": (),
-    "PySide2.QtPrintSupport.QPrintEngine.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrintEngine.newPage": (),
-    "PySide2.QtPrintSupport.QPrintEngine.printerState": (),
-    "PySide2.QtPrintSupport.QPrintEngine.property": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey',),
-    "PySide2.QtPrintSupport.QPrintEngine.setProperty": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey', 'typing.Any'),
-# class PySide2.QtPrintSupport.QPrintPreviewDialog:
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.printer": (),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintPreviewWidget:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode:
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.currentPage": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitInView": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitToWidth": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.orientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.pageCount": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.print_": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setAllPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setCurrentPage": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setFacingPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setLandscapeOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setPortraitOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setSinglePageViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setViewMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomFactor": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.updatePreview": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.viewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomFactor": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomIn": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomOut": ('float',),
-# class PySide2.QtPrintSupport.QPrinter:
-# class PySide2.QtPrintSupport.QPrinter.ColorMode:
-# class PySide2.QtPrintSupport.QPrinter.DuplexMode:
-# class PySide2.QtPrintSupport.QPrinter.Orientation:
-# class PySide2.QtPrintSupport.QPrinter.OutputFormat:
-# class PySide2.QtPrintSupport.QPrinter.PageOrder:
-# class PySide2.QtPrintSupport.QPrinter.PaperSource:
-# class PySide2.QtPrintSupport.QPrinter.PrintRange:
-# class PySide2.QtPrintSupport.QPrinter.PrinterMode:
-# class PySide2.QtPrintSupport.QPrinter.PrinterState:
-# class PySide2.QtPrintSupport.QPrinter.Unit:
-    "PySide2.QtPrintSupport.QPrinter.__init__": [('PySide2.QtPrintSupport.QPrinter.PrinterMode',), ('PySide2.QtPrintSupport.QPrinterInfo', 'PySide2.QtPrintSupport.QPrinter.PrinterMode')],
-    "PySide2.QtPrintSupport.QPrinter.abort": (),
-    "PySide2.QtPrintSupport.QPrinter.actualNumCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.collateCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.colorMode": (),
-    "PySide2.QtPrintSupport.QPrinter.copyCount": (),
-    "PySide2.QtPrintSupport.QPrinter.creator": (),
-    "PySide2.QtPrintSupport.QPrinter.devType": (),
-    "PySide2.QtPrintSupport.QPrinter.docName": (),
-    "PySide2.QtPrintSupport.QPrinter.doubleSidedPrinting": (),
-    "PySide2.QtPrintSupport.QPrinter.duplex": (),
-    "PySide2.QtPrintSupport.QPrinter.fontEmbeddingEnabled": (),
-    "PySide2.QtPrintSupport.QPrinter.fromPage": (),
-    "PySide2.QtPrintSupport.QPrinter.fullPage": (),
-    "PySide2.QtPrintSupport.QPrinter.getPageMargins": ('PySide2.QtPrintSupport.QPrinter.Unit',),
-    "PySide2.QtPrintSupport.QPrinter.isValid": (),
-    "PySide2.QtPrintSupport.QPrinter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrinter.newPage": (),
-    "PySide2.QtPrintSupport.QPrinter.numCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.orientation": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFileName": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFormat": (),
-    "PySide2.QtPrintSupport.QPrinter.pageOrder": (),
-    "PySide2.QtPrintSupport.QPrinter.pageRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.pageSize": (),
-    "PySide2.QtPrintSupport.QPrinter.paintEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.paperName": (),
-    "PySide2.QtPrintSupport.QPrinter.paperRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSize": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSource": (),
-    "PySide2.QtPrintSupport.QPrinter.pdfVersion": (),
-    "PySide2.QtPrintSupport.QPrinter.printEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.printProgram": (),
-    "PySide2.QtPrintSupport.QPrinter.printRange": (),
-    "PySide2.QtPrintSupport.QPrinter.printerName": (),
-    "PySide2.QtPrintSupport.QPrinter.printerState": (),
-    "PySide2.QtPrintSupport.QPrinter.resolution": (),
-    "PySide2.QtPrintSupport.QPrinter.setCollateCopies": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setColorMode": ('PySide2.QtPrintSupport.QPrinter.ColorMode',),
-    "PySide2.QtPrintSupport.QPrinter.setCopyCount": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setCreator": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDocName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDoubleSidedPrinting": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setDuplex": ('PySide2.QtPrintSupport.QPrinter.DuplexMode',),
-    "PySide2.QtPrintSupport.QPrinter.setEngines": ('PySide2.QtPrintSupport.QPrintEngine', 'PySide2.QtGui.QPaintEngine'),
-    "PySide2.QtPrintSupport.QPrinter.setFontEmbeddingEnabled": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QPrinter.setFullPage": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtPrintSupport.QPrinter.setNumCopies": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFileName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFormat": ('PySide2.QtPrintSupport.QPrinter.OutputFormat',),
-    "PySide2.QtPrintSupport.QPrinter.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float', 'PySide2.QtPrintSupport.QPrinter.Unit')],
-    "PySide2.QtPrintSupport.QPrinter.setPageOrder": ('PySide2.QtPrintSupport.QPrinter.PageOrder',),
-    "PySide2.QtPrintSupport.QPrinter.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperSize": [('PySide2.QtCore.QSizeF', 'PySide2.QtPrintSupport.QPrinter.Unit'), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPaperSource": ('PySide2.QtPrintSupport.QPrinter.PaperSource',),
-    "PySide2.QtPrintSupport.QPrinter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintProgram": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintRange": ('PySide2.QtPrintSupport.QPrinter.PrintRange',),
-    "PySide2.QtPrintSupport.QPrinter.setPrinterName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setResolution": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setWinPageSize": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinter.supportsMultipleCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.toPage": (),
-    "PySide2.QtPrintSupport.QPrinter.winPageSize": (),
-# class PySide2.QtPrintSupport.QPrinterInfo:
-    "PySide2.QtPrintSupport.QPrinterInfo.__init__": [(), ('PySide2.QtPrintSupport.QPrinter',), ('PySide2.QtPrintSupport.QPrinterInfo',)],
-    "PySide2.QtPrintSupport.QPrinterInfo.__copy__": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinterNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinters": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultColorMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultDuplexMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinter": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinterName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.description": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isDefault": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isNull": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isRemote": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.location": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.makeAndModel": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.maximumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.minimumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerInfo": ('str',),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.state": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedColorModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedDuplexModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPageSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPaperSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedSizesWithNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportsCustomPageSizes": (),
-    }) if "PySide2.QtPrintSupport" in sys.modules else None
-# Module PySide2.QtSql
-sig_dict.update({
-# class PySide2.QtSql.QSql:
-# class PySide2.QtSql.QSql.Location:
-# class PySide2.QtSql.QSql.NumericalPrecisionPolicy:
-# class PySide2.QtSql.QSql.ParamType:
-# class PySide2.QtSql.QSql.ParamTypeFlag:
-# class PySide2.QtSql.QSql.TableType:
-# class PySide2.QtSql.QSqlDatabase:
-    "PySide2.QtSql.QSqlDatabase.__init__": [(), ('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlDriver',), ('str',)],
-    "PySide2.QtSql.QSqlDatabase.__copy__": (),
-    "PySide2.QtSql.QSqlDatabase.addDatabase": [('PySide2.QtSql.QSqlDriver', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.cloneDatabase": [('PySide2.QtSql.QSqlDatabase', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.close": (),
-    "PySide2.QtSql.QSqlDatabase.commit": (),
-    "PySide2.QtSql.QSqlDatabase.connectOptions": (),
-    "PySide2.QtSql.QSqlDatabase.connectionName": (),
-    "PySide2.QtSql.QSqlDatabase.connectionNames": (),
-    "PySide2.QtSql.QSqlDatabase.contains": ('str',),
-    "PySide2.QtSql.QSqlDatabase.database": ('str', 'bool'),
-    "PySide2.QtSql.QSqlDatabase.databaseName": (),
-    "PySide2.QtSql.QSqlDatabase.driver": (),
-    "PySide2.QtSql.QSqlDatabase.driverName": (),
-    "PySide2.QtSql.QSqlDatabase.drivers": (),
-    "PySide2.QtSql.QSqlDatabase.exec_": ('str',),
-    "PySide2.QtSql.QSqlDatabase.hostName": (),
-    "PySide2.QtSql.QSqlDatabase.isDriverAvailable": ('str',),
-    "PySide2.QtSql.QSqlDatabase.isOpen": (),
-    "PySide2.QtSql.QSqlDatabase.isOpenError": (),
-    "PySide2.QtSql.QSqlDatabase.isValid": (),
-    "PySide2.QtSql.QSqlDatabase.lastError": (),
-    "PySide2.QtSql.QSqlDatabase.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDatabase.open": [(), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.password": (),
-    "PySide2.QtSql.QSqlDatabase.port": (),
-    "PySide2.QtSql.QSqlDatabase.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDatabase.record": ('str',),
-    "PySide2.QtSql.QSqlDatabase.registerSqlDriver": ('str', 'PySide2.QtSql.QSqlDriverCreatorBase'),
-    "PySide2.QtSql.QSqlDatabase.removeDatabase": ('str',),
-    "PySide2.QtSql.QSqlDatabase.rollback": (),
-    "PySide2.QtSql.QSqlDatabase.setConnectOptions": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setDatabaseName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setHostName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDatabase.setPassword": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setPort": ('int',),
-    "PySide2.QtSql.QSqlDatabase.setUserName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDatabase.transaction": (),
-    "PySide2.QtSql.QSqlDatabase.userName": (),
-# class PySide2.QtSql.QSqlDriver:
-# class PySide2.QtSql.QSqlDriver.DbmsType:
-# class PySide2.QtSql.QSqlDriver.DriverFeature:
-# class PySide2.QtSql.QSqlDriver.IdentifierType:
-# class PySide2.QtSql.QSqlDriver.NotificationSource:
-# class PySide2.QtSql.QSqlDriver.StatementType:
-    "PySide2.QtSql.QSqlDriver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlDriver.beginTransaction": (),
-    "PySide2.QtSql.QSqlDriver.cancelQuery": (),
-    "PySide2.QtSql.QSqlDriver.close": (),
-    "PySide2.QtSql.QSqlDriver.commitTransaction": (),
-    "PySide2.QtSql.QSqlDriver.createResult": (),
-    "PySide2.QtSql.QSqlDriver.dbmsType": (),
-    "PySide2.QtSql.QSqlDriver.escapeIdentifier": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.formatValue": ('PySide2.QtSql.QSqlField', 'bool'),
-    "PySide2.QtSql.QSqlDriver.hasFeature": ('PySide2.QtSql.QSqlDriver.DriverFeature',),
-    "PySide2.QtSql.QSqlDriver.isIdentifierEscaped": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.isOpen": (),
-    "PySide2.QtSql.QSqlDriver.isOpenError": (),
-    "PySide2.QtSql.QSqlDriver.lastError": (),
-    "PySide2.QtSql.QSqlDriver.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDriver.open": ('str', 'str', 'str', 'str', 'int', 'str'),
-    "PySide2.QtSql.QSqlDriver.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDriver.record": ('str',),
-    "PySide2.QtSql.QSqlDriver.rollbackTransaction": (),
-    "PySide2.QtSql.QSqlDriver.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlDriver.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDriver.setOpen": ('bool',),
-    "PySide2.QtSql.QSqlDriver.setOpenError": ('bool',),
-    "PySide2.QtSql.QSqlDriver.sqlStatement": ('PySide2.QtSql.QSqlDriver.StatementType', 'str', 'PySide2.QtSql.QSqlRecord', 'bool'),
-    "PySide2.QtSql.QSqlDriver.stripDelimiters": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.subscribeToNotification": ('str',),
-    "PySide2.QtSql.QSqlDriver.subscribedToNotifications": (),
-    "PySide2.QtSql.QSqlDriver.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDriver.unsubscribeFromNotification": ('str',),
-# class PySide2.QtSql.QSqlDriverCreatorBase:
-    "PySide2.QtSql.QSqlDriverCreatorBase.__init__": (),
-    "PySide2.QtSql.QSqlDriverCreatorBase.createObject": (),
-# class PySide2.QtSql.QSqlError:
-# class PySide2.QtSql.QSqlError.ErrorType:
-    "PySide2.QtSql.QSqlError.__init__": [('PySide2.QtSql.QSqlError',), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'int'), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'str')],
-    "PySide2.QtSql.QSqlError.__copy__": (),
-    "PySide2.QtSql.QSqlError.databaseText": (),
-    "PySide2.QtSql.QSqlError.driverText": (),
-    "PySide2.QtSql.QSqlError.isValid": (),
-    "PySide2.QtSql.QSqlError.nativeErrorCode": (),
-    "PySide2.QtSql.QSqlError.number": (),
-    "PySide2.QtSql.QSqlError.setDatabaseText": ('str',),
-    "PySide2.QtSql.QSqlError.setDriverText": ('str',),
-    "PySide2.QtSql.QSqlError.setNumber": ('int',),
-    "PySide2.QtSql.QSqlError.setType": ('PySide2.QtSql.QSqlError.ErrorType',),
-    "PySide2.QtSql.QSqlError.swap": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlError.text": (),
-    "PySide2.QtSql.QSqlError.type": (),
-# class PySide2.QtSql.QSqlField:
-# class PySide2.QtSql.QSqlField.RequiredStatus:
-    "PySide2.QtSql.QSqlField.__init__": [('PySide2.QtSql.QSqlField',), ('str', 'type'), ('str', 'type', 'str')],
-    "PySide2.QtSql.QSqlField.__copy__": (),
-    "PySide2.QtSql.QSqlField.clear": (),
-    "PySide2.QtSql.QSqlField.defaultValue": (),
-    "PySide2.QtSql.QSqlField.isAutoValue": (),
-    "PySide2.QtSql.QSqlField.isGenerated": (),
-    "PySide2.QtSql.QSqlField.isNull": (),
-    "PySide2.QtSql.QSqlField.isReadOnly": (),
-    "PySide2.QtSql.QSqlField.isValid": (),
-    "PySide2.QtSql.QSqlField.length": (),
-    "PySide2.QtSql.QSqlField.name": (),
-    "PySide2.QtSql.QSqlField.precision": (),
-    "PySide2.QtSql.QSqlField.requiredStatus": (),
-    "PySide2.QtSql.QSqlField.setAutoValue": ('bool',),
-    "PySide2.QtSql.QSqlField.setDefaultValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.setGenerated": ('bool',),
-    "PySide2.QtSql.QSqlField.setLength": ('int',),
-    "PySide2.QtSql.QSqlField.setName": ('str',),
-    "PySide2.QtSql.QSqlField.setPrecision": ('int',),
-    "PySide2.QtSql.QSqlField.setReadOnly": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequired": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequiredStatus": ('PySide2.QtSql.QSqlField.RequiredStatus',),
-    "PySide2.QtSql.QSqlField.setSqlType": ('int',),
-    "PySide2.QtSql.QSqlField.setTableName": ('str',),
-    "PySide2.QtSql.QSqlField.setType": ('type',),
-    "PySide2.QtSql.QSqlField.setValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.tableName": (),
-    "PySide2.QtSql.QSqlField.type": (),
-    "PySide2.QtSql.QSqlField.typeID": (),
-    "PySide2.QtSql.QSqlField.value": (),
-# class PySide2.QtSql.QSqlIndex:
-    "PySide2.QtSql.QSqlIndex.__init__": [('PySide2.QtSql.QSqlIndex',), ('str', 'str')],
-    "PySide2.QtSql.QSqlIndex.__copy__": (),
-    "PySide2.QtSql.QSqlIndex.append": [('PySide2.QtSql.QSqlField',), ('PySide2.QtSql.QSqlField', 'bool')],
-    "PySide2.QtSql.QSqlIndex.cursorName": (),
-    "PySide2.QtSql.QSqlIndex.isDescending": ('int',),
-    "PySide2.QtSql.QSqlIndex.name": (),
-    "PySide2.QtSql.QSqlIndex.setCursorName": ('str',),
-    "PySide2.QtSql.QSqlIndex.setDescending": ('int', 'bool'),
-    "PySide2.QtSql.QSqlIndex.setName": ('str',),
-# class PySide2.QtSql.QSqlQuery:
-# class PySide2.QtSql.QSqlQuery.BatchExecutionMode:
-    "PySide2.QtSql.QSqlQuery.__init__": [('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlQuery',), ('PySide2.QtSql.QSqlResult',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-    "PySide2.QtSql.QSqlQuery.__copy__": (),
-    "PySide2.QtSql.QSqlQuery.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlQuery.at": (),
-    "PySide2.QtSql.QSqlQuery.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlQuery.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.boundValues": (),
-    "PySide2.QtSql.QSqlQuery.clear": (),
-    "PySide2.QtSql.QSqlQuery.driver": (),
-    "PySide2.QtSql.QSqlQuery.execBatch": ('PySide2.QtSql.QSqlQuery.BatchExecutionMode',),
-    "PySide2.QtSql.QSqlQuery.exec_": [(), ('str',)],
-    "PySide2.QtSql.QSqlQuery.executedQuery": (),
-    "PySide2.QtSql.QSqlQuery.finish": (),
-    "PySide2.QtSql.QSqlQuery.first": (),
-    "PySide2.QtSql.QSqlQuery.isActive": (),
-    "PySide2.QtSql.QSqlQuery.isForwardOnly": (),
-    "PySide2.QtSql.QSqlQuery.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.isSelect": (),
-    "PySide2.QtSql.QSqlQuery.isValid": (),
-    "PySide2.QtSql.QSqlQuery.last": (),
-    "PySide2.QtSql.QSqlQuery.lastError": (),
-    "PySide2.QtSql.QSqlQuery.lastInsertId": (),
-    "PySide2.QtSql.QSqlQuery.lastQuery": (),
-    "PySide2.QtSql.QSqlQuery.nextResult": (),
-    "PySide2.QtSql.QSqlQuery.numRowsAffected": (),
-    "PySide2.QtSql.QSqlQuery.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlQuery.prepare": ('str',),
-    "PySide2.QtSql.QSqlQuery.previous": (),
-    "PySide2.QtSql.QSqlQuery.record": (),
-    "PySide2.QtSql.QSqlQuery.result": (),
-    "PySide2.QtSql.QSqlQuery.seek": ('int', 'bool'),
-    "PySide2.QtSql.QSqlQuery.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlQuery.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlQuery.size": (),
-    "PySide2.QtSql.QSqlQuery.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlQueryModel:
-    "PySide2.QtSql.QSqlQueryModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.clear": (),
-    "PySide2.QtSql.QSqlQueryModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.endInsertColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endInsertRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.lastError": (),
-    "PySide2.QtSql.QSqlQueryModel.query": (),
-    "PySide2.QtSql.QSqlQueryModel.queryChange": (),
-    "PySide2.QtSql.QSqlQueryModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlQueryModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.roleNames": (),
-    "PySide2.QtSql.QSqlQueryModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlQueryModel.setQuery": [('PySide2.QtSql.QSqlQuery',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-# class PySide2.QtSql.QSqlRecord:
-    "PySide2.QtSql.QSqlRecord.__init__": [(), ('PySide2.QtSql.QSqlRecord',)],
-    "PySide2.QtSql.QSqlRecord.__copy__": (),
-    "PySide2.QtSql.QSqlRecord.append": ('PySide2.QtSql.QSqlField',),
-    "PySide2.QtSql.QSqlRecord.clear": (),
-    "PySide2.QtSql.QSqlRecord.clearValues": (),
-    "PySide2.QtSql.QSqlRecord.contains": ('str',),
-    "PySide2.QtSql.QSqlRecord.count": (),
-    "PySide2.QtSql.QSqlRecord.field": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.fieldName": ('int',),
-    "PySide2.QtSql.QSqlRecord.indexOf": ('str',),
-    "PySide2.QtSql.QSqlRecord.insert": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.isEmpty": (),
-    "PySide2.QtSql.QSqlRecord.isGenerated": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.keyValues": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRecord.remove": ('int',),
-    "PySide2.QtSql.QSqlRecord.replace": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.setGenerated": [('int', 'bool'), ('str', 'bool')],
-    "PySide2.QtSql.QSqlRecord.setNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.setValue": [('int', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtSql.QSqlRecord.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlRelation:
-    "PySide2.QtSql.QSqlRelation.__init__": [(), ('PySide2.QtSql.QSqlRelation',), ('str', 'str', 'str')],
-    "PySide2.QtSql.QSqlRelation.__copy__": (),
-    "PySide2.QtSql.QSqlRelation.displayColumn": (),
-    "PySide2.QtSql.QSqlRelation.indexColumn": (),
-    "PySide2.QtSql.QSqlRelation.isValid": (),
-    "PySide2.QtSql.QSqlRelation.swap": ('PySide2.QtSql.QSqlRelation',),
-    "PySide2.QtSql.QSqlRelation.tableName": (),
-# class PySide2.QtSql.QSqlRelationalDelegate:
-    "PySide2.QtSql.QSqlRelationalDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlRelationalDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtSql.QSqlRelationalTableModel:
-# class PySide2.QtSql.QSqlRelationalTableModel.JoinMode:
-    "PySide2.QtSql.QSqlRelationalTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlRelationalTableModel.clear": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRelationalTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.relation": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.relationModel": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.select": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setJoinMode": ('PySide2.QtSql.QSqlRelationalTableModel.JoinMode',),
-    "PySide2.QtSql.QSqlRelationalTableModel.setRelation": ('int', 'PySide2.QtSql.QSqlRelation'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlRelationalTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-# class PySide2.QtSql.QSqlResult:
-# class PySide2.QtSql.QSqlResult.BindingSyntax:
-    "PySide2.QtSql.QSqlResult.__init__": ('PySide2.QtSql.QSqlDriver',),
-    "PySide2.QtSql.QSqlResult.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlResult.at": (),
-    "PySide2.QtSql.QSqlResult.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlResult.bindValueType": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.bindingSyntax": (),
-    "PySide2.QtSql.QSqlResult.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.boundValueCount": (),
-    "PySide2.QtSql.QSqlResult.boundValueName": ('int',),
-    "PySide2.QtSql.QSqlResult.boundValues": (),
-    "PySide2.QtSql.QSqlResult.clear": (),
-    "PySide2.QtSql.QSqlResult.data": ('int',),
-    "PySide2.QtSql.QSqlResult.detachFromResultSet": (),
-    "PySide2.QtSql.QSqlResult.driver": (),
-    "PySide2.QtSql.QSqlResult.execBatch": ('bool',),
-    "PySide2.QtSql.QSqlResult.exec_": (),
-    "PySide2.QtSql.QSqlResult.executedQuery": (),
-    "PySide2.QtSql.QSqlResult.fetch": ('int',),
-    "PySide2.QtSql.QSqlResult.fetchFirst": (),
-    "PySide2.QtSql.QSqlResult.fetchLast": (),
-    "PySide2.QtSql.QSqlResult.fetchNext": (),
-    "PySide2.QtSql.QSqlResult.fetchPrevious": (),
-    "PySide2.QtSql.QSqlResult.handle": (),
-    "PySide2.QtSql.QSqlResult.hasOutValues": (),
-    "PySide2.QtSql.QSqlResult.isActive": (),
-    "PySide2.QtSql.QSqlResult.isForwardOnly": (),
-    "PySide2.QtSql.QSqlResult.isNull": ('int',),
-    "PySide2.QtSql.QSqlResult.isSelect": (),
-    "PySide2.QtSql.QSqlResult.isValid": (),
-    "PySide2.QtSql.QSqlResult.lastError": (),
-    "PySide2.QtSql.QSqlResult.lastInsertId": (),
-    "PySide2.QtSql.QSqlResult.lastQuery": (),
-    "PySide2.QtSql.QSqlResult.nextResult": (),
-    "PySide2.QtSql.QSqlResult.numRowsAffected": (),
-    "PySide2.QtSql.QSqlResult.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlResult.prepare": ('str',),
-    "PySide2.QtSql.QSqlResult.record": (),
-    "PySide2.QtSql.QSqlResult.reset": ('str',),
-    "PySide2.QtSql.QSqlResult.resetBindCount": (),
-    "PySide2.QtSql.QSqlResult.savePrepare": ('str',),
-    "PySide2.QtSql.QSqlResult.setActive": ('bool',),
-    "PySide2.QtSql.QSqlResult.setAt": ('int',),
-    "PySide2.QtSql.QSqlResult.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlResult.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlResult.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlResult.setQuery": ('str',),
-    "PySide2.QtSql.QSqlResult.setSelect": ('bool',),
-    "PySide2.QtSql.QSqlResult.size": (),
-# class PySide2.QtSql.QSqlTableModel:
-# class PySide2.QtSql.QSqlTableModel.EditStrategy:
-    "PySide2.QtSql.QSqlTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlTableModel.clear": (),
-    "PySide2.QtSql.QSqlTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlTableModel.database": (),
-    "PySide2.QtSql.QSqlTableModel.deleteRowFromTable": ('int',),
-    "PySide2.QtSql.QSqlTableModel.editStrategy": (),
-    "PySide2.QtSql.QSqlTableModel.fieldIndex": ('str',),
-    "PySide2.QtSql.QSqlTableModel.filter": (),
-    "PySide2.QtSql.QSqlTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlTableModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.insertRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlTableModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.isDirty": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtSql.QSqlTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlTableModel.primaryKey": (),
-    "PySide2.QtSql.QSqlTableModel.primaryValues": ('int',),
-    "PySide2.QtSql.QSqlTableModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.revert": (),
-    "PySide2.QtSql.QSqlTableModel.revertAll": (),
-    "PySide2.QtSql.QSqlTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.select": (),
-    "PySide2.QtSql.QSqlTableModel.selectRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlTableModel.setEditStrategy": ('PySide2.QtSql.QSqlTableModel.EditStrategy',),
-    "PySide2.QtSql.QSqlTableModel.setFilter": ('str',),
-    "PySide2.QtSql.QSqlTableModel.setPrimaryKey": ('PySide2.QtSql.QSqlIndex',),
-    "PySide2.QtSql.QSqlTableModel.setQuery": ('PySide2.QtSql.QSqlQuery',),
-    "PySide2.QtSql.QSqlTableModel.setRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.setSort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlTableModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.submit": (),
-    "PySide2.QtSql.QSqlTableModel.submitAll": (),
-    "PySide2.QtSql.QSqlTableModel.tableName": (),
-    "PySide2.QtSql.QSqlTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-    }) if "PySide2.QtSql" in sys.modules else None
-# Module PySide2.QtNetwork
-sig_dict.update({
-# class PySide2.QtNetwork.QAbstractNetworkCache:
-    "PySide2.QtNetwork.QAbstractNetworkCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.cacheSize": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.clear": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QAbstractSocket:
-# class PySide2.QtNetwork.QAbstractSocket.BindFlag:
-# class PySide2.QtNetwork.QAbstractSocket.BindMode:
-# class PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol:
-# class PySide2.QtNetwork.QAbstractSocket.PauseMode:
-# class PySide2.QtNetwork.QAbstractSocket.PauseModes:
-# class PySide2.QtNetwork.QAbstractSocket.SocketError:
-# class PySide2.QtNetwork.QAbstractSocket.SocketOption:
-# class PySide2.QtNetwork.QAbstractSocket.SocketState:
-# class PySide2.QtNetwork.QAbstractSocket.SocketType:
-    "PySide2.QtNetwork.QAbstractSocket.__init__": ('PySide2.QtNetwork.QAbstractSocket.SocketType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QAbstractSocket.abort": (),
-    "PySide2.QtNetwork.QAbstractSocket.atEnd": (),
-    "PySide2.QtNetwork.QAbstractSocket.bind": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtNetwork.QAbstractSocket.BindMode'), ('int', 'PySide2.QtNetwork.QAbstractSocket.BindMode')],
-    "PySide2.QtNetwork.QAbstractSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QAbstractSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QAbstractSocket.canReadLine": (),
-    "PySide2.QtNetwork.QAbstractSocket.close": (),
-    "PySide2.QtNetwork.QAbstractSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QAbstractSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QAbstractSocket.error": (),
-    "PySide2.QtNetwork.QAbstractSocket.flush": (),
-    "PySide2.QtNetwork.QAbstractSocket.isSequential": (),
-    "PySide2.QtNetwork.QAbstractSocket.isValid": (),
-    "PySide2.QtNetwork.QAbstractSocket.localAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.localPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.pauseMode": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerName": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.protocolTag": (),
-    "PySide2.QtNetwork.QAbstractSocket.proxy": (),
-    "PySide2.QtNetwork.QAbstractSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QAbstractSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.readLineData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.resume": (),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerName": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QAbstractSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketError": ('PySide2.QtNetwork.QAbstractSocket.SocketError',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketState": ('PySide2.QtNetwork.QAbstractSocket.SocketState',),
-    "PySide2.QtNetwork.QAbstractSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QAbstractSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QAbstractSocket.socketType": (),
-    "PySide2.QtNetwork.QAbstractSocket.state": (),
-    "PySide2.QtNetwork.QAbstractSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QAuthenticator:
-    "PySide2.QtNetwork.QAuthenticator.__init__": [(), ('PySide2.QtNetwork.QAuthenticator',)],
-    "PySide2.QtNetwork.QAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QAuthenticator.isNull": (),
-    "PySide2.QtNetwork.QAuthenticator.option": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.options": (),
-    "PySide2.QtNetwork.QAuthenticator.password": (),
-    "PySide2.QtNetwork.QAuthenticator.realm": (),
-    "PySide2.QtNetwork.QAuthenticator.setOption": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QAuthenticator.setPassword": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setRealm": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setUser": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.user": (),
-# class PySide2.QtNetwork.QDnsDomainNameRecord:
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__init__": [(), ('PySide2.QtNetwork.QDnsDomainNameRecord',)],
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.name": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.swap": ('PySide2.QtNetwork.QDnsDomainNameRecord',),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.value": (),
-# class PySide2.QtNetwork.QDnsHostAddressRecord:
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__init__": [(), ('PySide2.QtNetwork.QDnsHostAddressRecord',)],
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.name": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.swap": ('PySide2.QtNetwork.QDnsHostAddressRecord',),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.value": (),
-# class PySide2.QtNetwork.QDnsLookup:
-# class PySide2.QtNetwork.QDnsLookup.Error:
-# class PySide2.QtNetwork.QDnsLookup.Type:
-    "PySide2.QtNetwork.QDnsLookup.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtNetwork.QHostAddress', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QDnsLookup.abort": (),
-    "PySide2.QtNetwork.QDnsLookup.canonicalNameRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.error": (),
-    "PySide2.QtNetwork.QDnsLookup.errorString": (),
-    "PySide2.QtNetwork.QDnsLookup.hostAddressRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.isFinished": (),
-    "PySide2.QtNetwork.QDnsLookup.lookup": (),
-    "PySide2.QtNetwork.QDnsLookup.mailExchangeRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.name": (),
-    "PySide2.QtNetwork.QDnsLookup.nameServerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.nameserver": (),
-    "PySide2.QtNetwork.QDnsLookup.pointerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.serviceRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.setName": ('str',),
-    "PySide2.QtNetwork.QDnsLookup.setNameserver": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QDnsLookup.setType": ('PySide2.QtNetwork.QDnsLookup.Type',),
-    "PySide2.QtNetwork.QDnsLookup.textRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.type": (),
-# class PySide2.QtNetwork.QDnsMailExchangeRecord:
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__init__": [(), ('PySide2.QtNetwork.QDnsMailExchangeRecord',)],
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.exchange": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.name": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.preference": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.swap": ('PySide2.QtNetwork.QDnsMailExchangeRecord',),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.timeToLive": (),
-# class PySide2.QtNetwork.QDnsServiceRecord:
-    "PySide2.QtNetwork.QDnsServiceRecord.__init__": [(), ('PySide2.QtNetwork.QDnsServiceRecord',)],
-    "PySide2.QtNetwork.QDnsServiceRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.name": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.port": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.priority": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.swap": ('PySide2.QtNetwork.QDnsServiceRecord',),
-    "PySide2.QtNetwork.QDnsServiceRecord.target": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.weight": (),
-# class PySide2.QtNetwork.QDnsTextRecord:
-    "PySide2.QtNetwork.QDnsTextRecord.__init__": [(), ('PySide2.QtNetwork.QDnsTextRecord',)],
-    "PySide2.QtNetwork.QDnsTextRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsTextRecord.name": (),
-    "PySide2.QtNetwork.QDnsTextRecord.swap": ('PySide2.QtNetwork.QDnsTextRecord',),
-    "PySide2.QtNetwork.QDnsTextRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsTextRecord.values": (),
-# class PySide2.QtNetwork.QHostAddress:
-# class PySide2.QtNetwork.QHostAddress.ConversionMode:
-# class PySide2.QtNetwork.QHostAddress.ConversionModeFlag:
-# class PySide2.QtNetwork.QHostAddress.SpecialAddress:
-    "PySide2.QtNetwork.QHostAddress.__init__": [(), ('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.__copy__": (),
-    "PySide2.QtNetwork.QHostAddress.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.clear": (),
-    "PySide2.QtNetwork.QHostAddress.isBroadcast": (),
-    "PySide2.QtNetwork.QHostAddress.isEqual": ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QHostAddress.ConversionMode'),
-    "PySide2.QtNetwork.QHostAddress.isGlobal": (),
-    "PySide2.QtNetwork.QHostAddress.isInSubnet": [('PySide2.QtNetwork.QHostAddress', 'int'), ('typing.Tuple[PySide2.QtNetwork.QHostAddress, int]',)],
-    "PySide2.QtNetwork.QHostAddress.isLinkLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isLoopback": (),
-    "PySide2.QtNetwork.QHostAddress.isMulticast": (),
-    "PySide2.QtNetwork.QHostAddress.isNull": (),
-    "PySide2.QtNetwork.QHostAddress.isSiteLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isUniqueLocalUnicast": (),
-    "PySide2.QtNetwork.QHostAddress.parseSubnet": ('str',),
-    "PySide2.QtNetwork.QHostAddress.protocol": (),
-    "PySide2.QtNetwork.QHostAddress.scopeId": (),
-    "PySide2.QtNetwork.QHostAddress.setAddress": [('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.setScopeId": ('str',),
-    "PySide2.QtNetwork.QHostAddress.swap": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QHostAddress.toIPv4Address": (),
-    "PySide2.QtNetwork.QHostAddress.toIPv6Address": (),
-    "PySide2.QtNetwork.QHostAddress.toString": (),
-# class PySide2.QtNetwork.QHostInfo:
-# class PySide2.QtNetwork.QHostInfo.HostInfoError:
-    "PySide2.QtNetwork.QHostInfo.__init__": [('PySide2.QtNetwork.QHostInfo',), ('int',)],
-    "PySide2.QtNetwork.QHostInfo.__copy__": (),
-    "PySide2.QtNetwork.QHostInfo.abortHostLookup": ('int',),
-    "PySide2.QtNetwork.QHostInfo.addresses": (),
-    "PySide2.QtNetwork.QHostInfo.error": (),
-    "PySide2.QtNetwork.QHostInfo.errorString": (),
-    "PySide2.QtNetwork.QHostInfo.fromName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.hostName": (),
-    "PySide2.QtNetwork.QHostInfo.localDomainName": (),
-    "PySide2.QtNetwork.QHostInfo.localHostName": (),
-    "PySide2.QtNetwork.QHostInfo.lookupId": (),
-    "PySide2.QtNetwork.QHostInfo.setAddresses": ('typing.Sequence[PySide2.QtNetwork.QHostAddress]',),
-    "PySide2.QtNetwork.QHostInfo.setError": ('PySide2.QtNetwork.QHostInfo.HostInfoError',),
-    "PySide2.QtNetwork.QHostInfo.setErrorString": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setHostName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setLookupId": ('int',),
-    "PySide2.QtNetwork.QHostInfo.swap": ('PySide2.QtNetwork.QHostInfo',),
-# class PySide2.QtNetwork.QHstsPolicy:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlag:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlags:
-    "PySide2.QtNetwork.QHstsPolicy.__init__": [(), ('PySide2.QtCore.QDateTime', 'PySide2.QtNetwork.QHstsPolicy.PolicyFlags', 'str', 'PySide2.QtCore.QUrl.ParsingMode'), ('PySide2.QtNetwork.QHstsPolicy',)],
-    "PySide2.QtNetwork.QHstsPolicy.__copy__": (),
-    "PySide2.QtNetwork.QHstsPolicy.expiry": (),
-    "PySide2.QtNetwork.QHstsPolicy.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtNetwork.QHstsPolicy.includesSubDomains": (),
-    "PySide2.QtNetwork.QHstsPolicy.isExpired": (),
-    "PySide2.QtNetwork.QHstsPolicy.setExpiry": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QHstsPolicy.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtNetwork.QHstsPolicy.setIncludesSubDomains": ('bool',),
-    "PySide2.QtNetwork.QHstsPolicy.swap": ('PySide2.QtNetwork.QHstsPolicy',),
-# class PySide2.QtNetwork.QHttpMultiPart:
-# class PySide2.QtNetwork.QHttpMultiPart.ContentType:
-    "PySide2.QtNetwork.QHttpMultiPart.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QHttpMultiPart.ContentType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QHttpMultiPart.append": ('PySide2.QtNetwork.QHttpPart',),
-    "PySide2.QtNetwork.QHttpMultiPart.boundary": (),
-    "PySide2.QtNetwork.QHttpMultiPart.setBoundary": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpMultiPart.setContentType": ('PySide2.QtNetwork.QHttpMultiPart.ContentType',),
-# class PySide2.QtNetwork.QHttpPart:
-    "PySide2.QtNetwork.QHttpPart.__init__": [(), ('PySide2.QtNetwork.QHttpPart',)],
-    "PySide2.QtNetwork.QHttpPart.__copy__": (),
-    "PySide2.QtNetwork.QHttpPart.setBody": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpPart.setBodyDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QHttpPart.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QHttpPart.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QHttpPart.swap": ('PySide2.QtNetwork.QHttpPart',),
-# class PySide2.QtNetwork.QIPv6Address:
-    "PySide2.QtNetwork.QIPv6Address.__init__": [(), ('PySide2.QtNetwork.QIPv6Address',)],
-    "PySide2.QtNetwork.QIPv6Address.__copy__": (),
-# class PySide2.QtNetwork.QLocalServer:
-# class PySide2.QtNetwork.QLocalServer.SocketOption:
-# class PySide2.QtNetwork.QLocalServer.SocketOptions:
-    "PySide2.QtNetwork.QLocalServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalServer.close": (),
-    "PySide2.QtNetwork.QLocalServer.errorString": (),
-    "PySide2.QtNetwork.QLocalServer.fullServerName": (),
-    "PySide2.QtNetwork.QLocalServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QLocalServer.isListening": (),
-    "PySide2.QtNetwork.QLocalServer.listen": [('int',), ('str',)],
-    "PySide2.QtNetwork.QLocalServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QLocalServer.removeServer": ('str',),
-    "PySide2.QtNetwork.QLocalServer.serverError": (),
-    "PySide2.QtNetwork.QLocalServer.serverName": (),
-    "PySide2.QtNetwork.QLocalServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QLocalServer.setSocketOptions": ('PySide2.QtNetwork.QLocalServer.SocketOptions',),
-    "PySide2.QtNetwork.QLocalServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalServer.socketOptions": (),
-    "PySide2.QtNetwork.QLocalServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QLocalSocket:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketError:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketState:
-    "PySide2.QtNetwork.QLocalSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalSocket.abort": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QLocalSocket.canReadLine": (),
-    "PySide2.QtNetwork.QLocalSocket.close": (),
-    "PySide2.QtNetwork.QLocalSocket.connectToServer": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtNetwork.QLocalSocket.disconnectFromServer": (),
-    "PySide2.QtNetwork.QLocalSocket.error": (),
-    "PySide2.QtNetwork.QLocalSocket.flush": (),
-    "PySide2.QtNetwork.QLocalSocket.fullServerName": (),
-    "PySide2.QtNetwork.QLocalSocket.isSequential": (),
-    "PySide2.QtNetwork.QLocalSocket.isValid": (),
-    "PySide2.QtNetwork.QLocalSocket.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtNetwork.QLocalSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QLocalSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QLocalSocket.serverName": (),
-    "PySide2.QtNetwork.QLocalSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.setServerName": ('str',),
-    "PySide2.QtNetwork.QLocalSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QLocalSocket.LocalSocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QLocalSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalSocket.state": (),
-    "PySide2.QtNetwork.QLocalSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkAccessManager:
-# class PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility:
-# class PySide2.QtNetwork.QNetworkAccessManager.Operation:
-    "PySide2.QtNetwork.QNetworkAccessManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkAccessManager.activeConfiguration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.addStrictTransportSecurityHosts": ('typing.List[PySide2.QtNetwork.QHstsPolicy]',),
-    "PySide2.QtNetwork.QNetworkAccessManager.autoDeleteReplies": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.cache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearAccessCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearConnectionCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.configuration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHost": ('str', 'int'),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHostEncrypted": [('str', 'int', 'PySide2.QtNetwork.QSslConfiguration'), ('str', 'int', 'PySide2.QtNetwork.QSslConfiguration', 'str')],
-    "PySide2.QtNetwork.QNetworkAccessManager.cookieJar": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.createRequest": ('PySide2.QtNetwork.QNetworkAccessManager.Operation', 'PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtNetwork.QNetworkAccessManager.deleteResource": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.enableStrictTransportSecurityStore": ('bool', 'str'),
-    "PySide2.QtNetwork.QNetworkAccessManager.get": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.head": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityStoreEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.networkAccessible": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.post": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.proxy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.proxyFactory": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.put": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.redirectPolicy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.sendCustomRequest": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.setAutoDeleteReplies": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCache": ('PySide2.QtNetwork.QAbstractNetworkCache',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCookieJar": ('PySide2.QtNetwork.QNetworkCookieJar',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setNetworkAccessible": ('PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setRedirectPolicy": ('PySide2.QtNetwork.QNetworkRequest.RedirectPolicy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setStrictTransportSecurityEnabled": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.strictTransportSecurityHosts": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemes": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemesImplementation": (),
-# class PySide2.QtNetwork.QNetworkAddressEntry:
-# class PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus:
-    "PySide2.QtNetwork.QNetworkAddressEntry.__init__": [(), ('PySide2.QtNetwork.QNetworkAddressEntry',)],
-    "PySide2.QtNetwork.QNetworkAddressEntry.__copy__": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.broadcast": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.clearAddressLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.dnsEligibility": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.ip": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isLifetimeKnown": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isPermanent": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isTemporary": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.netmask": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.preferredLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.prefixLength": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setAddressLifetime": ('PySide2.QtCore.QDeadlineTimer', 'PySide2.QtCore.QDeadlineTimer'),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setBroadcast": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setDnsEligibility": ('PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setIp": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setNetmask": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setPrefixLength": ('int',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.swap": ('PySide2.QtNetwork.QNetworkAddressEntry',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.validityLifetime": (),
-# class PySide2.QtNetwork.QNetworkCacheMetaData:
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__init__": [(), ('PySide2.QtNetwork.QNetworkCacheMetaData',)],
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.attributes": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.isValid": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.lastModified": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.rawHeaders": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.saveToDisk": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setAttributes": ('typing.Dict[PySide2.QtNetwork.QNetworkRequest.Attribute, typing.Any]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setLastModified": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setRawHeaders": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setSaveToDisk": ('bool',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.swap": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.url": (),
-# class PySide2.QtNetwork.QNetworkConfiguration:
-# class PySide2.QtNetwork.QNetworkConfiguration.BearerType:
-# class PySide2.QtNetwork.QNetworkConfiguration.Purpose:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlag:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlags:
-# class PySide2.QtNetwork.QNetworkConfiguration.Type:
-    "PySide2.QtNetwork.QNetworkConfiguration.__init__": [(), ('PySide2.QtNetwork.QNetworkConfiguration',)],
-    "PySide2.QtNetwork.QNetworkConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerType": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeFamily": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeName": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.children": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.connectTimeout": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.identifier": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isRoamingAvailable": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isValid": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.name": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.purpose": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.setConnectTimeout": ('int',),
-    "PySide2.QtNetwork.QNetworkConfiguration.state": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.swap": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkConfiguration.type": (),
-# class PySide2.QtNetwork.QNetworkConfigurationManager:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capabilities:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capability:
-    "PySide2.QtNetwork.QNetworkConfigurationManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.allConfigurations": ('PySide2.QtNetwork.QNetworkConfiguration.StateFlags',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.capabilities": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.configurationFromIdentifier": ('str',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.defaultConfiguration": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.isOnline": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.updateConfigurations": (),
-# class PySide2.QtNetwork.QNetworkCookie:
-# class PySide2.QtNetwork.QNetworkCookie.RawForm:
-    "PySide2.QtNetwork.QNetworkCookie.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkCookie',)],
-    "PySide2.QtNetwork.QNetworkCookie.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCookie.domain": (),
-    "PySide2.QtNetwork.QNetworkCookie.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCookie.hasSameIdentifier": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.isHttpOnly": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSecure": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSessionCookie": (),
-    "PySide2.QtNetwork.QNetworkCookie.name": (),
-    "PySide2.QtNetwork.QNetworkCookie.normalize": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookie.parseCookies": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.path": (),
-    "PySide2.QtNetwork.QNetworkCookie.setDomain": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCookie.setHttpOnly": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.setPath": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setSecure": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setValue": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.swap": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.toRawForm": ('PySide2.QtNetwork.QNetworkCookie.RawForm',),
-    "PySide2.QtNetwork.QNetworkCookie.value": (),
-# class PySide2.QtNetwork.QNetworkCookieJar:
-    "PySide2.QtNetwork.QNetworkCookieJar.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkCookieJar.allCookies": (),
-    "PySide2.QtNetwork.QNetworkCookieJar.cookiesForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookieJar.deleteCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.insertCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setAllCookies": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setCookiesFromUrl": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtNetwork.QNetworkCookieJar.updateCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.validateCookie": ('PySide2.QtNetwork.QNetworkCookie', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtNetwork.QNetworkDatagram:
-    "PySide2.QtNetwork.QNetworkDatagram.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    "PySide2.QtNetwork.QNetworkDatagram.__copy__": (),
-    "PySide2.QtNetwork.QNetworkDatagram.clear": (),
-    "PySide2.QtNetwork.QNetworkDatagram.data": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.hopLimit": (),
-    "PySide2.QtNetwork.QNetworkDatagram.interfaceIndex": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isNull": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isValid": (),
-    "PySide2.QtNetwork.QNetworkDatagram.makeReply": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.senderAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.senderPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.setDestination": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.setHopLimit": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setInterfaceIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setSender": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.swap": ('PySide2.QtNetwork.QNetworkDatagram',),
-# class PySide2.QtNetwork.QNetworkDiskCache:
-    "PySide2.QtNetwork.QNetworkDiskCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheDirectory": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.clear": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.expire": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.fileMetaData": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QNetworkDiskCache.maximumCacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkDiskCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setCacheDirectory": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setMaximumCacheSize": ('int',),
-    "PySide2.QtNetwork.QNetworkDiskCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QNetworkInterface:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlag:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlags:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceType:
-    "PySide2.QtNetwork.QNetworkInterface.__init__": [(), ('PySide2.QtNetwork.QNetworkInterface',)],
-    "PySide2.QtNetwork.QNetworkInterface.__copy__": (),
-    "PySide2.QtNetwork.QNetworkInterface.addressEntries": (),
-    "PySide2.QtNetwork.QNetworkInterface.allAddresses": (),
-    "PySide2.QtNetwork.QNetworkInterface.allInterfaces": (),
-    "PySide2.QtNetwork.QNetworkInterface.flags": (),
-    "PySide2.QtNetwork.QNetworkInterface.hardwareAddress": (),
-    "PySide2.QtNetwork.QNetworkInterface.humanReadableName": (),
-    "PySide2.QtNetwork.QNetworkInterface.index": (),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceIndexFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceNameFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.isValid": (),
-    "PySide2.QtNetwork.QNetworkInterface.maximumTransmissionUnit": (),
-    "PySide2.QtNetwork.QNetworkInterface.name": (),
-    "PySide2.QtNetwork.QNetworkInterface.swap": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QNetworkInterface.type": (),
-# class PySide2.QtNetwork.QNetworkProxy:
-# class PySide2.QtNetwork.QNetworkProxy.Capabilities:
-# class PySide2.QtNetwork.QNetworkProxy.Capability:
-# class PySide2.QtNetwork.QNetworkProxy.ProxyType:
-    "PySide2.QtNetwork.QNetworkProxy.__init__": [(), ('PySide2.QtNetwork.QNetworkProxy',), ('PySide2.QtNetwork.QNetworkProxy.ProxyType', 'str', 'int', 'str', 'str')],
-    "PySide2.QtNetwork.QNetworkProxy.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxy.applicationProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.capabilities": (),
-    "PySide2.QtNetwork.QNetworkProxy.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkProxy.hostName": (),
-    "PySide2.QtNetwork.QNetworkProxy.isCachingProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.isTransparentProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.password": (),
-    "PySide2.QtNetwork.QNetworkProxy.port": (),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkProxy.setApplicationProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.setCapabilities": ('PySide2.QtNetwork.QNetworkProxy.Capabilities',),
-    "PySide2.QtNetwork.QNetworkProxy.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkProxy.setHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPassword": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxy.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkProxy.setType": ('PySide2.QtNetwork.QNetworkProxy.ProxyType',),
-    "PySide2.QtNetwork.QNetworkProxy.setUser": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.swap": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.type": (),
-    "PySide2.QtNetwork.QNetworkProxy.user": (),
-# class PySide2.QtNetwork.QNetworkProxyFactory:
-    "PySide2.QtNetwork.QNetworkProxyFactory.__init__": (),
-    "PySide2.QtNetwork.QNetworkProxyFactory.proxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.queryProxy": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setApplicationProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration": ('bool',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.systemProxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.usesSystemConfiguration": (),
-# class PySide2.QtNetwork.QNetworkProxyQuery:
-# class PySide2.QtNetwork.QNetworkProxyQuery.QueryType:
-    "PySide2.QtNetwork.QNetworkProxyQuery.__init__": [(), ('PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkProxyQuery',), ('int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType')],
-    "PySide2.QtNetwork.QNetworkProxyQuery.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.localPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.networkConfiguration": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerHostName": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.protocolTag": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.queryType": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setNetworkConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setQueryType": ('PySide2.QtNetwork.QNetworkProxyQuery.QueryType',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.swap": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.url": (),
-# class PySide2.QtNetwork.QNetworkReply:
-# class PySide2.QtNetwork.QNetworkReply.NetworkError:
-    "PySide2.QtNetwork.QNetworkReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkReply.abort": (),
-    "PySide2.QtNetwork.QNetworkReply.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute',),
-    "PySide2.QtNetwork.QNetworkReply.close": (),
-    "PySide2.QtNetwork.QNetworkReply.error": (),
-    "PySide2.QtNetwork.QNetworkReply.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrorsImplementation": ('typing.Sequence[PySide2.QtNetwork.QSslError]',),
-    "PySide2.QtNetwork.QNetworkReply.isFinished": (),
-    "PySide2.QtNetwork.QNetworkReply.isRunning": (),
-    "PySide2.QtNetwork.QNetworkReply.isSequential": (),
-    "PySide2.QtNetwork.QNetworkReply.manager": (),
-    "PySide2.QtNetwork.QNetworkReply.operation": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderPairs": (),
-    "PySide2.QtNetwork.QNetworkReply.readBufferSize": (),
-    "PySide2.QtNetwork.QNetworkReply.request": (),
-    "PySide2.QtNetwork.QNetworkReply.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setError": ('PySide2.QtNetwork.QNetworkReply.NetworkError', 'str'),
-    "PySide2.QtNetwork.QNetworkReply.setFinished": ('bool',),
-    "PySide2.QtNetwork.QNetworkReply.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setOperation": ('PySide2.QtNetwork.QNetworkAccessManager.Operation',),
-    "PySide2.QtNetwork.QNetworkReply.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkReply.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QNetworkReply.setRequest": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkReply.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkReply.sslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.url": (),
-    "PySide2.QtNetwork.QNetworkReply.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkRequest:
-# class PySide2.QtNetwork.QNetworkRequest.Attribute:
-# class PySide2.QtNetwork.QNetworkRequest.CacheLoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.KnownHeaders:
-# class PySide2.QtNetwork.QNetworkRequest.LoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.Priority:
-# class PySide2.QtNetwork.QNetworkRequest.RedirectPolicy:
-    "PySide2.QtNetwork.QNetworkRequest.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtNetwork.QNetworkRequest.__copy__": (),
-    "PySide2.QtNetwork.QNetworkRequest.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkRequest.maximumRedirectsAllowed": (),
-    "PySide2.QtNetwork.QNetworkRequest.originatingObject": (),
-    "PySide2.QtNetwork.QNetworkRequest.peerVerifyName": (),
-    "PySide2.QtNetwork.QNetworkRequest.priority": (),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkRequest.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setMaximumRedirectsAllowed": ('int',),
-    "PySide2.QtNetwork.QNetworkRequest.setOriginatingObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkRequest.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QNetworkRequest.setPriority": ('PySide2.QtNetwork.QNetworkRequest.Priority',),
-    "PySide2.QtNetwork.QNetworkRequest.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkRequest.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkRequest.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkRequest.swap": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkRequest.url": (),
-# class PySide2.QtNetwork.QNetworkSession:
-# class PySide2.QtNetwork.QNetworkSession.SessionError:
-# class PySide2.QtNetwork.QNetworkSession.State:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicies:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicy:
-    "PySide2.QtNetwork.QNetworkSession.__init__": ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QNetworkSession.accept": (),
-    "PySide2.QtNetwork.QNetworkSession.activeTime": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesReceived": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesWritten": (),
-    "PySide2.QtNetwork.QNetworkSession.close": (),
-    "PySide2.QtNetwork.QNetworkSession.configuration": (),
-    "PySide2.QtNetwork.QNetworkSession.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.error": (),
-    "PySide2.QtNetwork.QNetworkSession.errorString": (),
-    "PySide2.QtNetwork.QNetworkSession.ignore": (),
-    "PySide2.QtNetwork.QNetworkSession.interface": (),
-    "PySide2.QtNetwork.QNetworkSession.isOpen": (),
-    "PySide2.QtNetwork.QNetworkSession.migrate": (),
-    "PySide2.QtNetwork.QNetworkSession.open": (),
-    "PySide2.QtNetwork.QNetworkSession.reject": (),
-    "PySide2.QtNetwork.QNetworkSession.sessionProperty": ('str',),
-    "PySide2.QtNetwork.QNetworkSession.setSessionProperty": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkSession.state": (),
-    "PySide2.QtNetwork.QNetworkSession.stop": (),
-    "PySide2.QtNetwork.QNetworkSession.usagePolicies": (),
-    "PySide2.QtNetwork.QNetworkSession.waitForOpened": ('int',),
-# class PySide2.QtNetwork.QOcspCertificateStatus:
-# class PySide2.QtNetwork.QOcspResponse:
-    "PySide2.QtNetwork.QOcspResponse.__init__": [(), ('PySide2.QtNetwork.QOcspResponse',)],
-    "PySide2.QtNetwork.QOcspResponse.__copy__": (),
-    "PySide2.QtNetwork.QOcspResponse.certificateStatus": (),
-    "PySide2.QtNetwork.QOcspResponse.revocationReason": (),
-    "PySide2.QtNetwork.QOcspResponse.subject": (),
-    "PySide2.QtNetwork.QOcspResponse.swap": ('PySide2.QtNetwork.QOcspResponse',),
-# class PySide2.QtNetwork.QOcspRevocationReason:
-# class PySide2.QtNetwork.QPasswordDigestor:
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf1": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf2": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-# class PySide2.QtNetwork.QSsl:
-# class PySide2.QtNetwork.QSsl.AlternativeNameEntryType:
-# class PySide2.QtNetwork.QSsl.EncodingFormat:
-# class PySide2.QtNetwork.QSsl.KeyAlgorithm:
-# class PySide2.QtNetwork.QSsl.KeyType:
-# class PySide2.QtNetwork.QSsl.SslOption:
-# class PySide2.QtNetwork.QSsl.SslOptions:
-# class PySide2.QtNetwork.QSsl.SslProtocol:
-# class PySide2.QtNetwork.QSslCertificate:
-# class PySide2.QtNetwork.QSslCertificate.SubjectInfo:
-    "PySide2.QtNetwork.QSslCertificate.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtNetwork.QSslCertificate',)],
-    "PySide2.QtNetwork.QSslCertificate.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificate.clear": (),
-    "PySide2.QtNetwork.QSslCertificate.digest": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtNetwork.QSslCertificate.effectiveDate": (),
-    "PySide2.QtNetwork.QSslCertificate.expiryDate": (),
-    "PySide2.QtNetwork.QSslCertificate.extensions": (),
-    "PySide2.QtNetwork.QSslCertificate.fromData": ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromDevice": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromPath": ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'),
-    "PySide2.QtNetwork.QSslCertificate.handle": (),
-    "PySide2.QtNetwork.QSslCertificate.importPkcs12": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSslKey', 'PySide2.QtNetwork.QSslCertificate', 'typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QSslCertificate.isBlacklisted": (),
-    "PySide2.QtNetwork.QSslCertificate.isNull": (),
-    "PySide2.QtNetwork.QSslCertificate.isSelfSigned": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.issuerInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.publicKey": (),
-    "PySide2.QtNetwork.QSslCertificate.serialNumber": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectAlternativeNames": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.subjectInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.swap": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslCertificate.toDer": (),
-    "PySide2.QtNetwork.QSslCertificate.toPem": (),
-    "PySide2.QtNetwork.QSslCertificate.toText": (),
-    "PySide2.QtNetwork.QSslCertificate.verify": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'str'),
-    "PySide2.QtNetwork.QSslCertificate.version": (),
-# class PySide2.QtNetwork.QSslCertificateExtension:
-    "PySide2.QtNetwork.QSslCertificateExtension.__init__": [(), ('PySide2.QtNetwork.QSslCertificateExtension',)],
-    "PySide2.QtNetwork.QSslCertificateExtension.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isCritical": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isSupported": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.name": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.oid": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.swap": ('PySide2.QtNetwork.QSslCertificateExtension',),
-    "PySide2.QtNetwork.QSslCertificateExtension.value": (),
-# class PySide2.QtNetwork.QSslCipher:
-    "PySide2.QtNetwork.QSslCipher.__init__": [(), ('PySide2.QtNetwork.QSslCipher',), ('str',), ('str', 'PySide2.QtNetwork.QSsl.SslProtocol')],
-    "PySide2.QtNetwork.QSslCipher.__copy__": (),
-    "PySide2.QtNetwork.QSslCipher.authenticationMethod": (),
-    "PySide2.QtNetwork.QSslCipher.encryptionMethod": (),
-    "PySide2.QtNetwork.QSslCipher.isNull": (),
-    "PySide2.QtNetwork.QSslCipher.keyExchangeMethod": (),
-    "PySide2.QtNetwork.QSslCipher.name": (),
-    "PySide2.QtNetwork.QSslCipher.protocol": (),
-    "PySide2.QtNetwork.QSslCipher.protocolString": (),
-    "PySide2.QtNetwork.QSslCipher.supportedBits": (),
-    "PySide2.QtNetwork.QSslCipher.swap": ('PySide2.QtNetwork.QSslCipher',),
-    "PySide2.QtNetwork.QSslCipher.usedBits": (),
-# class PySide2.QtNetwork.QSslConfiguration:
-# class PySide2.QtNetwork.QSslConfiguration.NextProtocolNegotiationStatus:
-    "PySide2.QtNetwork.QSslConfiguration.__init__": [(), ('PySide2.QtNetwork.QSslConfiguration',)],
-    "PySide2.QtNetwork.QSslConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QSslConfiguration.allowedNextProtocols": (),
-    "PySide2.QtNetwork.QSslConfiguration.backendConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.caCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.ciphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.diffieHellmanParameters": (),
-    "PySide2.QtNetwork.QSslConfiguration.ephemeralServerKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.isNull": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextNegotiatedProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextProtocolNegotiationStatus": (),
-    "PySide2.QtNetwork.QSslConfiguration.ocspStaplingEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslConfiguration.preSharedKeyIdentityHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.privateKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.protocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionCipher": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicket": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicketLifeTimeHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.setAllowedNextProtocols": ('typing.Sequence[PySide2.QtCore.QByteArray]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfiguration": ('typing.Dict[PySide2.QtCore.QByteArray, typing.Any]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfigurationOption": ('PySide2.QtCore.QByteArray', 'typing.Any'),
-    "PySide2.QtNetwork.QSslConfiguration.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDiffieHellmanParameters": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setOcspStaplingEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslConfiguration.setPreSharedKeyIdentityHint": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setPrivateKey": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslConfiguration.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslConfiguration.setSessionTicket": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setSslOption": ('PySide2.QtNetwork.QSsl.SslOption', 'bool'),
-    "PySide2.QtNetwork.QSslConfiguration.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.swap": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.testSslOption": ('PySide2.QtNetwork.QSsl.SslOption',),
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters:
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters.Error:
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__init__": [(), ('PySide2.QtNetwork.QSslDiffieHellmanParameters',)],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__copy__": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.defaultParameters": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.error": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.errorString": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.fromEncoded": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isEmpty": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isValid": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.swap": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-# class PySide2.QtNetwork.QSslError:
-# class PySide2.QtNetwork.QSslError.SslError:
-    "PySide2.QtNetwork.QSslError.__init__": [(), ('PySide2.QtNetwork.QSslError',), ('PySide2.QtNetwork.QSslError.SslError',), ('PySide2.QtNetwork.QSslError.SslError', 'PySide2.QtNetwork.QSslCertificate')],
-    "PySide2.QtNetwork.QSslError.__copy__": (),
-    "PySide2.QtNetwork.QSslError.certificate": (),
-    "PySide2.QtNetwork.QSslError.error": (),
-    "PySide2.QtNetwork.QSslError.errorString": (),
-    "PySide2.QtNetwork.QSslError.swap": ('PySide2.QtNetwork.QSslError',),
-# class PySide2.QtNetwork.QSslKey:
-    "PySide2.QtNetwork.QSslKey.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QSslKey',), ('int', 'PySide2.QtNetwork.QSsl.KeyType')],
-    "PySide2.QtNetwork.QSslKey.__copy__": (),
-    "PySide2.QtNetwork.QSslKey.algorithm": (),
-    "PySide2.QtNetwork.QSslKey.clear": (),
-    "PySide2.QtNetwork.QSslKey.handle": (),
-    "PySide2.QtNetwork.QSslKey.isNull": (),
-    "PySide2.QtNetwork.QSslKey.length": (),
-    "PySide2.QtNetwork.QSslKey.swap": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslKey.toDer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.toPem": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.type": (),
-# class PySide2.QtNetwork.QSslPreSharedKeyAuthenticator:
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__init__": [(), ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',)],
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identity": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identityHint": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumIdentityLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumPreSharedKeyLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.preSharedKey": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setIdentity": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setPreSharedKey": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.swap": ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',),
-# class PySide2.QtNetwork.QSslSocket:
-# class PySide2.QtNetwork.QSslSocket.PeerVerifyMode:
-# class PySide2.QtNetwork.QSslSocket.SslMode:
-    "PySide2.QtNetwork.QSslSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QSslSocket.abort": (),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.atEnd": (),
-    "PySide2.QtNetwork.QSslSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.caCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.canReadLine": (),
-    "PySide2.QtNetwork.QSslSocket.ciphers": (),
-    "PySide2.QtNetwork.QSslSocket.close": (),
-    "PySide2.QtNetwork.QSslSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.connectToHostEncrypted": [('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol'), ('str', 'int', 'str', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.defaultCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.defaultCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.flush": (),
-    "PySide2.QtNetwork.QSslSocket.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QSslSocket.isEncrypted": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.mode": (),
-    "PySide2.QtNetwork.QSslSocket.ocspResponses": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyName": (),
-    "PySide2.QtNetwork.QSslSocket.privateKey": (),
-    "PySide2.QtNetwork.QSslSocket.protocol": (),
-    "PySide2.QtNetwork.QSslSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QSslSocket.resume": (),
-    "PySide2.QtNetwork.QSslSocket.sessionCipher": (),
-    "PySide2.QtNetwork.QSslSocket.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslSocket.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setCiphers": [('str',), ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',)],
-    "PySide2.QtNetwork.QSslSocket.setDefaultCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setDefaultCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificate": [('PySide2.QtNetwork.QSslCertificate',), ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QSslSocket.setPrivateKey": [('PySide2.QtNetwork.QSslKey',), ('str', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtNetwork.QSslSocket.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QSslSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QSslSocket.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QSslSocket.sslConfiguration": (),
-    "PySide2.QtNetwork.QSslSocket.sslErrors": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.startClientEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.startServerEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.supportsSsl": (),
-    "PySide2.QtNetwork.QSslSocket.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForEncrypted": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QSslSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QTcpServer:
-    "PySide2.QtNetwork.QTcpServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QTcpServer.addPendingConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtNetwork.QTcpServer.close": (),
-    "PySide2.QtNetwork.QTcpServer.errorString": (),
-    "PySide2.QtNetwork.QTcpServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QTcpServer.isListening": (),
-    "PySide2.QtNetwork.QTcpServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QTcpServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QTcpServer.pauseAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.proxy": (),
-    "PySide2.QtNetwork.QTcpServer.resumeAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.serverAddress": (),
-    "PySide2.QtNetwork.QTcpServer.serverError": (),
-    "PySide2.QtNetwork.QTcpServer.serverPort": (),
-    "PySide2.QtNetwork.QTcpServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QTcpServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QTcpServer.setSocketDescriptor": ('int',),
-    "PySide2.QtNetwork.QTcpServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QTcpServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QTcpSocket:
-    "PySide2.QtNetwork.QTcpSocket.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtNetwork.QUdpSocket:
-    "PySide2.QtNetwork.QUdpSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QUdpSocket.hasPendingDatagrams": (),
-    "PySide2.QtNetwork.QUdpSocket.joinMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.leaveMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.multicastInterface": (),
-    "PySide2.QtNetwork.QUdpSocket.pendingDatagramSize": (),
-    "PySide2.QtNetwork.QUdpSocket.readDatagram": ('str', 'int', 'PySide2.QtNetwork.QHostAddress'),
-    "PySide2.QtNetwork.QUdpSocket.receiveDatagram": ('int',),
-    "PySide2.QtNetwork.QUdpSocket.setMulticastInterface": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QUdpSocket.writeDatagram": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    }) if "PySide2.QtNetwork" in sys.modules else None
-# Module PySide2.QtTest
-sig_dict.update({
-# class PySide2.QtTest.QTest:
-# class PySide2.QtTest.QTest.KeyAction:
-# class PySide2.QtTest.QTest.MouseAction:
-# class PySide2.QtTest.QTest.QBenchmarkMetric:
-# class PySide2.QtTest.QTest.QTouchEventSequence:
-    "PySide2.QtTest.QTest.QTouchEventSequence.commit": ('bool',),
-    "PySide2.QtTest.QTest.QTouchEventSequence.move": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.press": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.release": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.stationary": ('int',),
-# class PySide2.QtTest.QTest.TestFailMode:
-    "PySide2.QtTest.QTest.addColumnInternal": ('int', 'str'),
-    "PySide2.QtTest.QTest.asciiToKey": ('int',),
-    "PySide2.QtTest.QTest.compare_ptr_helper": ('int', 'int', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.compare_string_helper": ('str', 'str', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.createTouchDevice": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtTest.QTest.currentAppName": (),
-    "PySide2.QtTest.QTest.currentDataTag": (),
-    "PySide2.QtTest.QTest.currentTestFailed": (),
-    "PySide2.QtTest.QTest.currentTestFunction": (),
-    "PySide2.QtTest.QTest.ignoreMessage": [('PySide2.QtCore.QtMsgType', 'PySide2.QtCore.QRegularExpression'), ('PySide2.QtCore.QtMsgType', 'str')],
-    "PySide2.QtTest.QTest.keyClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyClicks": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'),
-    "PySide2.QtTest.QTest.keyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyPress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keySequence": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtTest.QTest.keyToAscii": ('PySide2.QtCore.Qt.Key',),
-    "PySide2.QtTest.QTest.mouseClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseDClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseEvent": [('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseMove": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mousePress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.qCleanup": (),
-    "PySide2.QtTest.QTest.qElementData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qExpectFail": ('str', 'str', 'PySide2.QtTest.QTest.TestFailMode', 'str', 'int'),
-    "PySide2.QtTest.QTest.qFindTestData": ('str', 'str', 'int', 'str'),
-    "PySide2.QtTest.QTest.qGlobalData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qRun": (),
-    "PySide2.QtTest.QTest.qSkip": ('str', 'str', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowActive": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowExposed": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.sendKeyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.setBenchmarkResult": ('float', 'PySide2.QtTest.QTest.QBenchmarkMetric'),
-    "PySide2.QtTest.QTest.setMainSourcePath": ('str', 'str'),
-    "PySide2.QtTest.QTest.simulateEvent": [('PySide2.QtGui.QWindow', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'), ('PySide2.QtWidgets.QWidget', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtTest.QTest.testObject": (),
-    "PySide2.QtTest.QTest.toPrettyCString": ('str', 'int'),
-    "PySide2.QtTest.QTest.touchEvent": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QTouchDevice', 'bool'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QTouchDevice', 'bool')],
-    }) if "PySide2.QtTest" in sys.modules else None
-# Module PySide2.QtConcurrent
-sig_dict.update({
-# class PySide2.QtConcurrent.QtConcurrent:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOption:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOptions:
-# class PySide2.QtConcurrent.QtConcurrent.ThreadFunctionResult:
-    }) if "PySide2.QtConcurrent" in sys.modules else None
-# Module PySide2.QtMacExtras
-sig_dict.update({
-# class PySide2.QtMacExtras.QMacPasteboardMime:
-# class PySide2.QtMacExtras.QMacPasteboardMime.QMacPasteboardMimeType:
-    "PySide2.QtMacExtras.QMacPasteboardMime.__init__": ('int',),
-    "PySide2.QtMacExtras.QMacPasteboardMime.canConvert": ('str', 'str'),
-    "PySide2.QtMacExtras.QMacPasteboardMime.convertFromMime": ('str', 'typing.Any', 'str'),
-    "PySide2.QtMacExtras.QMacPasteboardMime.convertToMime": ('str', 'typing.Sequence[PySide2.QtCore.QByteArray]', 'str'),
-    "PySide2.QtMacExtras.QMacPasteboardMime.convertorName": (),
-    "PySide2.QtMacExtras.QMacPasteboardMime.count": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtMacExtras.QMacPasteboardMime.flavorFor": ('str',),
-    "PySide2.QtMacExtras.QMacPasteboardMime.mimeFor": ('str',),
-# class PySide2.QtMacExtras.QMacToolBar:
-    "PySide2.QtMacExtras.QMacToolBar.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMacExtras.QMacToolBar.addAllowedItem": ('PySide2.QtGui.QIcon', 'str'),
-    "PySide2.QtMacExtras.QMacToolBar.addAllowedStandardItem": ('PySide2.QtMacExtras.QMacToolBarItem.StandardItem',),
-    "PySide2.QtMacExtras.QMacToolBar.addItem": ('PySide2.QtGui.QIcon', 'str'),
-    "PySide2.QtMacExtras.QMacToolBar.addSeparator": (),
-    "PySide2.QtMacExtras.QMacToolBar.addStandardItem": ('PySide2.QtMacExtras.QMacToolBarItem.StandardItem',),
-    "PySide2.QtMacExtras.QMacToolBar.allowedItems": (),
-    "PySide2.QtMacExtras.QMacToolBar.attachToWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtMacExtras.QMacToolBar.detachFromWindow": (),
-    "PySide2.QtMacExtras.QMacToolBar.items": (),
-    "PySide2.QtMacExtras.QMacToolBar.setAllowedItems": ('typing.Sequence[PySide2.QtMacExtras.QMacToolBarItem]',),
-    "PySide2.QtMacExtras.QMacToolBar.setItems": ('typing.Sequence[PySide2.QtMacExtras.QMacToolBarItem]',),
-# class PySide2.QtMacExtras.QMacToolBarItem:
-# class PySide2.QtMacExtras.QMacToolBarItem.StandardItem:
-    "PySide2.QtMacExtras.QMacToolBarItem.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMacExtras.QMacToolBarItem.icon": (),
-    "PySide2.QtMacExtras.QMacToolBarItem.selectable": (),
-    "PySide2.QtMacExtras.QMacToolBarItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtMacExtras.QMacToolBarItem.setSelectable": ('bool',),
-    "PySide2.QtMacExtras.QMacToolBarItem.setStandardItem": ('PySide2.QtMacExtras.QMacToolBarItem.StandardItem',),
-    "PySide2.QtMacExtras.QMacToolBarItem.setText": ('str',),
-    "PySide2.QtMacExtras.QMacToolBarItem.standardItem": (),
-    "PySide2.QtMacExtras.QMacToolBarItem.text": (),
-    "PySide2.QtMacExtras.QMacToolBarItem.qRegisterDraggedTypes": ('typing.Sequence[str]',),
-    }) if "PySide2.QtMacExtras" in sys.modules else None
-# Module PySide2.QtXml
-sig_dict.update({
-# class PySide2.QtXml.QDomAttr:
-    "PySide2.QtXml.QDomAttr.__init__": [(), ('PySide2.QtXml.QDomAttr',)],
-    "PySide2.QtXml.QDomAttr.__copy__": (),
-    "PySide2.QtXml.QDomAttr.name": (),
-    "PySide2.QtXml.QDomAttr.nodeType": (),
-    "PySide2.QtXml.QDomAttr.ownerElement": (),
-    "PySide2.QtXml.QDomAttr.setValue": ('str',),
-    "PySide2.QtXml.QDomAttr.specified": (),
-    "PySide2.QtXml.QDomAttr.value": (),
-# class PySide2.QtXml.QDomCDATASection:
-    "PySide2.QtXml.QDomCDATASection.__init__": [(), ('PySide2.QtXml.QDomCDATASection',)],
-    "PySide2.QtXml.QDomCDATASection.__copy__": (),
-    "PySide2.QtXml.QDomCDATASection.nodeType": (),
-# class PySide2.QtXml.QDomCharacterData:
-    "PySide2.QtXml.QDomCharacterData.__init__": [(), ('PySide2.QtXml.QDomCharacterData',)],
-    "PySide2.QtXml.QDomCharacterData.__copy__": (),
-    "PySide2.QtXml.QDomCharacterData.appendData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.data": (),
-    "PySide2.QtXml.QDomCharacterData.deleteData": ('int', 'int'),
-    "PySide2.QtXml.QDomCharacterData.insertData": ('int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.length": (),
-    "PySide2.QtXml.QDomCharacterData.nodeType": (),
-    "PySide2.QtXml.QDomCharacterData.replaceData": ('int', 'int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.setData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.substringData": ('int', 'int'),
-# class PySide2.QtXml.QDomComment:
-    "PySide2.QtXml.QDomComment.__init__": [(), ('PySide2.QtXml.QDomComment',)],
-    "PySide2.QtXml.QDomComment.__copy__": (),
-    "PySide2.QtXml.QDomComment.nodeType": (),
-# class PySide2.QtXml.QDomDocument:
-    "PySide2.QtXml.QDomDocument.__init__": [(), ('PySide2.QtXml.QDomDocument',), ('PySide2.QtXml.QDomDocumentType',), ('str',)],
-    "PySide2.QtXml.QDomDocument.__copy__": (),
-    "PySide2.QtXml.QDomDocument.createAttribute": ('str',),
-    "PySide2.QtXml.QDomDocument.createAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createCDATASection": ('str',),
-    "PySide2.QtXml.QDomDocument.createComment": ('str',),
-    "PySide2.QtXml.QDomDocument.createDocumentFragment": (),
-    "PySide2.QtXml.QDomDocument.createElement": ('str',),
-    "PySide2.QtXml.QDomDocument.createElementNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createEntityReference": ('str',),
-    "PySide2.QtXml.QDomDocument.createProcessingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createTextNode": ('str',),
-    "PySide2.QtXml.QDomDocument.doctype": (),
-    "PySide2.QtXml.QDomDocument.documentElement": (),
-    "PySide2.QtXml.QDomDocument.elementById": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.implementation": (),
-    "PySide2.QtXml.QDomDocument.importNode": ('PySide2.QtXml.QDomNode', 'bool'),
-    "PySide2.QtXml.QDomDocument.nodeType": (),
-    "PySide2.QtXml.QDomDocument.setContent": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'bool'), ('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QIODevice', 'bool'), ('PySide2.QtXml.QXmlInputSource', 'PySide2.QtXml.QXmlReader'), ('PySide2.QtXml.QXmlInputSource', 'bool'), ('str',), ('str', 'bool')],
-    "PySide2.QtXml.QDomDocument.toByteArray": ('int',),
-    "PySide2.QtXml.QDomDocument.toString": ('int',),
-# class PySide2.QtXml.QDomDocumentFragment:
-    "PySide2.QtXml.QDomDocumentFragment.__init__": [(), ('PySide2.QtXml.QDomDocumentFragment',)],
-    "PySide2.QtXml.QDomDocumentFragment.__copy__": (),
-    "PySide2.QtXml.QDomDocumentFragment.nodeType": (),
-# class PySide2.QtXml.QDomDocumentType:
-    "PySide2.QtXml.QDomDocumentType.__init__": [(), ('PySide2.QtXml.QDomDocumentType',)],
-    "PySide2.QtXml.QDomDocumentType.__copy__": (),
-    "PySide2.QtXml.QDomDocumentType.entities": (),
-    "PySide2.QtXml.QDomDocumentType.internalSubset": (),
-    "PySide2.QtXml.QDomDocumentType.name": (),
-    "PySide2.QtXml.QDomDocumentType.nodeType": (),
-    "PySide2.QtXml.QDomDocumentType.notations": (),
-    "PySide2.QtXml.QDomDocumentType.publicId": (),
-    "PySide2.QtXml.QDomDocumentType.systemId": (),
-# class PySide2.QtXml.QDomElement:
-    "PySide2.QtXml.QDomElement.__init__": [(), ('PySide2.QtXml.QDomElement',)],
-    "PySide2.QtXml.QDomElement.__copy__": (),
-    "PySide2.QtXml.QDomElement.attribute": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNS": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNode": ('str',),
-    "PySide2.QtXml.QDomElement.attributeNodeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributes": (),
-    "PySide2.QtXml.QDomElement.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomElement.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.hasAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.hasAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.nodeType": (),
-    "PySide2.QtXml.QDomElement.removeAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.removeAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.removeAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttribute": [('str', 'float'), ('str', 'int'), ('str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNS": [('str', 'str', 'float'), ('str', 'str', 'int'), ('str', 'str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttributeNodeNS": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setTagName": ('str',),
-    "PySide2.QtXml.QDomElement.tagName": (),
-    "PySide2.QtXml.QDomElement.text": (),
-# class PySide2.QtXml.QDomEntity:
-    "PySide2.QtXml.QDomEntity.__init__": [(), ('PySide2.QtXml.QDomEntity',)],
-    "PySide2.QtXml.QDomEntity.__copy__": (),
-    "PySide2.QtXml.QDomEntity.nodeType": (),
-    "PySide2.QtXml.QDomEntity.notationName": (),
-    "PySide2.QtXml.QDomEntity.publicId": (),
-    "PySide2.QtXml.QDomEntity.systemId": (),
-# class PySide2.QtXml.QDomEntityReference:
-    "PySide2.QtXml.QDomEntityReference.__init__": [(), ('PySide2.QtXml.QDomEntityReference',)],
-    "PySide2.QtXml.QDomEntityReference.__copy__": (),
-    "PySide2.QtXml.QDomEntityReference.nodeType": (),
-# class PySide2.QtXml.QDomImplementation:
-# class PySide2.QtXml.QDomImplementation.InvalidDataPolicy:
-    "PySide2.QtXml.QDomImplementation.__init__": [(), ('PySide2.QtXml.QDomImplementation',)],
-    "PySide2.QtXml.QDomImplementation.__copy__": (),
-    "PySide2.QtXml.QDomImplementation.createDocument": ('str', 'str', 'PySide2.QtXml.QDomDocumentType'),
-    "PySide2.QtXml.QDomImplementation.createDocumentType": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomImplementation.hasFeature": ('str', 'str'),
-    "PySide2.QtXml.QDomImplementation.invalidDataPolicy": (),
-    "PySide2.QtXml.QDomImplementation.isNull": (),
-    "PySide2.QtXml.QDomImplementation.setInvalidDataPolicy": ('PySide2.QtXml.QDomImplementation.InvalidDataPolicy',),
-# class PySide2.QtXml.QDomNamedNodeMap:
-    "PySide2.QtXml.QDomNamedNodeMap.__init__": [(), ('PySide2.QtXml.QDomNamedNodeMap',)],
-    "PySide2.QtXml.QDomNamedNodeMap.__copy__": (),
-    "PySide2.QtXml.QDomNamedNodeMap.contains": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.count": (),
-    "PySide2.QtXml.QDomNamedNodeMap.isEmpty": (),
-    "PySide2.QtXml.QDomNamedNodeMap.item": ('int',),
-    "PySide2.QtXml.QDomNamedNodeMap.length": (),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItem": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItemNS": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.size": (),
-# class PySide2.QtXml.QDomNode:
-# class PySide2.QtXml.QDomNode.EncodingPolicy:
-# class PySide2.QtXml.QDomNode.NodeType:
-    "PySide2.QtXml.QDomNode.__init__": [(), ('PySide2.QtXml.QDomNode',)],
-    "PySide2.QtXml.QDomNode.__copy__": (),
-    "PySide2.QtXml.QDomNode.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtXml.QDomNode.appendChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.attributes": (),
-    "PySide2.QtXml.QDomNode.childNodes": (),
-    "PySide2.QtXml.QDomNode.clear": (),
-    "PySide2.QtXml.QDomNode.cloneNode": ('bool',),
-    "PySide2.QtXml.QDomNode.columnNumber": (),
-    "PySide2.QtXml.QDomNode.firstChild": (),
-    "PySide2.QtXml.QDomNode.firstChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.hasAttributes": (),
-    "PySide2.QtXml.QDomNode.hasChildNodes": (),
-    "PySide2.QtXml.QDomNode.insertAfter": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.insertBefore": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.isAttr": (),
-    "PySide2.QtXml.QDomNode.isCDATASection": (),
-    "PySide2.QtXml.QDomNode.isCharacterData": (),
-    "PySide2.QtXml.QDomNode.isComment": (),
-    "PySide2.QtXml.QDomNode.isDocument": (),
-    "PySide2.QtXml.QDomNode.isDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.isDocumentType": (),
-    "PySide2.QtXml.QDomNode.isElement": (),
-    "PySide2.QtXml.QDomNode.isEntity": (),
-    "PySide2.QtXml.QDomNode.isEntityReference": (),
-    "PySide2.QtXml.QDomNode.isNotation": (),
-    "PySide2.QtXml.QDomNode.isNull": (),
-    "PySide2.QtXml.QDomNode.isProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.isSupported": ('str', 'str'),
-    "PySide2.QtXml.QDomNode.isText": (),
-    "PySide2.QtXml.QDomNode.lastChild": (),
-    "PySide2.QtXml.QDomNode.lastChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.lineNumber": (),
-    "PySide2.QtXml.QDomNode.localName": (),
-    "PySide2.QtXml.QDomNode.namedItem": ('str',),
-    "PySide2.QtXml.QDomNode.namespaceURI": (),
-    "PySide2.QtXml.QDomNode.nextSibling": (),
-    "PySide2.QtXml.QDomNode.nextSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.nodeName": (),
-    "PySide2.QtXml.QDomNode.nodeType": (),
-    "PySide2.QtXml.QDomNode.nodeValue": (),
-    "PySide2.QtXml.QDomNode.normalize": (),
-    "PySide2.QtXml.QDomNode.ownerDocument": (),
-    "PySide2.QtXml.QDomNode.parentNode": (),
-    "PySide2.QtXml.QDomNode.prefix": (),
-    "PySide2.QtXml.QDomNode.previousSibling": (),
-    "PySide2.QtXml.QDomNode.previousSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.removeChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.replaceChild": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.save": ('PySide2.QtCore.QTextStream', 'int', 'PySide2.QtXml.QDomNode.EncodingPolicy'),
-    "PySide2.QtXml.QDomNode.setNodeValue": ('str',),
-    "PySide2.QtXml.QDomNode.setPrefix": ('str',),
-    "PySide2.QtXml.QDomNode.toAttr": (),
-    "PySide2.QtXml.QDomNode.toCDATASection": (),
-    "PySide2.QtXml.QDomNode.toCharacterData": (),
-    "PySide2.QtXml.QDomNode.toComment": (),
-    "PySide2.QtXml.QDomNode.toDocument": (),
-    "PySide2.QtXml.QDomNode.toDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.toDocumentType": (),
-    "PySide2.QtXml.QDomNode.toElement": (),
-    "PySide2.QtXml.QDomNode.toEntity": (),
-    "PySide2.QtXml.QDomNode.toEntityReference": (),
-    "PySide2.QtXml.QDomNode.toNotation": (),
-    "PySide2.QtXml.QDomNode.toProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.toText": (),
-# class PySide2.QtXml.QDomNodeList:
-    "PySide2.QtXml.QDomNodeList.__init__": [(), ('PySide2.QtXml.QDomNodeList',)],
-    "PySide2.QtXml.QDomNodeList.__copy__": (),
-    "PySide2.QtXml.QDomNodeList.at": ('int',),
-    "PySide2.QtXml.QDomNodeList.count": (),
-    "PySide2.QtXml.QDomNodeList.isEmpty": (),
-    "PySide2.QtXml.QDomNodeList.item": ('int',),
-    "PySide2.QtXml.QDomNodeList.length": (),
-    "PySide2.QtXml.QDomNodeList.size": (),
-# class PySide2.QtXml.QDomNotation:
-    "PySide2.QtXml.QDomNotation.__init__": [(), ('PySide2.QtXml.QDomNotation',)],
-    "PySide2.QtXml.QDomNotation.__copy__": (),
-    "PySide2.QtXml.QDomNotation.nodeType": (),
-    "PySide2.QtXml.QDomNotation.publicId": (),
-    "PySide2.QtXml.QDomNotation.systemId": (),
-# class PySide2.QtXml.QDomProcessingInstruction:
-    "PySide2.QtXml.QDomProcessingInstruction.__init__": [(), ('PySide2.QtXml.QDomProcessingInstruction',)],
-    "PySide2.QtXml.QDomProcessingInstruction.__copy__": (),
-    "PySide2.QtXml.QDomProcessingInstruction.data": (),
-    "PySide2.QtXml.QDomProcessingInstruction.nodeType": (),
-    "PySide2.QtXml.QDomProcessingInstruction.setData": ('str',),
-    "PySide2.QtXml.QDomProcessingInstruction.target": (),
-# class PySide2.QtXml.QDomText:
-    "PySide2.QtXml.QDomText.__init__": [(), ('PySide2.QtXml.QDomText',)],
-    "PySide2.QtXml.QDomText.__copy__": (),
-    "PySide2.QtXml.QDomText.nodeType": (),
-    "PySide2.QtXml.QDomText.splitText": ('int',),
-# class PySide2.QtXml.QXmlAttributes:
-    "PySide2.QtXml.QXmlAttributes.__init__": [(), ('PySide2.QtXml.QXmlAttributes',)],
-    "PySide2.QtXml.QXmlAttributes.__copy__": (),
-    "PySide2.QtXml.QXmlAttributes.append": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlAttributes.clear": (),
-    "PySide2.QtXml.QXmlAttributes.count": (),
-    "PySide2.QtXml.QXmlAttributes.index": [('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.length": (),
-    "PySide2.QtXml.QXmlAttributes.localName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.qName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.swap": ('PySide2.QtXml.QXmlAttributes',),
-    "PySide2.QtXml.QXmlAttributes.type": [('int',), ('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.uri": ('int',),
-    "PySide2.QtXml.QXmlAttributes.value": [('int',), ('str',), ('str', 'str')],
-# class PySide2.QtXml.QXmlContentHandler:
-    "PySide2.QtXml.QXmlContentHandler.__init__": (),
-    "PySide2.QtXml.QXmlContentHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.endDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.errorString": (),
-    "PySide2.QtXml.QXmlContentHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlContentHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.startDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlContentHandler.startPrefixMapping": ('str', 'str'),
-# class PySide2.QtXml.QXmlDTDHandler:
-    "PySide2.QtXml.QXmlDTDHandler.__init__": (),
-    "PySide2.QtXml.QXmlDTDHandler.errorString": (),
-    "PySide2.QtXml.QXmlDTDHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDTDHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-# class PySide2.QtXml.QXmlDeclHandler:
-    "PySide2.QtXml.QXmlDeclHandler.__init__": (),
-    "PySide2.QtXml.QXmlDeclHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.errorString": (),
-    "PySide2.QtXml.QXmlDeclHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.internalEntityDecl": ('str', 'str'),
-# class PySide2.QtXml.QXmlDefaultHandler:
-    "PySide2.QtXml.QXmlDefaultHandler.__init__": (),
-    "PySide2.QtXml.QXmlDefaultHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDTD": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.errorString": (),
-    "PySide2.QtXml.QXmlDefaultHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.internalEntityDecl": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-    "PySide2.QtXml.QXmlDefaultHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlDefaultHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.startDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlDefaultHandler.startEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startPrefixMapping": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlEntityResolver:
-    "PySide2.QtXml.QXmlEntityResolver.__init__": (),
-    "PySide2.QtXml.QXmlEntityResolver.errorString": (),
-    "PySide2.QtXml.QXmlEntityResolver.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-# class PySide2.QtXml.QXmlErrorHandler:
-    "PySide2.QtXml.QXmlErrorHandler.__init__": (),
-    "PySide2.QtXml.QXmlErrorHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.errorString": (),
-    "PySide2.QtXml.QXmlErrorHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlInputSource:
-    "PySide2.QtXml.QXmlInputSource.__init__": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtXml.QXmlInputSource.data": (),
-    "PySide2.QtXml.QXmlInputSource.fetchData": (),
-    "PySide2.QtXml.QXmlInputSource.fromRawData": ('PySide2.QtCore.QByteArray', 'bool'),
-    "PySide2.QtXml.QXmlInputSource.reset": (),
-    "PySide2.QtXml.QXmlInputSource.setData": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtXml.QXmlLexicalHandler:
-    "PySide2.QtXml.QXmlLexicalHandler.__init__": (),
-    "PySide2.QtXml.QXmlLexicalHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endDTD": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.errorString": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlLexicalHandler.startEntity": ('str',),
-# class PySide2.QtXml.QXmlLocator:
-    "PySide2.QtXml.QXmlLocator.__init__": (),
-    "PySide2.QtXml.QXmlLocator.columnNumber": (),
-    "PySide2.QtXml.QXmlLocator.lineNumber": (),
-# class PySide2.QtXml.QXmlNamespaceSupport:
-    "PySide2.QtXml.QXmlNamespaceSupport.__init__": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.popContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefix": ('str',),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefixes": [(), ('str',)],
-    "PySide2.QtXml.QXmlNamespaceSupport.processName": ('str', 'bool', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.pushContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.reset": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.setPrefix": ('str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.splitName": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.uri": ('str',),
-# class PySide2.QtXml.QXmlParseException:
-    "PySide2.QtXml.QXmlParseException.__init__": [('PySide2.QtXml.QXmlParseException',), ('str', 'int', 'int', 'str', 'str')],
-    "PySide2.QtXml.QXmlParseException.columnNumber": (),
-    "PySide2.QtXml.QXmlParseException.lineNumber": (),
-    "PySide2.QtXml.QXmlParseException.message": (),
-    "PySide2.QtXml.QXmlParseException.publicId": (),
-    "PySide2.QtXml.QXmlParseException.systemId": (),
-# class PySide2.QtXml.QXmlReader:
-    "PySide2.QtXml.QXmlReader.__init__": (),
-    "PySide2.QtXml.QXmlReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlReader.contentHandler": (),
-    "PySide2.QtXml.QXmlReader.declHandler": (),
-    "PySide2.QtXml.QXmlReader.entityResolver": (),
-    "PySide2.QtXml.QXmlReader.errorHandler": (),
-    "PySide2.QtXml.QXmlReader.feature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlReader.parse": ('PySide2.QtXml.QXmlInputSource',),
-    "PySide2.QtXml.QXmlReader.property": ('str',),
-    "PySide2.QtXml.QXmlReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlReader.setProperty": ('str', 'int'),
-# class PySide2.QtXml.QXmlSimpleReader:
-    "PySide2.QtXml.QXmlSimpleReader.__init__": (),
-    "PySide2.QtXml.QXmlSimpleReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.contentHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.declHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.entityResolver": (),
-    "PySide2.QtXml.QXmlSimpleReader.errorHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.feature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.parse": [('PySide2.QtXml.QXmlInputSource',), ('PySide2.QtXml.QXmlInputSource', 'bool')],
-    "PySide2.QtXml.QXmlSimpleReader.parseContinue": (),
-    "PySide2.QtXml.QXmlSimpleReader.property": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlSimpleReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlSimpleReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setProperty": ('str', 'int'),
-    }) if "PySide2.QtXml" in sys.modules else None
-# Module PySide2.QtXmlPatterns
-sig_dict.update({
-# class PySide2.QtXmlPatterns.QAbstractMessageHandler:
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.handleMessage": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.message": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-# class PySide2.QtXmlPatterns.QAbstractUriResolver:
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.resolve": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.NodeCopySetting:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis:
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.attributes": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.baseUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.compareOrder": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.createIndex": [('int',), ('int', 'int')],
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.documentUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.elementById": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.isDeepEqual": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.kind": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.name": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceBindings": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceForPrefix": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode")'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nextFromSimpleAxis": ('PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nodesByIdref": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.root": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sendNamespaces": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QAbstractXmlReceiver'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sourceLocation": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.stringValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.typedValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-# class PySide2.QtXmlPatterns.QAbstractXmlReceiver:
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.characters": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.comment": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endElement": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.whitespaceOnly": ('str',),
-# class PySide2.QtXmlPatterns.QSourceLocation:
-    "PySide2.QtXmlPatterns.QSourceLocation.__init__": [(), ('PySide2.QtCore.QUrl', 'int', 'int'), ('PySide2.QtXmlPatterns.QSourceLocation',)],
-    "PySide2.QtXmlPatterns.QSourceLocation.__copy__": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.column": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.isNull": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.line": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.setColumn": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setLine": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setUri": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtXmlPatterns.QSourceLocation.uri": (),
-# class PySide2.QtXmlPatterns.QXmlFormatter:
-    "PySide2.QtXmlPatterns.QXmlFormatter.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.indentationDepth": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.setIndentationDepth": ('int',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startOfSequence": (),
-# class PySide2.QtXmlPatterns.QXmlItem:
-    "PySide2.QtXmlPatterns.QXmlItem.__init__": [(), ('PySide2.QtXmlPatterns.QXmlItem',), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',), ('typing.Any',)],
-    "PySide2.QtXmlPatterns.QXmlItem.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNode": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toNodeModelIndex": (),
-# class PySide2.QtXmlPatterns.QXmlName:
-    "PySide2.QtXmlPatterns.QXmlName.__init__": [(), ('PySide2.QtXmlPatterns.QXmlName',), ('PySide2.QtXmlPatterns.QXmlNamePool', 'str', 'str', 'str')],
-    "PySide2.QtXmlPatterns.QXmlName.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlName.fromClarkName": ('str', 'PySide2.QtXmlPatterns.QXmlNamePool'),
-    "PySide2.QtXmlPatterns.QXmlName.isNCName": ('str',),
-    "PySide2.QtXmlPatterns.QXmlName.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlName.localName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.namespaceUri": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.prefix": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.toClarkName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-# class PySide2.QtXmlPatterns.QXmlNamePool:
-    "PySide2.QtXmlPatterns.QXmlNamePool.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',)],
-    "PySide2.QtXmlPatterns.QXmlNamePool.__copy__": (),
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.DocumentOrder:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.NodeKind:
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',)],
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.additionalData": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.data": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.internalPointer": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.model": (),
-# class PySide2.QtXmlPatterns.QXmlQuery:
-# class PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage:
-    "PySide2.QtXmlPatterns.QXmlQuery.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',), ('PySide2.QtXmlPatterns.QXmlQuery',), ('PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage', 'PySide2.QtXmlPatterns.QXmlNamePool')],
-    "PySide2.QtXmlPatterns.QXmlQuery.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.bindVariable": [('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtCore.QIODevice'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlItem'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlQuery'), ('str', 'PySide2.QtCore.QIODevice'), ('str', 'PySide2.QtXmlPatterns.QXmlItem'), ('str', 'PySide2.QtXmlPatterns.QXmlQuery')],
-    "PySide2.QtXmlPatterns.QXmlQuery.evaluateTo": [('PySide2.QtCore.QIODevice',), ('PySide2.QtXmlPatterns.QAbstractXmlReceiver',), ('PySide2.QtXmlPatterns.QXmlResultItems',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.initialTemplateName": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.queryLanguage": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.setFocus": [('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QUrl',), ('PySide2.QtXmlPatterns.QXmlItem',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setInitialTemplateName": [('PySide2.QtXmlPatterns.QXmlName',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlQuery.setQuery": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'), ('str', 'PySide2.QtCore.QUrl')],
-    "PySide2.QtXmlPatterns.QXmlQuery.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlQuery.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlResultItems:
-    "PySide2.QtXmlPatterns.QXmlResultItems.__init__": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.current": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.hasError": (),
-# class PySide2.QtXmlPatterns.QXmlSchema:
-    "PySide2.QtXmlPatterns.QXmlSchema.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.documentUri": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.load": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchema.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchema.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlSchemaValidator:
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.schema": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setSchema": ('PySide2.QtXmlPatterns.QXmlSchema',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.uriResolver": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.validate": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-# class PySide2.QtXmlPatterns.QXmlSerializer:
-    "PySide2.QtXmlPatterns.QXmlSerializer.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.codec": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.outputDevice": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startOfSequence": (),
-    }) if "PySide2.QtXmlPatterns" in sys.modules else None
-# Module PySide2.QtHelp
-sig_dict.update({
-# class PySide2.QtHelp.QCompressedHelpInfo:
-    "PySide2.QtHelp.QCompressedHelpInfo.__init__": [(), ('PySide2.QtHelp.QCompressedHelpInfo',)],
-    "PySide2.QtHelp.QCompressedHelpInfo.__copy__": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.component": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.fromCompressedHelpFile": ('str',),
-    "PySide2.QtHelp.QCompressedHelpInfo.namespaceName": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.swap": ('PySide2.QtHelp.QCompressedHelpInfo',),
-    "PySide2.QtHelp.QCompressedHelpInfo.version": (),
-# class PySide2.QtHelp.QHelpContentItem:
-    "PySide2.QtHelp.QHelpContentItem.__copy__": (),
-    "PySide2.QtHelp.QHelpContentItem.child": ('int',),
-    "PySide2.QtHelp.QHelpContentItem.childCount": (),
-    "PySide2.QtHelp.QHelpContentItem.childPosition": ('PySide2.QtHelp.QHelpContentItem',),
-    "PySide2.QtHelp.QHelpContentItem.parent": (),
-    "PySide2.QtHelp.QHelpContentItem.row": (),
-    "PySide2.QtHelp.QHelpContentItem.title": (),
-    "PySide2.QtHelp.QHelpContentItem.url": (),
-# class PySide2.QtHelp.QHelpContentModel:
-    "PySide2.QtHelp.QHelpContentModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.contentItemAt": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.createContents": ('str',),
-    "PySide2.QtHelp.QHelpContentModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtHelp.QHelpContentModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtHelp.QHelpContentModel.isCreatingContents": (),
-    "PySide2.QtHelp.QHelpContentModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtHelp.QHelpContentModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtHelp.QHelpContentWidget:
-    "PySide2.QtHelp.QHelpContentWidget.indexOf": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtHelp.QHelpEngine:
-    "PySide2.QtHelp.QHelpEngine.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngine.contentModel": (),
-    "PySide2.QtHelp.QHelpEngine.contentWidget": (),
-    "PySide2.QtHelp.QHelpEngine.indexModel": (),
-    "PySide2.QtHelp.QHelpEngine.indexWidget": (),
-    "PySide2.QtHelp.QHelpEngine.searchEngine": (),
-# class PySide2.QtHelp.QHelpEngineCore:
-    "PySide2.QtHelp.QHelpEngineCore.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngineCore.addCustomFilter": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtHelp.QHelpEngineCore.autoSaveFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.collectionFile": (),
-    "PySide2.QtHelp.QHelpEngineCore.copyCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.currentFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.customFilters": (),
-    "PySide2.QtHelp.QHelpEngineCore.customValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.documentationFileName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.error": (),
-    "PySide2.QtHelp.QHelpEngineCore.fileData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.files": [('str', 'str', 'str'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributeSets": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributes": [(), ('str',)],
-    "PySide2.QtHelp.QHelpEngineCore.filterEngine": (),
-    "PySide2.QtHelp.QHelpEngineCore.findFile": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForIdentifier": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForKeyword": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.metaData": ('str', 'str'),
-    "PySide2.QtHelp.QHelpEngineCore.namespaceName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registerDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registeredDocumentations": (),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomValue": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setAutoSaveFilter": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCurrentFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCustomValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.setUsesFilterEngine": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setupData": (),
-    "PySide2.QtHelp.QHelpEngineCore.unregisterDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.usesFilterEngine": (),
-# class PySide2.QtHelp.QHelpFilterData:
-    "PySide2.QtHelp.QHelpFilterData.__init__": [(), ('PySide2.QtHelp.QHelpFilterData',)],
-    "PySide2.QtHelp.QHelpFilterData.__copy__": (),
-    "PySide2.QtHelp.QHelpFilterData.components": (),
-    "PySide2.QtHelp.QHelpFilterData.setComponents": ('typing.Sequence[str]',),
-    "PySide2.QtHelp.QHelpFilterData.setVersions": ('typing.Sequence[PySide2.QtCore.QVersionNumber]',),
-    "PySide2.QtHelp.QHelpFilterData.swap": ('PySide2.QtHelp.QHelpFilterData',),
-    "PySide2.QtHelp.QHelpFilterData.versions": (),
-# class PySide2.QtHelp.QHelpFilterEngine:
-    "PySide2.QtHelp.QHelpFilterEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore',),
-    "PySide2.QtHelp.QHelpFilterEngine.activeFilter": (),
-    "PySide2.QtHelp.QHelpFilterEngine.availableComponents": (),
-    "PySide2.QtHelp.QHelpFilterEngine.filterData": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.filters": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToComponent": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToVersion": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespacesForFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.removeFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setActiveFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setFilterData": ('str', 'PySide2.QtHelp.QHelpFilterData'),
-# class PySide2.QtHelp.QHelpIndexModel:
-    "PySide2.QtHelp.QHelpIndexModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object'), ('str',)],
-    "PySide2.QtHelp.QHelpIndexModel.filter": ('str', 'str'),
-    "PySide2.QtHelp.QHelpIndexModel.isCreatingIndex": (),
-    "PySide2.QtHelp.QHelpIndexModel.linksForKeyword": ('str',),
-# class PySide2.QtHelp.QHelpIndexWidget:
-    "PySide2.QtHelp.QHelpIndexWidget.activateCurrentItem": (),
-    "PySide2.QtHelp.QHelpIndexWidget.filterIndices": ('str', 'str'),
-# class PySide2.QtHelp.QHelpSearchEngine:
-    "PySide2.QtHelp.QHelpSearchEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelIndexing": (),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelSearching": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hitCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hits": ('int', 'int'),
-    "PySide2.QtHelp.QHelpSearchEngine.hitsCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.query": (),
-    "PySide2.QtHelp.QHelpSearchEngine.queryWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.reindexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.resultWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.scheduleIndexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.search": [('str',), ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',)],
-    "PySide2.QtHelp.QHelpSearchEngine.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResultCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResults": ('int', 'int'),
-# class PySide2.QtHelp.QHelpSearchQuery:
-# class PySide2.QtHelp.QHelpSearchQuery.FieldName:
-    "PySide2.QtHelp.QHelpSearchQuery.__init__": [(), ('PySide2.QtHelp.QHelpSearchQuery',), ('PySide2.QtHelp.QHelpSearchQuery.FieldName', 'typing.Sequence[str]')],
-    "PySide2.QtHelp.QHelpSearchQuery.__copy__": (),
-# class PySide2.QtHelp.QHelpSearchQueryWidget:
-    "PySide2.QtHelp.QHelpSearchQueryWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.collapseExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.expandExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.isCompactMode": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.query": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setCompactMode": ('bool',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setQuery": ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setSearchInput": ('str',),
-# class PySide2.QtHelp.QHelpSearchResult:
-    "PySide2.QtHelp.QHelpSearchResult.__init__": [(), ('PySide2.QtCore.QUrl', 'str', 'str'), ('PySide2.QtHelp.QHelpSearchResult',)],
-    "PySide2.QtHelp.QHelpSearchResult.snippet": (),
-    "PySide2.QtHelp.QHelpSearchResult.title": (),
-    "PySide2.QtHelp.QHelpSearchResult.url": (),
-# class PySide2.QtHelp.QHelpSearchResultWidget:
-    "PySide2.QtHelp.QHelpSearchResultWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchResultWidget.linkAt": ('PySide2.QtCore.QPoint',),
-    }) if "PySide2.QtHelp" in sys.modules else None
-# Module PySide2.QtMultimedia
-sig_dict.update({
-# class PySide2.QtMultimedia.QAbstractAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAbstractAudioInput:
-    "PySide2.QtMultimedia.QAbstractAudioInput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioInput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAbstractAudioOutput:
-    "PySide2.QtMultimedia.QAbstractAudioOutput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAbstractVideoBuffer:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode:
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.__init__": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handle": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handleType": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.mapMode": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.release": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.unmap": (),
-# class PySide2.QtMultimedia.QAbstractVideoFilter:
-    "PySide2.QtMultimedia.QAbstractVideoFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.createFilterRunnable": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.setActive": ('bool',),
-# class PySide2.QtMultimedia.QAbstractVideoSurface:
-# class PySide2.QtMultimedia.QAbstractVideoSurface.Error:
-    "PySide2.QtMultimedia.QAbstractVideoSurface.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.error": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isFormatSupported": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nativeResolution": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nearestFormat": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.present": ('PySide2.QtMultimedia.QVideoFrame',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setError": ('PySide2.QtMultimedia.QAbstractVideoSurface.Error',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setNativeResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.start": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.stop": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.supportedPixelFormats": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.surfaceFormat": (),
-# class PySide2.QtMultimedia.QAudio:
-# class PySide2.QtMultimedia.QAudio.Error:
-# class PySide2.QtMultimedia.QAudio.Mode:
-# class PySide2.QtMultimedia.QAudio.Role:
-# class PySide2.QtMultimedia.QAudio.State:
-# class PySide2.QtMultimedia.QAudio.VolumeScale:
-    "PySide2.QtMultimedia.QAudio.convertVolume": ('float', 'PySide2.QtMultimedia.QAudio.VolumeScale', 'PySide2.QtMultimedia.QAudio.VolumeScale'),
-# class PySide2.QtMultimedia.QAudioBuffer:
-    "PySide2.QtMultimedia.QAudioBuffer.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtMultimedia.QAudioFormat', 'int'), ('PySide2.QtMultimedia.QAudioBuffer',), ('int', 'PySide2.QtMultimedia.QAudioFormat', 'int')],
-    "PySide2.QtMultimedia.QAudioBuffer.__copy__": (),
-    "PySide2.QtMultimedia.QAudioBuffer.byteCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.constData": (),
-    "PySide2.QtMultimedia.QAudioBuffer.data": (),
-    "PySide2.QtMultimedia.QAudioBuffer.duration": (),
-    "PySide2.QtMultimedia.QAudioBuffer.format": (),
-    "PySide2.QtMultimedia.QAudioBuffer.frameCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.isValid": (),
-    "PySide2.QtMultimedia.QAudioBuffer.sampleCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.startTime": (),
-# class PySide2.QtMultimedia.QAudioDecoder:
-# class PySide2.QtMultimedia.QAudioDecoder.Error:
-# class PySide2.QtMultimedia.QAudioDecoder.State:
-    "PySide2.QtMultimedia.QAudioDecoder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoder.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoder.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoder.error": (),
-    "PySide2.QtMultimedia.QAudioDecoder.errorString": (),
-    "PySide2.QtMultimedia.QAudioDecoder.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QAudioDecoder.position": (),
-    "PySide2.QtMultimedia.QAudioDecoder.read": (),
-    "PySide2.QtMultimedia.QAudioDecoder.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoder.start": (),
-    "PySide2.QtMultimedia.QAudioDecoder.state": (),
-    "PySide2.QtMultimedia.QAudioDecoder.stop": (),
-    "PySide2.QtMultimedia.QAudioDecoder.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QAudioDecoderControl:
-    "PySide2.QtMultimedia.QAudioDecoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.position": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.read": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.start": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.state": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.stop": (),
-# class PySide2.QtMultimedia.QAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__init__": [(), ('PySide2.QtMultimedia.QAudioDeviceInfo',)],
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__copy__": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.availableDevices": ('PySide2.QtMultimedia.QAudio.Mode',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultInputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultOutputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isNull": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.nearestFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.realm": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAudioEncoderSettings:
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QAudioEncoderSettings',)],
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.channelCount": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setSampleRate": ('int',),
-# class PySide2.QtMultimedia.QAudioEncoderSettingsControl:
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.audioSettings": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.codecDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.supportedAudioCodecs": (),
-# class PySide2.QtMultimedia.QAudioFormat:
-# class PySide2.QtMultimedia.QAudioFormat.Endian:
-# class PySide2.QtMultimedia.QAudioFormat.SampleType:
-    "PySide2.QtMultimedia.QAudioFormat.__init__": [(), ('PySide2.QtMultimedia.QAudioFormat',)],
-    "PySide2.QtMultimedia.QAudioFormat.__copy__": (),
-    "PySide2.QtMultimedia.QAudioFormat.byteOrder": (),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesPerFrame": (),
-    "PySide2.QtMultimedia.QAudioFormat.channelCount": (),
-    "PySide2.QtMultimedia.QAudioFormat.codec": (),
-    "PySide2.QtMultimedia.QAudioFormat.durationForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.durationForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.isValid": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleSize": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleType": (),
-    "PySide2.QtMultimedia.QAudioFormat.setByteOrder": ('PySide2.QtMultimedia.QAudioFormat.Endian',),
-    "PySide2.QtMultimedia.QAudioFormat.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleSize": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleType": ('PySide2.QtMultimedia.QAudioFormat.SampleType',),
-# class PySide2.QtMultimedia.QAudioInput:
-    "PySide2.QtMultimedia.QAudioInput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.error": (),
-    "PySide2.QtMultimedia.QAudioInput.format": (),
-    "PySide2.QtMultimedia.QAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioInput.state": (),
-    "PySide2.QtMultimedia.QAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAudioInputSelectorControl:
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.activeInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.availableInputs": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.defaultInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.inputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.setActiveInput": ('str',),
-# class PySide2.QtMultimedia.QAudioOutput:
-    "PySide2.QtMultimedia.QAudioOutput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAudioOutputSelectorControl:
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.activeOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.availableOutputs": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.defaultOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.outputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.setActiveOutput": ('str',),
-# class PySide2.QtMultimedia.QAudioProbe:
-    "PySide2.QtMultimedia.QAudioProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioProbe.isActive": (),
-    "PySide2.QtMultimedia.QAudioProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QAudioRecorder:
-    "PySide2.QtMultimedia.QAudioRecorder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputs": (),
-    "PySide2.QtMultimedia.QAudioRecorder.defaultAudioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.setAudioInput": ('str',),
-# class PySide2.QtMultimedia.QAudioRoleControl:
-    "PySide2.QtMultimedia.QAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRoleControl.audioRole": (),
-    "PySide2.QtMultimedia.QAudioRoleControl.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QAudioRoleControl.supportedAudioRoles": (),
-# class PySide2.QtMultimedia.QCamera:
-# class PySide2.QtMultimedia.QCamera.CaptureMode:
-# class PySide2.QtMultimedia.QCamera.CaptureModes:
-# class PySide2.QtMultimedia.QCamera.Error:
-# class PySide2.QtMultimedia.QCamera.FrameRateRange:
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__init__": [(), ('PySide2.QtMultimedia.QCamera.FrameRateRange',), ('float', 'float')],
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__copy__": (),
-# class PySide2.QtMultimedia.QCamera.LockChangeReason:
-# class PySide2.QtMultimedia.QCamera.LockStatus:
-# class PySide2.QtMultimedia.QCamera.LockType:
-# class PySide2.QtMultimedia.QCamera.LockTypes:
-# class PySide2.QtMultimedia.QCamera.Position:
-# class PySide2.QtMultimedia.QCamera.State:
-# class PySide2.QtMultimedia.QCamera.Status:
-    "PySide2.QtMultimedia.QCamera.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QCamera.Position', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QCameraInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QCamera.availability": (),
-    "PySide2.QtMultimedia.QCamera.availableDevices": (),
-    "PySide2.QtMultimedia.QCamera.captureMode": (),
-    "PySide2.QtMultimedia.QCamera.deviceDescription": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QCamera.error": (),
-    "PySide2.QtMultimedia.QCamera.errorString": (),
-    "PySide2.QtMultimedia.QCamera.exposure": (),
-    "PySide2.QtMultimedia.QCamera.focus": (),
-    "PySide2.QtMultimedia.QCamera.imageProcessing": (),
-    "PySide2.QtMultimedia.QCamera.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.load": (),
-    "PySide2.QtMultimedia.QCamera.lockStatus": [(), ('PySide2.QtMultimedia.QCamera.LockType',)],
-    "PySide2.QtMultimedia.QCamera.requestedLocks": (),
-    "PySide2.QtMultimedia.QCamera.searchAndLock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.setViewfinder": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QCamera.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.start": (),
-    "PySide2.QtMultimedia.QCamera.state": (),
-    "PySide2.QtMultimedia.QCamera.status": (),
-    "PySide2.QtMultimedia.QCamera.stop": (),
-    "PySide2.QtMultimedia.QCamera.supportedLocks": (),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderFrameRateRanges": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderPixelFormats": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderResolutions": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.unload": (),
-    "PySide2.QtMultimedia.QCamera.unlock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraCaptureBufferFormatControl:
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.supportedBufferFormats": (),
-# class PySide2.QtMultimedia.QCameraCaptureDestinationControl:
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-# class PySide2.QtMultimedia.QCameraControl:
-# class PySide2.QtMultimedia.QCameraControl.PropertyChangeType:
-    "PySide2.QtMultimedia.QCameraControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraControl.canChangeProperty": ('PySide2.QtMultimedia.QCameraControl.PropertyChangeType', 'PySide2.QtMultimedia.QCamera.Status'),
-    "PySide2.QtMultimedia.QCameraControl.captureMode": (),
-    "PySide2.QtMultimedia.QCameraControl.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setState": ('PySide2.QtMultimedia.QCamera.State',),
-    "PySide2.QtMultimedia.QCameraControl.state": (),
-    "PySide2.QtMultimedia.QCameraControl.status": (),
-# class PySide2.QtMultimedia.QCameraExposure:
-# class PySide2.QtMultimedia.QCameraExposure.ExposureMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashModes:
-# class PySide2.QtMultimedia.QCameraExposure.MeteringMode:
-    "PySide2.QtMultimedia.QCameraExposure.aperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureCompensation": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.flashMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraExposure.isExposureModeSupported": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraExposure.isMeteringModeSupported": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.meteringMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureCompensation": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureMode": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualAperture": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualIsoSensitivity": ('int',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualShutterSpeed": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setMeteringMode": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setSpotMeteringPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraExposure.shutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.spotMeteringPoint": (),
-# class PySide2.QtMultimedia.QCameraExposureControl:
-# class PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter:
-    "PySide2.QtMultimedia.QCameraExposureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraExposureControl.actualValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.requestedValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.setValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraFeedbackControl:
-# class PySide2.QtMultimedia.QCameraFeedbackControl.EventType:
-    "PySide2.QtMultimedia.QCameraFeedbackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackLocked": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.resetEventFeedback": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'bool'),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackSound": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'str'),
-# class PySide2.QtMultimedia.QCameraFlashControl:
-    "PySide2.QtMultimedia.QCameraFlashControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFlashControl.flashMode": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-# class PySide2.QtMultimedia.QCameraFocus:
-# class PySide2.QtMultimedia.QCameraFocus.FocusMode:
-# class PySide2.QtMultimedia.QCameraFocus.FocusModes:
-# class PySide2.QtMultimedia.QCameraFocus.FocusPointMode:
-    "PySide2.QtMultimedia.QCameraFocus.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocus.digitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocus.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.opticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCameraFocusControl:
-    "PySide2.QtMultimedia.QCameraFocusControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFocusControl.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-# class PySide2.QtMultimedia.QCameraFocusZone:
-# class PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus:
-    "PySide2.QtMultimedia.QCameraFocusZone.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus'), ('PySide2.QtMultimedia.QCameraFocusZone',)],
-    "PySide2.QtMultimedia.QCameraFocusZone.__copy__": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.area": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.isValid": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.setStatus": ('PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus',),
-    "PySide2.QtMultimedia.QCameraFocusZone.status": (),
-# class PySide2.QtMultimedia.QCameraImageCapture:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestination:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations:
-# class PySide2.QtMultimedia.QCameraImageCapture.DriveMode:
-# class PySide2.QtMultimedia.QCameraImageCapture.Error:
-    "PySide2.QtMultimedia.QCameraImageCapture.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QCameraImageCapture.availability": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.encodingSettings": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.error": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.errorString": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.mediaObject": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setEncodingSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedBufferFormats": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QCameraImageCaptureControl:
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.driveMode": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.setDriveMode": ('PySide2.QtMultimedia.QCameraImageCapture.DriveMode',),
-# class PySide2.QtMultimedia.QCameraImageProcessing:
-# class PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter:
-# class PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode:
-    "PySide2.QtMultimedia.QCameraImageProcessing.brightness": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.colorFilter": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.contrast": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.denoisingLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isColorFilterSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isWhiteBalanceModeSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.manualWhiteBalance": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.saturation": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setBrightness": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setColorFilter": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setContrast": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setDenoisingLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setManualWhiteBalance": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSaturation": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSharpeningLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setWhiteBalanceMode": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.sharpeningLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.whiteBalanceMode": (),
-# class PySide2.QtMultimedia.QCameraImageProcessingControl:
-# class PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter:
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterValueSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.parameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.setParameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraInfo:
-    "PySide2.QtMultimedia.QCameraInfo.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera',), ('PySide2.QtMultimedia.QCameraInfo',)],
-    "PySide2.QtMultimedia.QCameraInfo.__copy__": (),
-    "PySide2.QtMultimedia.QCameraInfo.availableCameras": ('PySide2.QtMultimedia.QCamera.Position',),
-    "PySide2.QtMultimedia.QCameraInfo.defaultCamera": (),
-    "PySide2.QtMultimedia.QCameraInfo.description": (),
-    "PySide2.QtMultimedia.QCameraInfo.deviceName": (),
-    "PySide2.QtMultimedia.QCameraInfo.isNull": (),
-    "PySide2.QtMultimedia.QCameraInfo.orientation": (),
-    "PySide2.QtMultimedia.QCameraInfo.position": (),
-# class PySide2.QtMultimedia.QCameraInfoControl:
-    "PySide2.QtMultimedia.QCameraInfoControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraOrientation": ('str',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraPosition": ('str',),
-# class PySide2.QtMultimedia.QCameraLocksControl:
-    "PySide2.QtMultimedia.QCameraLocksControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraLocksControl.lockStatus": ('PySide2.QtMultimedia.QCamera.LockType',),
-    "PySide2.QtMultimedia.QCameraLocksControl.searchAndLock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-    "PySide2.QtMultimedia.QCameraLocksControl.supportedLocks": (),
-    "PySide2.QtMultimedia.QCameraLocksControl.unlock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettings:
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__init__": [(), ('PySide2.QtMultimedia.QCameraViewfinderSettings',)],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.isNull": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.maximumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.minimumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelFormat": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.resolution": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMaximumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMinimumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.swap": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl:
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.isViewfinderParameterSupported": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.setViewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.viewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl2:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.supportedViewfinderSettings": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraZoomControl:
-    "PySide2.QtMultimedia.QCameraZoomControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCustomAudioRoleControl:
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.customAudioRole": (),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.supportedCustomAudioRoles": (),
-# class PySide2.QtMultimedia.QImageEncoderControl:
-    "PySide2.QtMultimedia.QImageEncoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageSettings": (),
-    "PySide2.QtMultimedia.QImageEncoderControl.setImageSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QImageEncoderControl.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QImageEncoderSettings:
-    "PySide2.QtMultimedia.QImageEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QImageEncoderSettings',)],
-    "PySide2.QtMultimedia.QImageEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QMediaAudioProbeControl:
-    "PySide2.QtMultimedia.QMediaAudioProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaAvailabilityControl:
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.availability": (),
-# class PySide2.QtMultimedia.QMediaBindableInterface:
-    "PySide2.QtMultimedia.QMediaBindableInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimedia.QMediaContainerControl:
-    "PySide2.QtMultimedia.QMediaContainerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaContainerControl.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.supportedContainers": (),
-# class PySide2.QtMultimedia.QMediaContent:
-    "PySide2.QtMultimedia.QMediaContent.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtMultimedia.QMediaContent',), ('PySide2.QtMultimedia.QMediaPlaylist', 'PySide2.QtCore.QUrl', 'bool'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest',), ('typing.Sequence[PySide2.QtMultimedia.QMediaResource]',)],
-    "PySide2.QtMultimedia.QMediaContent.__copy__": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalRequest": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalResource": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalUrl": (),
-    "PySide2.QtMultimedia.QMediaContent.isNull": (),
-    "PySide2.QtMultimedia.QMediaContent.playlist": (),
-    "PySide2.QtMultimedia.QMediaContent.request": (),
-    "PySide2.QtMultimedia.QMediaContent.resources": (),
-# class PySide2.QtMultimedia.QMediaControl:
-    "PySide2.QtMultimedia.QMediaControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaGaplessPlaybackControl:
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.crossfadeTime": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.isCrossfadeSupported": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.nextMedia": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setCrossfadeTime": ('float',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setNextMedia": ('PySide2.QtMultimedia.QMediaContent',),
-# class PySide2.QtMultimedia.QMediaNetworkAccessControl:
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.currentConfiguration": (),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.setConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-# class PySide2.QtMultimedia.QMediaObject:
-    "PySide2.QtMultimedia.QMediaObject.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaService'),
-    "PySide2.QtMultimedia.QMediaObject.addPropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.availability": (),
-    "PySide2.QtMultimedia.QMediaObject.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaObject.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaObject.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaObject.notifyInterval": (),
-    "PySide2.QtMultimedia.QMediaObject.removePropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.service": (),
-    "PySide2.QtMultimedia.QMediaObject.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QMediaObject.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaPlayer:
-# class PySide2.QtMultimedia.QMediaPlayer.Error:
-# class PySide2.QtMultimedia.QMediaPlayer.Flag:
-# class PySide2.QtMultimedia.QMediaPlayer.Flags:
-# class PySide2.QtMultimedia.QMediaPlayer.MediaStatus:
-# class PySide2.QtMultimedia.QMediaPlayer.State:
-    "PySide2.QtMultimedia.QMediaPlayer.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.audioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.availability": (),
-    "PySide2.QtMultimedia.QMediaPlayer.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentNetworkConfiguration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.customAudioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.error": (),
-    "PySide2.QtMultimedia.QMediaPlayer.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlayer.hasSupport": ('str', 'typing.Sequence[str]', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.media": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayer.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayer.play": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playlist": (),
-    "PySide2.QtMultimedia.QMediaPlayer.position": (),
-    "PySide2.QtMultimedia.QMediaPlayer.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QMediaPlayer.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QMediaPlayer.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayer.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayer.setNetworkConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaylist": ('PySide2.QtMultimedia.QMediaPlaylist',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.setVideoOutput": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QMediaPlayer.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.state": (),
-    "PySide2.QtMultimedia.QMediaPlayer.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedCustomAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedMimeTypes": ('PySide2.QtMultimedia.QMediaPlayer.Flags',),
-    "PySide2.QtMultimedia.QMediaPlayer.unbind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.volume": (),
-# class PySide2.QtMultimedia.QMediaPlayerControl:
-    "PySide2.QtMultimedia.QMediaPlayerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.availablePlaybackRanges": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.media": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.play": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.position": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.state": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.volume": (),
-# class PySide2.QtMultimedia.QMediaPlaylist:
-# class PySide2.QtMultimedia.QMediaPlaylist.Error:
-# class PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode:
-    "PySide2.QtMultimedia.QMediaPlaylist.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.addMedia": [('PySide2.QtMultimedia.QMediaContent',), ('typing.Sequence[PySide2.QtMultimedia.QMediaContent]',)],
-    "PySide2.QtMultimedia.QMediaPlaylist.clear": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentIndex": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.error": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.insertMedia": [('int', 'PySide2.QtMultimedia.QMediaContent'), ('int', 'typing.Sequence[PySide2.QtMultimedia.QMediaContent]')],
-    "PySide2.QtMultimedia.QMediaPlaylist.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.isReadOnly": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.load": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.media": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaCount": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.moveMedia": ('int', 'int'),
-    "PySide2.QtMultimedia.QMediaPlaylist.nextIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.playbackMode": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previous": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previousIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.removeMedia": [('int',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaPlaylist.save": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.setCurrentIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setPlaybackMode": ('PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode',),
-    "PySide2.QtMultimedia.QMediaPlaylist.shuffle": (),
-# class PySide2.QtMultimedia.QMediaRecorder:
-# class PySide2.QtMultimedia.QMediaRecorder.Error:
-# class PySide2.QtMultimedia.QMediaRecorder.State:
-# class PySide2.QtMultimedia.QMediaRecorder.Status:
-    "PySide2.QtMultimedia.QMediaRecorder.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QMediaRecorder.actualLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.audioCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.audioSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availability": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaRecorder.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaRecorder.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorder.error": (),
-    "PySide2.QtMultimedia.QMediaRecorder.errorString": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataWritable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorder.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaRecorder.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.pause": (),
-    "PySide2.QtMultimedia.QMediaRecorder.record": (),
-    "PySide2.QtMultimedia.QMediaRecorder.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.setEncodingSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings', 'PySide2.QtMultimedia.QVideoEncoderSettings', 'str'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaRecorder.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorder.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorder.state": (),
-    "PySide2.QtMultimedia.QMediaRecorder.status": (),
-    "PySide2.QtMultimedia.QMediaRecorder.stop": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedAudioCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedContainers": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.videoSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.volume": (),
-# class PySide2.QtMultimedia.QMediaRecorderControl:
-    "PySide2.QtMultimedia.QMediaRecorderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.applySettings": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setState": ('PySide2.QtMultimedia.QMediaRecorder.State',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.state": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.status": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.volume": (),
-# class PySide2.QtMultimedia.QMediaResource:
-    "PySide2.QtMultimedia.QMediaResource.__init__": [(), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaResource.__copy__": (),
-    "PySide2.QtMultimedia.QMediaResource.audioBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.audioCodec": (),
-    "PySide2.QtMultimedia.QMediaResource.channelCount": (),
-    "PySide2.QtMultimedia.QMediaResource.dataSize": (),
-    "PySide2.QtMultimedia.QMediaResource.isNull": (),
-    "PySide2.QtMultimedia.QMediaResource.language": (),
-    "PySide2.QtMultimedia.QMediaResource.mimeType": (),
-    "PySide2.QtMultimedia.QMediaResource.request": (),
-    "PySide2.QtMultimedia.QMediaResource.resolution": (),
-    "PySide2.QtMultimedia.QMediaResource.sampleRate": (),
-    "PySide2.QtMultimedia.QMediaResource.setAudioBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setAudioCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setDataSize": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setLanguage": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaResource.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.url": (),
-    "PySide2.QtMultimedia.QMediaResource.videoBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.videoCodec": (),
-# class PySide2.QtMultimedia.QMediaService:
-    "PySide2.QtMultimedia.QMediaService.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaService.releaseControl": ('PySide2.QtMultimedia.QMediaControl',),
-    "PySide2.QtMultimedia.QMediaService.requestControl": ('str',),
-# class PySide2.QtMultimedia.QMediaServiceCameraInfoInterface:
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraOrientation": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraPosition": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface:
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.defaultDevice": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceFeaturesInterface:
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.supportedFeatures": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceProviderHint:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Feature:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Features:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Type:
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera.Position',), ('PySide2.QtMultimedia.QMediaServiceProviderHint',), ('PySide2.QtMultimedia.QMediaServiceProviderHint.Features',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__copy__": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.cameraPosition": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.codecs": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.device": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.features": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.isNull": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.mimeType": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.type": (),
-# class PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.deviceDescription": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.devices": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.supportedMimeTypes": (),
-# class PySide2.QtMultimedia.QMediaStreamsControl:
-# class PySide2.QtMultimedia.QMediaStreamsControl.StreamType:
-    "PySide2.QtMultimedia.QMediaStreamsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.isActive": ('int',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.metaData": ('int', 'str'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.setActive": ('int', 'bool'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamCount": (),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamType": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeInterval:
-    "PySide2.QtMultimedia.QMediaTimeInterval.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeInterval.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeInterval.end": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.isNormal": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.normalized": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.start": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.translated": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeRange:
-    "PySide2.QtMultimedia.QMediaTimeRange.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.__add__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.__iadd__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__isub__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__sub__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.addInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.addTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.clear": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeRange.earliestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.intervals": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isContinuous": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.latestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.removeInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.removeTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-# class PySide2.QtMultimedia.QMediaVideoProbeControl:
-    "PySide2.QtMultimedia.QMediaVideoProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMetaDataReaderControl:
-    "PySide2.QtMultimedia.QMetaDataReaderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.metaData": ('str',),
-# class PySide2.QtMultimedia.QMetaDataWriterControl:
-    "PySide2.QtMultimedia.QMetaDataWriterControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isWritable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.metaData": ('str',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.setMetaData": ('str', 'typing.Any'),
-# class PySide2.QtMultimedia.QMultimedia:
-# class PySide2.QtMultimedia.QMultimedia.AvailabilityStatus:
-# class PySide2.QtMultimedia.QMultimedia.EncodingMode:
-# class PySide2.QtMultimedia.QMultimedia.EncodingQuality:
-# class PySide2.QtMultimedia.QMultimedia.SupportEstimate:
-# class PySide2.QtMultimedia.QRadioData:
-# class PySide2.QtMultimedia.QRadioData.Error:
-# class PySide2.QtMultimedia.QRadioData.ProgramType:
-    "PySide2.QtMultimedia.QRadioData.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QRadioData.availability": (),
-    "PySide2.QtMultimedia.QRadioData.error": (),
-    "PySide2.QtMultimedia.QRadioData.errorString": (),
-    "PySide2.QtMultimedia.QRadioData.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioData.mediaObject": (),
-    "PySide2.QtMultimedia.QRadioData.programType": (),
-    "PySide2.QtMultimedia.QRadioData.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioData.radioText": (),
-    "PySide2.QtMultimedia.QRadioData.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioData.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QRadioData.stationId": (),
-    "PySide2.QtMultimedia.QRadioData.stationName": (),
-# class PySide2.QtMultimedia.QRadioDataControl:
-    "PySide2.QtMultimedia.QRadioDataControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioDataControl.error": (),
-    "PySide2.QtMultimedia.QRadioDataControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioDataControl.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programType": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioDataControl.radioText": (),
-    "PySide2.QtMultimedia.QRadioDataControl.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioDataControl.stationId": (),
-    "PySide2.QtMultimedia.QRadioDataControl.stationName": (),
-# class PySide2.QtMultimedia.QRadioTuner:
-# class PySide2.QtMultimedia.QRadioTuner.Band:
-# class PySide2.QtMultimedia.QRadioTuner.Error:
-# class PySide2.QtMultimedia.QRadioTuner.SearchMode:
-# class PySide2.QtMultimedia.QRadioTuner.State:
-# class PySide2.QtMultimedia.QRadioTuner.StereoMode:
-    "PySide2.QtMultimedia.QRadioTuner.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTuner.availability": (),
-    "PySide2.QtMultimedia.QRadioTuner.band": (),
-    "PySide2.QtMultimedia.QRadioTuner.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTuner.error": (),
-    "PySide2.QtMultimedia.QRadioTuner.errorString": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequency": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTuner.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTuner.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTuner.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTuner.radioData": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTuner.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTuner.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTuner.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTuner.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTuner.start": (),
-    "PySide2.QtMultimedia.QRadioTuner.state": (),
-    "PySide2.QtMultimedia.QRadioTuner.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTuner.stop": (),
-    "PySide2.QtMultimedia.QRadioTuner.volume": (),
-# class PySide2.QtMultimedia.QRadioTunerControl:
-    "PySide2.QtMultimedia.QRadioTunerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTunerControl.band": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.error": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequency": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.start": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.state": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stop": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.volume": (),
-# class PySide2.QtMultimedia.QSound:
-# class PySide2.QtMultimedia.QSound.Loop:
-    "PySide2.QtMultimedia.QSound.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QSound.fileName": (),
-    "PySide2.QtMultimedia.QSound.isFinished": (),
-    "PySide2.QtMultimedia.QSound.loops": (),
-    "PySide2.QtMultimedia.QSound.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSound.play": [(), ('str',)],
-    "PySide2.QtMultimedia.QSound.setLoops": ('int',),
-    "PySide2.QtMultimedia.QSound.stop": (),
-# class PySide2.QtMultimedia.QSoundEffect:
-# class PySide2.QtMultimedia.QSoundEffect.Loop:
-# class PySide2.QtMultimedia.QSoundEffect.Status:
-    "PySide2.QtMultimedia.QSoundEffect.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QSoundEffect.category": (),
-    "PySide2.QtMultimedia.QSoundEffect.isLoaded": (),
-    "PySide2.QtMultimedia.QSoundEffect.isMuted": (),
-    "PySide2.QtMultimedia.QSoundEffect.isPlaying": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopCount": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSoundEffect.play": (),
-    "PySide2.QtMultimedia.QSoundEffect.setCategory": ('str',),
-    "PySide2.QtMultimedia.QSoundEffect.setLoopCount": ('int',),
-    "PySide2.QtMultimedia.QSoundEffect.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QSoundEffect.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QSoundEffect.setVolume": ('float',),
-    "PySide2.QtMultimedia.QSoundEffect.source": (),
-    "PySide2.QtMultimedia.QSoundEffect.status": (),
-    "PySide2.QtMultimedia.QSoundEffect.stop": (),
-    "PySide2.QtMultimedia.QSoundEffect.supportedMimeTypes": (),
-    "PySide2.QtMultimedia.QSoundEffect.volume": (),
-# class PySide2.QtMultimedia.QVideoDeviceSelectorControl:
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.defaultDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceCount": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceDescription": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceName": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.selectedDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.setSelectedDevice": ('int',),
-# class PySide2.QtMultimedia.QVideoEncoderSettings:
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QVideoEncoderSettings',)],
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.frameRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QVideoEncoderSettingsControl:
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoSettings": (),
-# class PySide2.QtMultimedia.QVideoFilterRunnable:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlag:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags:
-    "PySide2.QtMultimedia.QVideoFilterRunnable.__init__": (),
-    "PySide2.QtMultimedia.QVideoFilterRunnable.run": ('PySide2.QtMultimedia.QVideoFrame', 'PySide2.QtMultimedia.QVideoSurfaceFormat', 'PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags'),
-# class PySide2.QtMultimedia.QVideoFrame:
-# class PySide2.QtMultimedia.QVideoFrame.FieldType:
-# class PySide2.QtMultimedia.QVideoFrame.PixelFormat:
-    "PySide2.QtMultimedia.QVideoFrame.__init__": [(), ('PySide2.QtGui.QImage',), ('PySide2.QtMultimedia.QAbstractVideoBuffer', 'PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat'), ('PySide2.QtMultimedia.QVideoFrame',), ('int', 'PySide2.QtCore.QSize', 'int', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat')],
-    "PySide2.QtMultimedia.QVideoFrame.__copy__": (),
-    "PySide2.QtMultimedia.QVideoFrame.availableMetaData": (),
-    "PySide2.QtMultimedia.QVideoFrame.bits": (),
-    "PySide2.QtMultimedia.QVideoFrame.buffer": (),
-    "PySide2.QtMultimedia.QVideoFrame.bytesPerLine": [(), ('int',)],
-    "PySide2.QtMultimedia.QVideoFrame.endTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.fieldType": (),
-    "PySide2.QtMultimedia.QVideoFrame.handle": (),
-    "PySide2.QtMultimedia.QVideoFrame.handleType": (),
-    "PySide2.QtMultimedia.QVideoFrame.height": (),
-    "PySide2.QtMultimedia.QVideoFrame.imageFormatFromPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QVideoFrame.isMapped": (),
-    "PySide2.QtMultimedia.QVideoFrame.isReadable": (),
-    "PySide2.QtMultimedia.QVideoFrame.isValid": (),
-    "PySide2.QtMultimedia.QVideoFrame.isWritable": (),
-    "PySide2.QtMultimedia.QVideoFrame.map": ('PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode',),
-    "PySide2.QtMultimedia.QVideoFrame.mapMode": (),
-    "PySide2.QtMultimedia.QVideoFrame.mappedBytes": (),
-    "PySide2.QtMultimedia.QVideoFrame.metaData": ('str',),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormatFromImageFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtMultimedia.QVideoFrame.planeCount": (),
-    "PySide2.QtMultimedia.QVideoFrame.setEndTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.setFieldType": ('PySide2.QtMultimedia.QVideoFrame.FieldType',),
-    "PySide2.QtMultimedia.QVideoFrame.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoFrame.setStartTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.size": (),
-    "PySide2.QtMultimedia.QVideoFrame.startTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.unmap": (),
-    "PySide2.QtMultimedia.QVideoFrame.width": (),
-# class PySide2.QtMultimedia.QVideoProbe:
-    "PySide2.QtMultimedia.QVideoProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoProbe.isActive": (),
-    "PySide2.QtMultimedia.QVideoProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QVideoRendererControl:
-    "PySide2.QtMultimedia.QVideoRendererControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoRendererControl.setSurface": ('PySide2.QtMultimedia.QAbstractVideoSurface',),
-    "PySide2.QtMultimedia.QVideoRendererControl.surface": (),
-# class PySide2.QtMultimedia.QVideoSurfaceFormat:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.Direction:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace:
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat', 'PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType'), ('PySide2.QtMultimedia.QVideoSurfaceFormat',)],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__copy__": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameHeight": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameRate": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameSize": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameWidth": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.handleType": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isMirrored": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isValid": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.property": ('str',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.propertyNames": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.scanLineDirection": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setMirrored": ('bool',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setScanLineDirection": ('PySide2.QtMultimedia.QVideoSurfaceFormat.Direction',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setYCbCrColorSpace": ('PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.sizeHint": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.viewport": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.yCbCrColorSpace": (),
-# class PySide2.QtMultimedia.QVideoWindowControl:
-    "PySide2.QtMultimedia.QVideoWindowControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoWindowControl.aspectRatioMode": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.brightness": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.contrast": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.displayRect": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.hue": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.isFullScreen": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.nativeSize": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.repaint": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.saturation": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setBrightness": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setContrast": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setDisplayRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setHue": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setSaturation": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setWinId": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.winId": (),
-    }) if "PySide2.QtMultimedia" in sys.modules else None
-# Module PySide2.QtMultimediaWidgets
-sig_dict.update({
-# class PySide2.QtMultimediaWidgets.QCameraViewfinder:
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimediaWidgets.QGraphicsVideoItem:
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.boundingRect": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.nativeSize": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.offset": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.size": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtMultimediaWidgets.QVideoWidget:
-    "PySide2.QtMultimediaWidgets.QVideoWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.sizeHint": (),
-# class PySide2.QtMultimediaWidgets.QVideoWidgetControl:
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.isFullScreen": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.videoWidget": (),
-    }) if "PySide2.QtMultimediaWidgets" in sys.modules else None
-# Module PySide2.QtOpenGL
-sig_dict.update({
-# class PySide2.QtOpenGL.QGL:
-# class PySide2.QtOpenGL.QGL.FormatOption:
-# class PySide2.QtOpenGL.QGL.FormatOptions:
-# class PySide2.QtOpenGL.QGLBuffer:
-# class PySide2.QtOpenGL.QGLBuffer.Access:
-# class PySide2.QtOpenGL.QGLBuffer.Type:
-# class PySide2.QtOpenGL.QGLBuffer.UsagePattern:
-    "PySide2.QtOpenGL.QGLBuffer.__init__": [(), ('PySide2.QtOpenGL.QGLBuffer',), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLBuffer.bind": (),
-    "PySide2.QtOpenGL.QGLBuffer.bufferId": (),
-    "PySide2.QtOpenGL.QGLBuffer.create": (),
-    "PySide2.QtOpenGL.QGLBuffer.destroy": (),
-    "PySide2.QtOpenGL.QGLBuffer.isCreated": (),
-    "PySide2.QtOpenGL.QGLBuffer.map": ('PySide2.QtOpenGL.QGLBuffer.Access',),
-    "PySide2.QtOpenGL.QGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLBuffer.release": [(), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.setUsagePattern": ('PySide2.QtOpenGL.QGLBuffer.UsagePattern',),
-    "PySide2.QtOpenGL.QGLBuffer.size": (),
-    "PySide2.QtOpenGL.QGLBuffer.type": (),
-    "PySide2.QtOpenGL.QGLBuffer.unmap": (),
-    "PySide2.QtOpenGL.QGLBuffer.usagePattern": (),
-    "PySide2.QtOpenGL.QGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtOpenGL.QGLColormap:
-    "PySide2.QtOpenGL.QGLColormap.__init__": [(), ('PySide2.QtOpenGL.QGLColormap',)],
-    "PySide2.QtOpenGL.QGLColormap.__copy__": (),
-    "PySide2.QtOpenGL.QGLColormap.entryColor": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.entryRgb": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.find": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.findNearest": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.handle": (),
-    "PySide2.QtOpenGL.QGLColormap.isEmpty": (),
-    "PySide2.QtOpenGL.QGLColormap.setEntry": [('int', 'PySide2.QtGui.QColor'), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLColormap.setHandle": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.size": (),
-# class PySide2.QtOpenGL.QGLContext:
-# class PySide2.QtOpenGL.QGLContext.BindOption:
-# class PySide2.QtOpenGL.QGLContext.BindOptions:
-    "PySide2.QtOpenGL.QGLContext.__init__": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.areSharing": ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLContext.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLContext.chooseContext": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.colorIndex": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLContext.contextHandle": (),
-    "PySide2.QtOpenGL.QGLContext.create": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.currentContext": (),
-    "PySide2.QtOpenGL.QGLContext.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLContext.device": (),
-    "PySide2.QtOpenGL.QGLContext.deviceIsPixmap": (),
-    "PySide2.QtOpenGL.QGLContext.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLContext.format": (),
-    "PySide2.QtOpenGL.QGLContext.fromOpenGLContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtOpenGL.QGLContext.initialized": (),
-    "PySide2.QtOpenGL.QGLContext.isSharing": (),
-    "PySide2.QtOpenGL.QGLContext.isValid": (),
-    "PySide2.QtOpenGL.QGLContext.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtOpenGL.QGLContext.overlayTransparentColor": (),
-    "PySide2.QtOpenGL.QGLContext.requestedFormat": (),
-    "PySide2.QtOpenGL.QGLContext.reset": (),
-    "PySide2.QtOpenGL.QGLContext.setDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtOpenGL.QGLContext.setFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.setInitialized": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setTextureCacheLimit": ('int',),
-    "PySide2.QtOpenGL.QGLContext.setValid": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setWindowCreated": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLContext.textureCacheLimit": (),
-    "PySide2.QtOpenGL.QGLContext.windowCreated": (),
-# class PySide2.QtOpenGL.QGLFormat:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlag:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlags:
-    "PySide2.QtOpenGL.QGLFormat.__init__": [(), ('PySide2.QtOpenGL.QGL.FormatOptions', 'int'), ('PySide2.QtOpenGL.QGLFormat',)],
-    "PySide2.QtOpenGL.QGLFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFormat.accum": (),
-    "PySide2.QtOpenGL.QGLFormat.accumBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.alpha": (),
-    "PySide2.QtOpenGL.QGLFormat.alphaBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.blueBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultOverlayFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.depth": (),
-    "PySide2.QtOpenGL.QGLFormat.depthBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.directRendering": (),
-    "PySide2.QtOpenGL.QGLFormat.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLFormat.fromSurfaceFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtOpenGL.QGLFormat.greenBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGL": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGLOverlays": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOverlay": (),
-    "PySide2.QtOpenGL.QGLFormat.majorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.minorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.openGLVersionFlags": (),
-    "PySide2.QtOpenGL.QGLFormat.plane": (),
-    "PySide2.QtOpenGL.QGLFormat.profile": (),
-    "PySide2.QtOpenGL.QGLFormat.redBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.rgba": (),
-    "PySide2.QtOpenGL.QGLFormat.sampleBuffers": (),
-    "PySide2.QtOpenGL.QGLFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFormat.setAccum": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAccumBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setAlpha": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultOverlayFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDepth": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDirectRendering": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDoubleBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.setOverlay": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setPlane": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setProfile": ('PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile',),
-    "PySide2.QtOpenGL.QGLFormat.setRedBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setRgba": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSampleBuffers": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStencil": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStereo": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSwapInterval": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setVersion": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLFormat.stencil": (),
-    "PySide2.QtOpenGL.QGLFormat.stencilBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.stereo": (),
-    "PySide2.QtOpenGL.QGLFormat.swapInterval": (),
-    "PySide2.QtOpenGL.QGLFormat.testOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.toSurfaceFormat": ('PySide2.QtOpenGL.QGLFormat',),
-# class PySide2.QtOpenGL.QGLFramebufferObject:
-# class PySide2.QtOpenGL.QGLFramebufferObject.Attachment:
-    "PySide2.QtOpenGL.QGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bind": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bindDefault": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.blitFramebuffer": ('PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLFramebufferObject.devType": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.format": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.handle": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isBound": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isValid": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLFramebufferObject.paintEngine": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.release": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.size": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.texture": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.toImage": (),
-# class PySide2.QtOpenGL.QGLFramebufferObjectFormat:
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtOpenGL.QGLFramebufferObjectFormat',)],
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setAttachment": ('PySide2.QtOpenGL.QGLFramebufferObject.Attachment',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtOpenGL.QGLPixelBuffer:
-    "PySide2.QtOpenGL.QGLPixelBuffer.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget'), ('int', 'int', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindTexture": [('PySide2.QtGui.QImage', 'int'), ('PySide2.QtGui.QPixmap', 'int'), ('str',)],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindToDynamicTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.context": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.devType": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.format": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.generateDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.handle": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.hasOpenGLPbuffers": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.isValid": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.paintEngine": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.releaseFromDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.size": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.toImage": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.updateDynamicTexture": ('int',),
-# class PySide2.QtOpenGL.QGLShader:
-# class PySide2.QtOpenGL.QGLShader.ShaderType:
-# class PySide2.QtOpenGL.QGLShader.ShaderTypeBit:
-    "PySide2.QtOpenGL.QGLShader.__init__": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QObject'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShader.compileSourceFile": ('str',),
-    "PySide2.QtOpenGL.QGLShader.hasOpenGLShaders": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLShader.isCompiled": (),
-    "PySide2.QtOpenGL.QGLShader.log": (),
-    "PySide2.QtOpenGL.QGLShader.shaderId": (),
-    "PySide2.QtOpenGL.QGLShader.shaderType": (),
-    "PySide2.QtOpenGL.QGLShader.sourceCode": (),
-# class PySide2.QtOpenGL.QGLShaderProgram:
-    "PySide2.QtOpenGL.QGLShaderProgram.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str'),
-    "PySide2.QtOpenGL.QGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.bind": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryInputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputVertexCount": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLShaderProgram.isLinked": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.link": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.log": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.programId": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.release": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryInputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputVertexCount": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x2": [('int', 'PySide2.QtGui.QMatrix2x2', 'int'), ('str', 'PySide2.QtGui.QMatrix2x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x3": [('int', 'PySide2.QtGui.QMatrix2x3', 'int'), ('str', 'PySide2.QtGui.QMatrix2x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x4": [('int', 'PySide2.QtGui.QMatrix2x4', 'int'), ('str', 'PySide2.QtGui.QMatrix2x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x2": [('int', 'PySide2.QtGui.QMatrix3x2', 'int'), ('str', 'PySide2.QtGui.QMatrix3x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x3": [('int', 'PySide2.QtGui.QMatrix3x3', 'int'), ('str', 'PySide2.QtGui.QMatrix3x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x4": [('int', 'PySide2.QtGui.QMatrix3x4', 'int'), ('str', 'PySide2.QtGui.QMatrix3x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x2": [('int', 'PySide2.QtGui.QMatrix4x2', 'int'), ('str', 'PySide2.QtGui.QMatrix4x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x3": [('int', 'PySide2.QtGui.QMatrix4x3', 'int'), ('str', 'PySide2.QtGui.QMatrix4x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x4": [('int', 'PySide2.QtGui.QMatrix4x4', 'int'), ('str', 'PySide2.QtGui.QMatrix4x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayInt": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayUint": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.shaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtOpenGL.QGLWidget:
-    "PySide2.QtOpenGL.QGLWidget.__init__": [('PySide2.QtOpenGL.QGLContext', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtOpenGL.QGLFormat', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtOpenGL.QGLWidget.autoBufferSwap": (),
-    "PySide2.QtOpenGL.QGLWidget.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLWidget.colormap": (),
-    "PySide2.QtOpenGL.QGLWidget.context": (),
-    "PySide2.QtOpenGL.QGLWidget.convertToGLFormat": ('PySide2.QtGui.QImage',),
-    "PySide2.QtOpenGL.QGLWidget.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLWidget.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLWidget.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtOpenGL.QGLWidget.format": (),
-    "PySide2.QtOpenGL.QGLWidget.glDraw": (),
-    "PySide2.QtOpenGL.QGLWidget.glInit": (),
-    "PySide2.QtOpenGL.QGLWidget.grabFrameBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.initializeGL": (),
-    "PySide2.QtOpenGL.QGLWidget.initializeOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.isSharing": (),
-    "PySide2.QtOpenGL.QGLWidget.isValid": (),
-    "PySide2.QtOpenGL.QGLWidget.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.makeOverlayCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.overlayContext": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEngine": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtOpenGL.QGLWidget.paintGL": (),
-    "PySide2.QtOpenGL.QGLWidget.paintOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.qglClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.qglColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.renderPixmap": ('int', 'int', 'bool'),
-    "PySide2.QtOpenGL.QGLWidget.renderText": [('float', 'float', 'float', 'str', 'PySide2.QtGui.QFont'), ('int', 'int', 'str', 'PySide2.QtGui.QFont')],
-    "PySide2.QtOpenGL.QGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtOpenGL.QGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.resizeOverlayGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.setAutoBufferSwap": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.setColormap": ('PySide2.QtOpenGL.QGLColormap',),
-    "PySide2.QtOpenGL.QGLWidget.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLWidget.updateGL": (),
-    "PySide2.QtOpenGL.QGLWidget.updateOverlayGL": (),
-    }) if "PySide2.QtOpenGL" in sys.modules else None
-# Module PySide2.QtOpenGLFunctions
-sig_dict.update({
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnConvolutionFilter": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnHistogram": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnMinmax": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.initializeOpenGLFunctions": (),
-    }) if "PySide2.QtOpenGLFunctions" in sys.modules else None
-# Module PySide2.QtPositioning
-sig_dict.update({
-# class PySide2.QtPositioning.QGeoAddress:
-    "PySide2.QtPositioning.QGeoAddress.__init__": [(), ('PySide2.QtPositioning.QGeoAddress',)],
-    "PySide2.QtPositioning.QGeoAddress.__copy__": (),
-    "PySide2.QtPositioning.QGeoAddress.city": (),
-    "PySide2.QtPositioning.QGeoAddress.clear": (),
-    "PySide2.QtPositioning.QGeoAddress.country": (),
-    "PySide2.QtPositioning.QGeoAddress.countryCode": (),
-    "PySide2.QtPositioning.QGeoAddress.county": (),
-    "PySide2.QtPositioning.QGeoAddress.district": (),
-    "PySide2.QtPositioning.QGeoAddress.isEmpty": (),
-    "PySide2.QtPositioning.QGeoAddress.isTextGenerated": (),
-    "PySide2.QtPositioning.QGeoAddress.postalCode": (),
-    "PySide2.QtPositioning.QGeoAddress.setCity": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountry": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountryCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCounty": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setDistrict": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setPostalCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setState": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setStreet": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setText": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.state": (),
-    "PySide2.QtPositioning.QGeoAddress.street": (),
-    "PySide2.QtPositioning.QGeoAddress.text": (),
-# class PySide2.QtPositioning.QGeoAreaMonitorInfo:
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__init__": [('PySide2.QtPositioning.QGeoAreaMonitorInfo',), ('str',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.area": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.expiration": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.identifier": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isPersistent": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.name": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.notificationParameters": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setExpiration": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setName": ('str',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setNotificationParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setPersistent": ('bool',),
-# class PySide2.QtPositioning.QGeoAreaMonitorSource:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeature:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeatures:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.Error:
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.activeMonitors": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createDefaultSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createSource": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.error": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.positionInfoSource": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.requestUpdate": ('PySide2.QtPositioning.QGeoAreaMonitorInfo', 'str'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.setPositionInfoSource": ('PySide2.QtPositioning.QGeoPositionInfoSource',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.startMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.stopMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.supportedAreaMonitorFeatures": (),
-# class PySide2.QtPositioning.QGeoCircle:
-    "PySide2.QtPositioning.QGeoCircle.__init__": [(), ('PySide2.QtPositioning.QGeoCircle',), ('PySide2.QtPositioning.QGeoCoordinate', 'float'), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoCircle.__copy__": (),
-    "PySide2.QtPositioning.QGeoCircle.center": (),
-    "PySide2.QtPositioning.QGeoCircle.extendCircle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.radius": (),
-    "PySide2.QtPositioning.QGeoCircle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.setRadius": ('float',),
-    "PySide2.QtPositioning.QGeoCircle.toString": (),
-    "PySide2.QtPositioning.QGeoCircle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoCircle.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoCoordinate:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateType:
-    "PySide2.QtPositioning.QGeoCoordinate.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtPositioning.QGeoCoordinate.__copy__": (),
-    "PySide2.QtPositioning.QGeoCoordinate.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.altitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.atDistanceAndAzimuth": ('float', 'float', 'float'),
-    "PySide2.QtPositioning.QGeoCoordinate.azimuthTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.distanceTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.isValid": (),
-    "PySide2.QtPositioning.QGeoCoordinate.latitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.longitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.setAltitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLatitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLongitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.toString": ('PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat',),
-    "PySide2.QtPositioning.QGeoCoordinate.type": (),
-# class PySide2.QtPositioning.QGeoLocation:
-    "PySide2.QtPositioning.QGeoLocation.__init__": [(), ('PySide2.QtPositioning.QGeoLocation',)],
-    "PySide2.QtPositioning.QGeoLocation.__copy__": (),
-    "PySide2.QtPositioning.QGeoLocation.address": (),
-    "PySide2.QtPositioning.QGeoLocation.boundingBox": (),
-    "PySide2.QtPositioning.QGeoLocation.coordinate": (),
-    "PySide2.QtPositioning.QGeoLocation.extendedAttributes": (),
-    "PySide2.QtPositioning.QGeoLocation.isEmpty": (),
-    "PySide2.QtPositioning.QGeoLocation.setAddress": ('PySide2.QtPositioning.QGeoAddress',),
-    "PySide2.QtPositioning.QGeoLocation.setBoundingBox": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoLocation.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoLocation.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtPositioning.QGeoPath:
-    "PySide2.QtPositioning.QGeoPath.__init__": [(), ('PySide2.QtPositioning.QGeoPath',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]', 'float')],
-    "PySide2.QtPositioning.QGeoPath.__copy__": (),
-    "PySide2.QtPositioning.QGeoPath.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.clearPath": (),
-    "PySide2.QtPositioning.QGeoPath.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPath.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPath.path": (),
-    "PySide2.QtPositioning.QGeoPath.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPath.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPath.setVariantPath": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPath.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoPath.size": (),
-    "PySide2.QtPositioning.QGeoPath.toString": (),
-    "PySide2.QtPositioning.QGeoPath.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.variantPath": (),
-    "PySide2.QtPositioning.QGeoPath.width": (),
-# class PySide2.QtPositioning.QGeoPolygon:
-    "PySide2.QtPositioning.QGeoPolygon.__init__": [(), ('PySide2.QtPositioning.QGeoPolygon',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.__copy__": (),
-    "PySide2.QtPositioning.QGeoPolygon.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.addHole": [('typing.Any',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.hole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holePath": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holesCount": (),
-    "PySide2.QtPositioning.QGeoPolygon.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPolygon.path": (),
-    "PySide2.QtPositioning.QGeoPolygon.perimeter": (),
-    "PySide2.QtPositioning.QGeoPolygon.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPolygon.removeHole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPolygon.setPerimeter": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPolygon.size": (),
-    "PySide2.QtPositioning.QGeoPolygon.toString": (),
-    "PySide2.QtPositioning.QGeoPolygon.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPolygon.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoPositionInfo:
-# class PySide2.QtPositioning.QGeoPositionInfo.Attribute:
-    "PySide2.QtPositioning.QGeoPositionInfo.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtCore.QDateTime'), ('PySide2.QtPositioning.QGeoPositionInfo',)],
-    "PySide2.QtPositioning.QGeoPositionInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.attribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.coordinate": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.hasAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.removeAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoPositionInfo.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setTimestamp": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoPositionInfo.timestamp": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSource:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.Error:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethod:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods:
-    "PySide2.QtPositioning.QGeoPositionInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.backendProperty": ('str',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.preferredPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setBackendProperty": ('str', 'typing.Any'),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setPreferredPositioningMethods": ('PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSourceFactory:
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.__init__": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.areaMonitor": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.positionInfoSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.satelliteInfoSource": ('PySide2.QtCore.QObject',),
-# class PySide2.QtPositioning.QGeoRectangle:
-    "PySide2.QtPositioning.QGeoRectangle.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('PySide2.QtPositioning.QGeoCoordinate', 'float', 'float'), ('PySide2.QtPositioning.QGeoRectangle',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoRectangle.__copy__": (),
-    "PySide2.QtPositioning.QGeoRectangle.__ior__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.__or__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.bottomLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.bottomRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.center": (),
-    "PySide2.QtPositioning.QGeoRectangle.contains": [('PySide2.QtPositioning.QGeoCoordinate',), ('PySide2.QtPositioning.QGeoRectangle',)],
-    "PySide2.QtPositioning.QGeoRectangle.extendRectangle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.height": (),
-    "PySide2.QtPositioning.QGeoRectangle.intersects": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setHeight": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.toString": (),
-    "PySide2.QtPositioning.QGeoRectangle.topLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.topRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.united": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.width": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfo:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.Attribute:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem:
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__init__": [(), ('PySide2.QtPositioning.QGeoSatelliteInfo',)],
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.attribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.hasAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.removeAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteIdentifier": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteSystem": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteIdentifier": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteSystem": ('PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSignalStrength": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.signalStrength": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource:
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource.Error:
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoShape:
-# class PySide2.QtPositioning.QGeoShape.ShapeType:
-    "PySide2.QtPositioning.QGeoShape.__init__": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoShape.__copy__": (),
-    "PySide2.QtPositioning.QGeoShape.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.boundingGeoRectangle": (),
-    "PySide2.QtPositioning.QGeoShape.center": (),
-    "PySide2.QtPositioning.QGeoShape.contains": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.extendShape": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.isEmpty": (),
-    "PySide2.QtPositioning.QGeoShape.isValid": (),
-    "PySide2.QtPositioning.QGeoShape.toString": (),
-    "PySide2.QtPositioning.QGeoShape.type": (),
-# class PySide2.QtPositioning.QNmeaPositionInfoSource:
-# class PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode:
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.__init__": ('PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.device": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.parsePosInfoFromNmeaData": ('str', 'int', 'PySide2.QtPositioning.QGeoPositionInfo'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUserEquivalentRangeError": ('float',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.updateMode": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.userEquivalentRangeError": (),
-    }) if "PySide2.QtPositioning" in sys.modules else None
-# Module PySide2.QtLocation
-sig_dict.update({
-# class PySide2.QtLocation.QGeoCodeReply:
-# class PySide2.QtLocation.QGeoCodeReply.Error:
-    "PySide2.QtLocation.QGeoCodeReply.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtLocation.QGeoCodeReply.Error', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoCodeReply.abort": (),
-    "PySide2.QtLocation.QGeoCodeReply.addLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QGeoCodeReply.error": (),
-    "PySide2.QtLocation.QGeoCodeReply.errorString": (),
-    "PySide2.QtLocation.QGeoCodeReply.isFinished": (),
-    "PySide2.QtLocation.QGeoCodeReply.limit": (),
-    "PySide2.QtLocation.QGeoCodeReply.locations": (),
-    "PySide2.QtLocation.QGeoCodeReply.offset": (),
-    "PySide2.QtLocation.QGeoCodeReply.setError": ('PySide2.QtLocation.QGeoCodeReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoCodeReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoCodeReply.setLimit": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setLocations": ('typing.Sequence[PySide2.QtPositioning.QGeoLocation]',),
-    "PySide2.QtLocation.QGeoCodeReply.setOffset": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setViewport": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QGeoCodeReply.viewport": (),
-# class PySide2.QtLocation.QGeoCodingManager:
-    "PySide2.QtLocation.QGeoCodingManager.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManager.locale": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManager.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManager.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoCodingManagerEngine:
-    "PySide2.QtLocation.QGeoCodingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoManeuver:
-# class PySide2.QtLocation.QGeoManeuver.InstructionDirection:
-    "PySide2.QtLocation.QGeoManeuver.__init__": [(), ('PySide2.QtLocation.QGeoManeuver',)],
-    "PySide2.QtLocation.QGeoManeuver.__copy__": (),
-    "PySide2.QtLocation.QGeoManeuver.direction": (),
-    "PySide2.QtLocation.QGeoManeuver.distanceToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoManeuver.instructionText": (),
-    "PySide2.QtLocation.QGeoManeuver.isValid": (),
-    "PySide2.QtLocation.QGeoManeuver.position": (),
-    "PySide2.QtLocation.QGeoManeuver.setDirection": ('PySide2.QtLocation.QGeoManeuver.InstructionDirection',),
-    "PySide2.QtLocation.QGeoManeuver.setDistanceToNextInstruction": ('float',),
-    "PySide2.QtLocation.QGeoManeuver.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoManeuver.setInstructionText": ('str',),
-    "PySide2.QtLocation.QGeoManeuver.setPosition": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.setTimeToNextInstruction": ('int',),
-    "PySide2.QtLocation.QGeoManeuver.setWaypoint": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.timeToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.waypoint": (),
-# class PySide2.QtLocation.QGeoRoute:
-    "PySide2.QtLocation.QGeoRoute.__init__": [(), ('PySide2.QtLocation.QGeoRoute',)],
-    "PySide2.QtLocation.QGeoRoute.__copy__": (),
-    "PySide2.QtLocation.QGeoRoute.bounds": (),
-    "PySide2.QtLocation.QGeoRoute.distance": (),
-    "PySide2.QtLocation.QGeoRoute.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoRoute.firstRouteSegment": (),
-    "PySide2.QtLocation.QGeoRoute.path": (),
-    "PySide2.QtLocation.QGeoRoute.request": (),
-    "PySide2.QtLocation.QGeoRoute.routeId": (),
-    "PySide2.QtLocation.QGeoRoute.setBounds": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtLocation.QGeoRoute.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRoute.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRoute.setFirstRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRoute.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRoute.setRequest": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoute.setRouteId": ('str',),
-    "PySide2.QtLocation.QGeoRoute.setTravelMode": ('PySide2.QtLocation.QGeoRouteRequest.TravelMode',),
-    "PySide2.QtLocation.QGeoRoute.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRoute.travelMode": (),
-    "PySide2.QtLocation.QGeoRoute.travelTime": (),
-# class PySide2.QtLocation.QGeoRouteReply:
-# class PySide2.QtLocation.QGeoRouteReply.Error:
-    "PySide2.QtLocation.QGeoRouteReply.__init__": [('PySide2.QtLocation.QGeoRouteReply.Error', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtLocation.QGeoRouteRequest', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoRouteReply.abort": (),
-    "PySide2.QtLocation.QGeoRouteReply.addRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-    "PySide2.QtLocation.QGeoRouteReply.error": (),
-    "PySide2.QtLocation.QGeoRouteReply.errorString": (),
-    "PySide2.QtLocation.QGeoRouteReply.isFinished": (),
-    "PySide2.QtLocation.QGeoRouteReply.request": (),
-    "PySide2.QtLocation.QGeoRouteReply.routes": (),
-    "PySide2.QtLocation.QGeoRouteReply.setError": ('PySide2.QtLocation.QGeoRouteReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoRouteReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoRouteReply.setRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-# class PySide2.QtLocation.QGeoRouteRequest:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureType:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureTypes:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeight:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeights:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimization:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelMode:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelModes:
-    "PySide2.QtLocation.QGeoRouteRequest.__init__": [('PySide2.QtLocation.QGeoRouteRequest',), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtLocation.QGeoRouteRequest.departureTime": (),
-    "PySide2.QtLocation.QGeoRouteRequest.excludeAreas": (),
-    "PySide2.QtLocation.QGeoRouteRequest.extraParameters": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureTypes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType',),
-    "PySide2.QtLocation.QGeoRouteRequest.maneuverDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.numberAlternativeRoutes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.routeOptimization": (),
-    "PySide2.QtLocation.QGeoRouteRequest.segmentDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.setDepartureTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExcludeAreas": ('typing.Sequence[PySide2.QtPositioning.QGeoRectangle]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExtraParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setFeatureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType', 'PySide2.QtLocation.QGeoRouteRequest.FeatureWeight'),
-    "PySide2.QtLocation.QGeoRouteRequest.setManeuverDetail": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setNumberAlternativeRoutes": ('int',),
-    "PySide2.QtLocation.QGeoRouteRequest.setRouteOptimization": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRouteRequest.setSegmentDetail": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypoints": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypointsMetadata": ('typing.Sequence[typing.Dict]',),
-    "PySide2.QtLocation.QGeoRouteRequest.travelModes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypoints": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypointsMetadata": (),
-# class PySide2.QtLocation.QGeoRouteSegment:
-    "PySide2.QtLocation.QGeoRouteSegment.__init__": [(), ('PySide2.QtLocation.QGeoRouteSegment',)],
-    "PySide2.QtLocation.QGeoRouteSegment.__copy__": (),
-    "PySide2.QtLocation.QGeoRouteSegment.distance": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isLegLastSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isValid": (),
-    "PySide2.QtLocation.QGeoRouteSegment.maneuver": (),
-    "PySide2.QtLocation.QGeoRouteSegment.nextRouteSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.path": (),
-    "PySide2.QtLocation.QGeoRouteSegment.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRouteSegment.setManeuver": ('PySide2.QtLocation.QGeoManeuver',),
-    "PySide2.QtLocation.QGeoRouteSegment.setNextRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRouteSegment.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteSegment.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRouteSegment.travelTime": (),
-# class PySide2.QtLocation.QGeoRoutingManager:
-    "PySide2.QtLocation.QGeoRoutingManager.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManager.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManager.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManager.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoRoutingManagerEngine:
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureTypes": ('PySide2.QtLocation.QGeoRouteRequest.FeatureTypes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureWeights": ('PySide2.QtLocation.QGeoRouteRequest.FeatureWeights',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedManeuverDetails": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedRouteOptimizations": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedSegmentDetails": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoServiceProvider:
-# class PySide2.QtLocation.QGeoServiceProvider.Error:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeatures:
-    "PySide2.QtLocation.QGeoServiceProvider.__init__": ('str', 'typing.Dict[str, typing.Any]', 'bool'),
-    "PySide2.QtLocation.QGeoServiceProvider.availableServiceProviders": (),
-    "PySide2.QtLocation.QGeoServiceProvider.error": (),
-    "PySide2.QtLocation.QGeoServiceProvider.errorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placeManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.setAllowExperimental": ('bool',),
-    "PySide2.QtLocation.QGeoServiceProvider.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoServiceProvider.setParameters": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtLocation.QGeoServiceProviderFactory:
-    "PySide2.QtLocation.QGeoServiceProviderFactory.__init__": (),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createGeocodingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createPlaceManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createRoutingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-# class PySide2.QtLocation.QGeoServiceProviderFactoryV2:
-    "PySide2.QtLocation.QGeoServiceProviderFactoryV2.__init__": (),
-# class PySide2.QtLocation.QPlace:
-    "PySide2.QtLocation.QPlace.__init__": [(), ('PySide2.QtLocation.QPlace',)],
-    "PySide2.QtLocation.QPlace.__copy__": (),
-    "PySide2.QtLocation.QPlace.appendContactDetail": ('str', 'PySide2.QtLocation.QPlaceContactDetail'),
-    "PySide2.QtLocation.QPlace.attribution": (),
-    "PySide2.QtLocation.QPlace.categories": (),
-    "PySide2.QtLocation.QPlace.contactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.contactTypes": (),
-    "PySide2.QtLocation.QPlace.content": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlace.detailsFetched": (),
-    "PySide2.QtLocation.QPlace.extendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.extendedAttributeTypes": (),
-    "PySide2.QtLocation.QPlace.icon": (),
-    "PySide2.QtLocation.QPlace.insertContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.isEmpty": (),
-    "PySide2.QtLocation.QPlace.location": (),
-    "PySide2.QtLocation.QPlace.name": (),
-    "PySide2.QtLocation.QPlace.placeId": (),
-    "PySide2.QtLocation.QPlace.primaryEmail": (),
-    "PySide2.QtLocation.QPlace.primaryFax": (),
-    "PySide2.QtLocation.QPlace.primaryPhone": (),
-    "PySide2.QtLocation.QPlace.primaryWebsite": (),
-    "PySide2.QtLocation.QPlace.ratings": (),
-    "PySide2.QtLocation.QPlace.removeContactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.removeExtendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlace.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlace.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlace.setContactDetails": ('str', 'typing.Sequence[PySide2.QtLocation.QPlaceContactDetail]'),
-    "PySide2.QtLocation.QPlace.setContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.setDetailsFetched": ('bool',),
-    "PySide2.QtLocation.QPlace.setExtendedAttribute": ('str', 'PySide2.QtLocation.QPlaceAttribute'),
-    "PySide2.QtLocation.QPlace.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlace.setLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QPlace.setName": ('str',),
-    "PySide2.QtLocation.QPlace.setPlaceId": ('str',),
-    "PySide2.QtLocation.QPlace.setRatings": ('PySide2.QtLocation.QPlaceRatings',),
-    "PySide2.QtLocation.QPlace.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlace.setTotalContentCount": ('PySide2.QtLocation.QPlaceContent.Type', 'int'),
-    "PySide2.QtLocation.QPlace.supplier": (),
-    "PySide2.QtLocation.QPlace.totalContentCount": ('PySide2.QtLocation.QPlaceContent.Type',),
-# class PySide2.QtLocation.QPlaceAttribute:
-    "PySide2.QtLocation.QPlaceAttribute.__init__": [(), ('PySide2.QtLocation.QPlaceAttribute',)],
-    "PySide2.QtLocation.QPlaceAttribute.__copy__": (),
-    "PySide2.QtLocation.QPlaceAttribute.isEmpty": (),
-    "PySide2.QtLocation.QPlaceAttribute.label": (),
-    "PySide2.QtLocation.QPlaceAttribute.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.setText": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.text": (),
-# class PySide2.QtLocation.QPlaceCategory:
-    "PySide2.QtLocation.QPlaceCategory.__init__": [(), ('PySide2.QtLocation.QPlaceCategory',)],
-    "PySide2.QtLocation.QPlaceCategory.__copy__": (),
-    "PySide2.QtLocation.QPlaceCategory.categoryId": (),
-    "PySide2.QtLocation.QPlaceCategory.icon": (),
-    "PySide2.QtLocation.QPlaceCategory.isEmpty": (),
-    "PySide2.QtLocation.QPlaceCategory.name": (),
-    "PySide2.QtLocation.QPlaceCategory.setCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceCategory.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceCategory.setName": ('str',),
-# class PySide2.QtLocation.QPlaceContactDetail:
-    "PySide2.QtLocation.QPlaceContactDetail.__init__": [(), ('PySide2.QtLocation.QPlaceContactDetail',)],
-    "PySide2.QtLocation.QPlaceContactDetail.__copy__": (),
-    "PySide2.QtLocation.QPlaceContactDetail.clear": (),
-    "PySide2.QtLocation.QPlaceContactDetail.label": (),
-    "PySide2.QtLocation.QPlaceContactDetail.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.setValue": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.value": (),
-# class PySide2.QtLocation.QPlaceContent:
-# class PySide2.QtLocation.QPlaceContent.Type:
-    "PySide2.QtLocation.QPlaceContent.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceContent.__copy__": (),
-    "PySide2.QtLocation.QPlaceContent.attribution": (),
-    "PySide2.QtLocation.QPlaceContent.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlaceContent.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlaceContent.setUser": ('PySide2.QtLocation.QPlaceUser',),
-    "PySide2.QtLocation.QPlaceContent.supplier": (),
-    "PySide2.QtLocation.QPlaceContent.type": (),
-    "PySide2.QtLocation.QPlaceContent.user": (),
-# class PySide2.QtLocation.QPlaceContentReply:
-    "PySide2.QtLocation.QPlaceContentReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceContentReply.content": (),
-    "PySide2.QtLocation.QPlaceContentReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.request": (),
-    "PySide2.QtLocation.QPlaceContentReply.setContent": ('typing.Dict[int, PySide2.QtLocation.QPlaceContent]',),
-    "PySide2.QtLocation.QPlaceContentReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setTotalCount": ('int',),
-    "PySide2.QtLocation.QPlaceContentReply.totalCount": (),
-    "PySide2.QtLocation.QPlaceContentReply.type": (),
-# class PySide2.QtLocation.QPlaceContentRequest:
-    "PySide2.QtLocation.QPlaceContentRequest.__init__": [(), ('PySide2.QtLocation.QPlaceContentRequest',)],
-    "PySide2.QtLocation.QPlaceContentRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceContentRequest.clear": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentContext": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentType": (),
-    "PySide2.QtLocation.QPlaceContentRequest.limit": (),
-    "PySide2.QtLocation.QPlaceContentRequest.placeId": (),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentType": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlaceContentRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceContentRequest.setPlaceId": ('str',),
-# class PySide2.QtLocation.QPlaceDetailsReply:
-    "PySide2.QtLocation.QPlaceDetailsReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceDetailsReply.place": (),
-    "PySide2.QtLocation.QPlaceDetailsReply.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceDetailsReply.type": (),
-# class PySide2.QtLocation.QPlaceEditorial:
-    "PySide2.QtLocation.QPlaceEditorial.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceEditorial.language": (),
-    "PySide2.QtLocation.QPlaceEditorial.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setText": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.text": (),
-    "PySide2.QtLocation.QPlaceEditorial.title": (),
-# class PySide2.QtLocation.QPlaceIcon:
-    "PySide2.QtLocation.QPlaceIcon.__init__": [(), ('PySide2.QtLocation.QPlaceIcon',)],
-    "PySide2.QtLocation.QPlaceIcon.__copy__": (),
-    "PySide2.QtLocation.QPlaceIcon.isEmpty": (),
-    "PySide2.QtLocation.QPlaceIcon.manager": (),
-    "PySide2.QtLocation.QPlaceIcon.parameters": (),
-    "PySide2.QtLocation.QPlaceIcon.setManager": ('PySide2.QtLocation.QPlaceManager',),
-    "PySide2.QtLocation.QPlaceIcon.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceIcon.url": ('PySide2.QtCore.QSize',),
-# class PySide2.QtLocation.QPlaceIdReply:
-# class PySide2.QtLocation.QPlaceIdReply.OperationType:
-    "PySide2.QtLocation.QPlaceIdReply.__init__": ('PySide2.QtLocation.QPlaceIdReply.OperationType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceIdReply.id": (),
-    "PySide2.QtLocation.QPlaceIdReply.operationType": (),
-    "PySide2.QtLocation.QPlaceIdReply.setId": ('str',),
-    "PySide2.QtLocation.QPlaceIdReply.type": (),
-# class PySide2.QtLocation.QPlaceImage:
-    "PySide2.QtLocation.QPlaceImage.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceImage.imageId": (),
-    "PySide2.QtLocation.QPlaceImage.mimeType": (),
-    "PySide2.QtLocation.QPlaceImage.setImageId": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setMimeType": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceImage.url": (),
-# class PySide2.QtLocation.QPlaceManager:
-    "PySide2.QtLocation.QPlaceManager.category": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManager.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManager.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManager.locales": (),
-    "PySide2.QtLocation.QPlaceManager.managerName": (),
-    "PySide2.QtLocation.QPlaceManager.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManager.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManager.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManager.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManager.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QPlaceManager.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceManagerEngine:
-    "PySide2.QtLocation.QPlaceManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceManagerEngine.category": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.constructIconUrl": ('PySide2.QtLocation.QPlaceIcon', 'PySide2.QtCore.QSize'),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.locales": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.manager": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerName": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManagerEngine.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceMatchReply:
-    "PySide2.QtLocation.QPlaceMatchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceMatchReply.places": (),
-    "PySide2.QtLocation.QPlaceMatchReply.request": (),
-    "PySide2.QtLocation.QPlaceMatchReply.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchReply.setRequest": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceMatchReply.type": (),
-# class PySide2.QtLocation.QPlaceMatchRequest:
-    "PySide2.QtLocation.QPlaceMatchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceMatchRequest',)],
-    "PySide2.QtLocation.QPlaceMatchRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.parameters": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.places": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-# class PySide2.QtLocation.QPlaceProposedSearchResult:
-    "PySide2.QtLocation.QPlaceProposedSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceProposedSearchResult.searchRequest": (),
-    "PySide2.QtLocation.QPlaceProposedSearchResult.setSearchRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-# class PySide2.QtLocation.QPlaceRatings:
-    "PySide2.QtLocation.QPlaceRatings.__init__": [(), ('PySide2.QtLocation.QPlaceRatings',)],
-    "PySide2.QtLocation.QPlaceRatings.__copy__": (),
-    "PySide2.QtLocation.QPlaceRatings.average": (),
-    "PySide2.QtLocation.QPlaceRatings.count": (),
-    "PySide2.QtLocation.QPlaceRatings.isEmpty": (),
-    "PySide2.QtLocation.QPlaceRatings.maximum": (),
-    "PySide2.QtLocation.QPlaceRatings.setAverage": ('float',),
-    "PySide2.QtLocation.QPlaceRatings.setCount": ('int',),
-    "PySide2.QtLocation.QPlaceRatings.setMaximum": ('float',),
-# class PySide2.QtLocation.QPlaceReply:
-# class PySide2.QtLocation.QPlaceReply.Error:
-# class PySide2.QtLocation.QPlaceReply.Type:
-    "PySide2.QtLocation.QPlaceReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceReply.abort": (),
-    "PySide2.QtLocation.QPlaceReply.error": (),
-    "PySide2.QtLocation.QPlaceReply.errorString": (),
-    "PySide2.QtLocation.QPlaceReply.isFinished": (),
-    "PySide2.QtLocation.QPlaceReply.setError": ('PySide2.QtLocation.QPlaceReply.Error', 'str'),
-    "PySide2.QtLocation.QPlaceReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QPlaceReply.type": (),
-# class PySide2.QtLocation.QPlaceResult:
-    "PySide2.QtLocation.QPlaceResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceResult.distance": (),
-    "PySide2.QtLocation.QPlaceResult.isSponsored": (),
-    "PySide2.QtLocation.QPlaceResult.place": (),
-    "PySide2.QtLocation.QPlaceResult.setDistance": ('float',),
-    "PySide2.QtLocation.QPlaceResult.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceResult.setSponsored": ('bool',),
-# class PySide2.QtLocation.QPlaceReview:
-    "PySide2.QtLocation.QPlaceReview.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceReview.dateTime": (),
-    "PySide2.QtLocation.QPlaceReview.language": (),
-    "PySide2.QtLocation.QPlaceReview.rating": (),
-    "PySide2.QtLocation.QPlaceReview.reviewId": (),
-    "PySide2.QtLocation.QPlaceReview.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QPlaceReview.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setRating": ('float',),
-    "PySide2.QtLocation.QPlaceReview.setReviewId": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setText": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceReview.text": (),
-    "PySide2.QtLocation.QPlaceReview.title": (),
-# class PySide2.QtLocation.QPlaceSearchReply:
-    "PySide2.QtLocation.QPlaceSearchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.request": (),
-    "PySide2.QtLocation.QPlaceSearchReply.results": (),
-    "PySide2.QtLocation.QPlaceSearchReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-    "PySide2.QtLocation.QPlaceSearchReply.type": (),
-# class PySide2.QtLocation.QPlaceSearchRequest:
-# class PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint:
-    "PySide2.QtLocation.QPlaceSearchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceSearchRequest',)],
-    "PySide2.QtLocation.QPlaceSearchRequest.categories": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.limit": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.recommendationId": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.relevanceHint": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchArea": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchContext": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchTerm": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRecommendationId": ('str',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRelevanceHint": ('PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchTerm": ('str',),
-# class PySide2.QtLocation.QPlaceSearchResult:
-# class PySide2.QtLocation.QPlaceSearchResult.SearchResultType:
-    "PySide2.QtLocation.QPlaceSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceSearchResult.icon": (),
-    "PySide2.QtLocation.QPlaceSearchResult.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSearchResult.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceSearchResult.title": (),
-    "PySide2.QtLocation.QPlaceSearchResult.type": (),
-# class PySide2.QtLocation.QPlaceSearchSuggestionReply:
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.setSuggestions": ('typing.Sequence[str]',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.suggestions": (),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.type": (),
-# class PySide2.QtLocation.QPlaceSupplier:
-    "PySide2.QtLocation.QPlaceSupplier.__init__": [(), ('PySide2.QtLocation.QPlaceSupplier',)],
-    "PySide2.QtLocation.QPlaceSupplier.__copy__": (),
-    "PySide2.QtLocation.QPlaceSupplier.icon": (),
-    "PySide2.QtLocation.QPlaceSupplier.isEmpty": (),
-    "PySide2.QtLocation.QPlaceSupplier.name": (),
-    "PySide2.QtLocation.QPlaceSupplier.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSupplier.setName": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setSupplierId": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceSupplier.supplierId": (),
-    "PySide2.QtLocation.QPlaceSupplier.url": (),
-# class PySide2.QtLocation.QPlaceUser:
-    "PySide2.QtLocation.QPlaceUser.__init__": [(), ('PySide2.QtLocation.QPlaceUser',)],
-    "PySide2.QtLocation.QPlaceUser.__copy__": (),
-    "PySide2.QtLocation.QPlaceUser.name": (),
-    "PySide2.QtLocation.QPlaceUser.setName": ('str',),
-    "PySide2.QtLocation.QPlaceUser.setUserId": ('str',),
-    "PySide2.QtLocation.QPlaceUser.userId": (),
-    }) if "PySide2.QtLocation" in sys.modules else None
-# Module PySide2.QtQml
-sig_dict.update({
-# class PySide2.QtQml.ListProperty:
-    "PySide2.QtQml.ListProperty.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable'),
-# class PySide2.QtQml.QJSEngine:
-# class PySide2.QtQml.QJSEngine.Extension:
-# class PySide2.QtQml.QJSEngine.Extensions:
-    "PySide2.QtQml.QJSEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QJSEngine.collectGarbage": (),
-    "PySide2.QtQml.QJSEngine.evaluate": ('str', 'str', 'int'),
-    "PySide2.QtQml.QJSEngine.globalObject": (),
-    "PySide2.QtQml.QJSEngine.importModule": ('str',),
-    "PySide2.QtQml.QJSEngine.installExtensions": ('PySide2.QtQml.QJSEngine.Extensions', 'PySide2.QtQml.QJSValue'),
-    "PySide2.QtQml.QJSEngine.installTranslatorFunctions": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSEngine.isInterrupted": (),
-    "PySide2.QtQml.QJSEngine.newArray": ('int',),
-    "PySide2.QtQml.QJSEngine.newErrorObject": ('PySide2.QtQml.QJSValue.ErrorType', 'str'),
-    "PySide2.QtQml.QJSEngine.newObject": (),
-    "PySide2.QtQml.QJSEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtQml.QJSEngine.newQObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QJSEngine.setInterrupted": ('bool',),
-    "PySide2.QtQml.QJSEngine.throwError": [('PySide2.QtQml.QJSValue.ErrorType', 'str'), ('str',)],
-    "PySide2.QtQml.QJSEngine.toScriptValue": ('typing.Any',),
-# class PySide2.QtQml.QJSValue:
-# class PySide2.QtQml.QJSValue.ErrorType:
-# class PySide2.QtQml.QJSValue.SpecialValue:
-    "PySide2.QtQml.QJSValue.__init__": [('PySide2.QtQml.QJSValue',), ('PySide2.QtQml.QJSValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.__copy__": (),
-    "PySide2.QtQml.QJSValue.call": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callAsConstructor": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callWithInstance": ('PySide2.QtQml.QJSValue', 'typing.Sequence[PySide2.QtQml.QJSValue]'),
-    "PySide2.QtQml.QJSValue.deleteProperty": ('str',),
-    "PySide2.QtQml.QJSValue.engine": (),
-    "PySide2.QtQml.QJSValue.equals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.errorType": (),
-    "PySide2.QtQml.QJSValue.hasOwnProperty": ('str',),
-    "PySide2.QtQml.QJSValue.hasProperty": ('str',),
-    "PySide2.QtQml.QJSValue.isArray": (),
-    "PySide2.QtQml.QJSValue.isBool": (),
-    "PySide2.QtQml.QJSValue.isCallable": (),
-    "PySide2.QtQml.QJSValue.isDate": (),
-    "PySide2.QtQml.QJSValue.isError": (),
-    "PySide2.QtQml.QJSValue.isNull": (),
-    "PySide2.QtQml.QJSValue.isNumber": (),
-    "PySide2.QtQml.QJSValue.isObject": (),
-    "PySide2.QtQml.QJSValue.isQMetaObject": (),
-    "PySide2.QtQml.QJSValue.isQObject": (),
-    "PySide2.QtQml.QJSValue.isRegExp": (),
-    "PySide2.QtQml.QJSValue.isString": (),
-    "PySide2.QtQml.QJSValue.isUndefined": (),
-    "PySide2.QtQml.QJSValue.isVariant": (),
-    "PySide2.QtQml.QJSValue.property": [('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.prototype": (),
-    "PySide2.QtQml.QJSValue.setProperty": [('int', 'PySide2.QtQml.QJSValue'), ('str', 'PySide2.QtQml.QJSValue')],
-    "PySide2.QtQml.QJSValue.setPrototype": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.strictlyEquals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.toBool": (),
-    "PySide2.QtQml.QJSValue.toDateTime": (),
-    "PySide2.QtQml.QJSValue.toInt": (),
-    "PySide2.QtQml.QJSValue.toNumber": (),
-    "PySide2.QtQml.QJSValue.toQMetaObject": (),
-    "PySide2.QtQml.QJSValue.toQObject": (),
-    "PySide2.QtQml.QJSValue.toString": (),
-    "PySide2.QtQml.QJSValue.toUInt": (),
-    "PySide2.QtQml.QJSValue.toVariant": (),
-# class PySide2.QtQml.QJSValueIterator:
-    "PySide2.QtQml.QJSValueIterator.__init__": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValueIterator.hasNext": (),
-    "PySide2.QtQml.QJSValueIterator.name": (),
-    "PySide2.QtQml.QJSValueIterator.value": (),
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor:
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType:
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.__init__": (),
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.intercept": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType'),
-# class PySide2.QtQml.QQmlApplicationEngine:
-    "PySide2.QtQml.QQmlApplicationEngine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlApplicationEngine.load": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlApplicationEngine.loadData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlApplicationEngine.rootObjects": (),
-    "PySide2.QtQml.QQmlApplicationEngine.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtQml.QQmlComponent:
-# class PySide2.QtQml.QQmlComponent.CompilationMode:
-# class PySide2.QtQml.QQmlComponent.Status:
-    "PySide2.QtQml.QQmlComponent.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlComponent.beginCreate": ('PySide2.QtQml.QQmlContext',),
-    "PySide2.QtQml.QQmlComponent.completeCreate": (),
-    "PySide2.QtQml.QQmlComponent.create": [('PySide2.QtQml.QQmlContext',), ('PySide2.QtQml.QQmlIncubator', 'PySide2.QtQml.QQmlContext', 'PySide2.QtQml.QQmlContext')],
-    "PySide2.QtQml.QQmlComponent.createWithInitialProperties": ('typing.Dict[str, typing.Any]', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlComponent.creationContext": (),
-    "PySide2.QtQml.QQmlComponent.engine": (),
-    "PySide2.QtQml.QQmlComponent.errorString": (),
-    "PySide2.QtQml.QQmlComponent.errors": (),
-    "PySide2.QtQml.QQmlComponent.isError": (),
-    "PySide2.QtQml.QQmlComponent.isLoading": (),
-    "PySide2.QtQml.QQmlComponent.isNull": (),
-    "PySide2.QtQml.QQmlComponent.isReady": (),
-    "PySide2.QtQml.QQmlComponent.loadUrl": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode')],
-    "PySide2.QtQml.QQmlComponent.progress": (),
-    "PySide2.QtQml.QQmlComponent.setData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlComponent.setInitialProperties": ('PySide2.QtCore.QObject', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlComponent.status": (),
-    "PySide2.QtQml.QQmlComponent.url": (),
-# class PySide2.QtQml.QQmlContext:
-    "PySide2.QtQml.QQmlContext.__init__": [('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlContext.baseUrl": (),
-    "PySide2.QtQml.QQmlContext.contextObject": (),
-    "PySide2.QtQml.QQmlContext.contextProperty": ('str',),
-    "PySide2.QtQml.QQmlContext.engine": (),
-    "PySide2.QtQml.QQmlContext.isValid": (),
-    "PySide2.QtQml.QQmlContext.nameForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.parentContext": (),
-    "PySide2.QtQml.QQmlContext.resolvedUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setContextObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.setContextProperty": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Any')],
-# class PySide2.QtQml.QQmlDebuggingEnabler:
-# class PySide2.QtQml.QQmlDebuggingEnabler.StartMode:
-    "PySide2.QtQml.QQmlDebuggingEnabler.__init__": ('bool',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.connectToLocalDebugger": ('str', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.debuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.inspectorServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.nativeDebuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.profilerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.setServices": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startDebugConnector": ('str', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startTcpDebugServer": ('int', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode', 'str'),
-# class PySide2.QtQml.QQmlEngine:
-# class PySide2.QtQml.QQmlEngine.ObjectOwnership:
-    "PySide2.QtQml.QQmlEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.addImageProvider": ('str', 'PySide2.QtQml.QQmlImageProviderBase'),
-    "PySide2.QtQml.QQmlEngine.addImportPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.addNamedBundle": ('str', 'str'),
-    "PySide2.QtQml.QQmlEngine.addPluginPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.baseUrl": (),
-    "PySide2.QtQml.QQmlEngine.clearComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.contextForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQml.QQmlEngine.imageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.importPathList": (),
-    "PySide2.QtQml.QQmlEngine.importPlugin": ('str', 'str', 'typing.Sequence[PySide2.QtQml.QQmlError]'),
-    "PySide2.QtQml.QQmlEngine.incubationController": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManager": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManagerFactory": (),
-    "PySide2.QtQml.QQmlEngine.objectOwnership": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.offlineStorageDatabaseFilePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.offlineStoragePath": (),
-    "PySide2.QtQml.QQmlEngine.outputWarningsToStandardError": (),
-    "PySide2.QtQml.QQmlEngine.pluginPathList": (),
-    "PySide2.QtQml.QQmlEngine.removeImageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.retranslate": (),
-    "PySide2.QtQml.QQmlEngine.rootContext": (),
-    "PySide2.QtQml.QQmlEngine.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlEngine.setContextForObject": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlEngine.setImportPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setIncubationController": ('PySide2.QtQml.QQmlIncubationController',),
-    "PySide2.QtQml.QQmlEngine.setNetworkAccessManagerFactory": ('PySide2.QtQml.QQmlNetworkAccessManagerFactory',),
-    "PySide2.QtQml.QQmlEngine.setObjectOwnership": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine.ObjectOwnership'),
-    "PySide2.QtQml.QQmlEngine.setOfflineStoragePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.setOutputWarningsToStandardError": ('bool',),
-    "PySide2.QtQml.QQmlEngine.setPluginPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setUrlInterceptor": ('PySide2.QtQml.QQmlAbstractUrlInterceptor',),
-    "PySide2.QtQml.QQmlEngine.trimComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.urlInterceptor": (),
-# class PySide2.QtQml.QQmlError:
-    "PySide2.QtQml.QQmlError.__init__": [(), ('PySide2.QtQml.QQmlError',)],
-    "PySide2.QtQml.QQmlError.__copy__": (),
-    "PySide2.QtQml.QQmlError.column": (),
-    "PySide2.QtQml.QQmlError.description": (),
-    "PySide2.QtQml.QQmlError.isValid": (),
-    "PySide2.QtQml.QQmlError.line": (),
-    "PySide2.QtQml.QQmlError.messageType": (),
-    "PySide2.QtQml.QQmlError.object": (),
-    "PySide2.QtQml.QQmlError.setColumn": ('int',),
-    "PySide2.QtQml.QQmlError.setDescription": ('str',),
-    "PySide2.QtQml.QQmlError.setLine": ('int',),
-    "PySide2.QtQml.QQmlError.setMessageType": ('PySide2.QtCore.QtMsgType',),
-    "PySide2.QtQml.QQmlError.setObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlError.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlError.toString": (),
-    "PySide2.QtQml.QQmlError.url": (),
-# class PySide2.QtQml.QQmlExpression:
-    "PySide2.QtQml.QQmlExpression.__init__": [(), ('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlScriptString', 'PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlExpression.clearError": (),
-    "PySide2.QtQml.QQmlExpression.columnNumber": (),
-    "PySide2.QtQml.QQmlExpression.context": (),
-    "PySide2.QtQml.QQmlExpression.engine": (),
-    "PySide2.QtQml.QQmlExpression.error": (),
-    "PySide2.QtQml.QQmlExpression.evaluate": (),
-    "PySide2.QtQml.QQmlExpression.expression": (),
-    "PySide2.QtQml.QQmlExpression.hasError": (),
-    "PySide2.QtQml.QQmlExpression.lineNumber": (),
-    "PySide2.QtQml.QQmlExpression.notifyOnValueChanged": (),
-    "PySide2.QtQml.QQmlExpression.scopeObject": (),
-    "PySide2.QtQml.QQmlExpression.setExpression": ('str',),
-    "PySide2.QtQml.QQmlExpression.setNotifyOnValueChanged": ('bool',),
-    "PySide2.QtQml.QQmlExpression.setSourceLocation": ('str', 'int', 'int'),
-    "PySide2.QtQml.QQmlExpression.sourceFile": (),
-# class PySide2.QtQml.QQmlExtensionInterface:
-    "PySide2.QtQml.QQmlExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlExtensionInterface.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-# class PySide2.QtQml.QQmlExtensionPlugin:
-    "PySide2.QtQml.QQmlExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlExtensionPlugin.baseUrl": (),
-    "PySide2.QtQml.QQmlExtensionPlugin.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-    "PySide2.QtQml.QQmlExtensionPlugin.registerTypes": ('str',),
-# class PySide2.QtQml.QQmlFile:
-# class PySide2.QtQml.QQmlFile.Status:
-    "PySide2.QtQml.QQmlFile.__init__": [(), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.clear": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QQmlFile.connectDownloadProgress": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.connectFinished": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.data": (),
-    "PySide2.QtQml.QQmlFile.dataByteArray": (),
-    "PySide2.QtQml.QQmlFile.error": (),
-    "PySide2.QtQml.QQmlFile.isError": (),
-    "PySide2.QtQml.QQmlFile.isLoading": (),
-    "PySide2.QtQml.QQmlFile.isLocalFile": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.isNull": (),
-    "PySide2.QtQml.QQmlFile.isReady": (),
-    "PySide2.QtQml.QQmlFile.isSynchronous": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.load": [('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.size": (),
-    "PySide2.QtQml.QQmlFile.status": (),
-    "PySide2.QtQml.QQmlFile.url": (),
-    "PySide2.QtQml.QQmlFile.urlToLocalFileOrQrc": [('PySide2.QtCore.QUrl',), ('str',)],
-# class PySide2.QtQml.QQmlFileSelector:
-    "PySide2.QtQml.QQmlFileSelector.__init__": ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQml.QQmlFileSelector.get": ('PySide2.QtQml.QQmlEngine',),
-    "PySide2.QtQml.QQmlFileSelector.selector": (),
-    "PySide2.QtQml.QQmlFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlFileSelector.setSelector": ('PySide2.QtCore.QFileSelector',),
-# class PySide2.QtQml.QQmlImageProviderBase:
-# class PySide2.QtQml.QQmlImageProviderBase.Flag:
-# class PySide2.QtQml.QQmlImageProviderBase.Flags:
-# class PySide2.QtQml.QQmlImageProviderBase.ImageType:
-    "PySide2.QtQml.QQmlImageProviderBase.flags": (),
-    "PySide2.QtQml.QQmlImageProviderBase.imageType": (),
-# class PySide2.QtQml.QQmlIncubationController:
-    "PySide2.QtQml.QQmlIncubationController.__init__": (),
-    "PySide2.QtQml.QQmlIncubationController.engine": (),
-    "PySide2.QtQml.QQmlIncubationController.incubateFor": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubateWhile": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCount": (),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCountChanged": ('int',),
-# class PySide2.QtQml.QQmlIncubator:
-# class PySide2.QtQml.QQmlIncubator.IncubationMode:
-# class PySide2.QtQml.QQmlIncubator.Status:
-    "PySide2.QtQml.QQmlIncubator.__init__": ('PySide2.QtQml.QQmlIncubator.IncubationMode',),
-    "PySide2.QtQml.QQmlIncubator.clear": (),
-    "PySide2.QtQml.QQmlIncubator.errors": (),
-    "PySide2.QtQml.QQmlIncubator.forceCompletion": (),
-    "PySide2.QtQml.QQmlIncubator.incubationMode": (),
-    "PySide2.QtQml.QQmlIncubator.isError": (),
-    "PySide2.QtQml.QQmlIncubator.isLoading": (),
-    "PySide2.QtQml.QQmlIncubator.isNull": (),
-    "PySide2.QtQml.QQmlIncubator.isReady": (),
-    "PySide2.QtQml.QQmlIncubator.object": (),
-    "PySide2.QtQml.QQmlIncubator.setInitialState": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlIncubator.status": (),
-    "PySide2.QtQml.QQmlIncubator.statusChanged": ('PySide2.QtQml.QQmlIncubator.Status',),
-# class PySide2.QtQml.QQmlListReference:
-    "PySide2.QtQml.QQmlListReference.__init__": [(), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlListReference',)],
-    "PySide2.QtQml.QQmlListReference.__copy__": (),
-    "PySide2.QtQml.QQmlListReference.append": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlListReference.at": ('int',),
-    "PySide2.QtQml.QQmlListReference.canAppend": (),
-    "PySide2.QtQml.QQmlListReference.canAt": (),
-    "PySide2.QtQml.QQmlListReference.canClear": (),
-    "PySide2.QtQml.QQmlListReference.canCount": (),
-    "PySide2.QtQml.QQmlListReference.clear": (),
-    "PySide2.QtQml.QQmlListReference.count": (),
-    "PySide2.QtQml.QQmlListReference.isManipulable": (),
-    "PySide2.QtQml.QQmlListReference.isReadable": (),
-    "PySide2.QtQml.QQmlListReference.isValid": (),
-    "PySide2.QtQml.QQmlListReference.listElementType": (),
-    "PySide2.QtQml.QQmlListReference.object": (),
-# class PySide2.QtQml.QQmlNetworkAccessManagerFactory:
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.__init__": (),
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.create": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.QQmlParserStatus:
-    "PySide2.QtQml.QQmlParserStatus.__init__": (),
-    "PySide2.QtQml.QQmlParserStatus.classBegin": (),
-    "PySide2.QtQml.QQmlParserStatus.componentComplete": (),
-# class PySide2.QtQml.QQmlProperty:
-# class PySide2.QtQml.QQmlProperty.PropertyTypeCategory:
-# class PySide2.QtQml.QQmlProperty.Type:
-    "PySide2.QtQml.QQmlProperty.__init__": [(), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlProperty',)],
-    "PySide2.QtQml.QQmlProperty.__copy__": (),
-    "PySide2.QtQml.QQmlProperty.connectNotifySignal": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlProperty.hasNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.index": (),
-    "PySide2.QtQml.QQmlProperty.isDesignable": (),
-    "PySide2.QtQml.QQmlProperty.isProperty": (),
-    "PySide2.QtQml.QQmlProperty.isResettable": (),
-    "PySide2.QtQml.QQmlProperty.isSignalProperty": (),
-    "PySide2.QtQml.QQmlProperty.isValid": (),
-    "PySide2.QtQml.QQmlProperty.isWritable": (),
-    "PySide2.QtQml.QQmlProperty.method": (),
-    "PySide2.QtQml.QQmlProperty.name": (),
-    "PySide2.QtQml.QQmlProperty.needsNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.object": (),
-    "PySide2.QtQml.QQmlProperty.property": (),
-    "PySide2.QtQml.QQmlProperty.propertyType": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeCategory": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeName": (),
-    "PySide2.QtQml.QQmlProperty.read": [(), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine')],
-    "PySide2.QtQml.QQmlProperty.reset": (),
-    "PySide2.QtQml.QQmlProperty.type": (),
-    "PySide2.QtQml.QQmlProperty.write": [('PySide2.QtCore.QObject', 'str', 'typing.Any'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlEngine'), ('typing.Any',)],
-# class PySide2.QtQml.QQmlPropertyMap:
-    "PySide2.QtQml.QQmlPropertyMap.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlPropertyMap.clear": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.contains": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.count": (),
-    "PySide2.QtQml.QQmlPropertyMap.insert": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.isEmpty": (),
-    "PySide2.QtQml.QQmlPropertyMap.keys": (),
-    "PySide2.QtQml.QQmlPropertyMap.size": (),
-    "PySide2.QtQml.QQmlPropertyMap.updateValue": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.value": ('str',),
-# class PySide2.QtQml.QQmlPropertyValueSource:
-    "PySide2.QtQml.QQmlPropertyValueSource.__init__": (),
-    "PySide2.QtQml.QQmlPropertyValueSource.setTarget": ('PySide2.QtQml.QQmlProperty',),
-# class PySide2.QtQml.QQmlScriptString:
-    "PySide2.QtQml.QQmlScriptString.__init__": [(), ('PySide2.QtQml.QQmlScriptString',)],
-    "PySide2.QtQml.QQmlScriptString.__copy__": (),
-    "PySide2.QtQml.QQmlScriptString.booleanLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isEmpty": (),
-    "PySide2.QtQml.QQmlScriptString.isNullLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isUndefinedLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.numberLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.stringLiteral": (),
-# class PySide2.QtQml.QQmlTypesExtensionInterface:
-    "PySide2.QtQml.QQmlTypesExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlTypesExtensionInterface.registerTypes": ('str',),
-# class PySide2.QtQml.QtQml:
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObject": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObjectById": ('int', 'PySide2.QtCore.QObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlContext": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlEngine": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlExecuteDeferred": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.VolatileBool:
-    "PySide2.QtQml.VolatileBool.get": (),
-    "PySide2.QtQml.VolatileBool.set": ('object',),
-    "PySide2.QtQml.VolatileBool.qmlRegisterType": ('type', 'str', 'int', 'int', 'str'),
-    }) if "PySide2.QtQml" in sys.modules else None
-# Module PySide2.QtQuick
-sig_dict.update({
-# class PySide2.QtQuick.QQuickAsyncImageProvider:
-    "PySide2.QtQuick.QQuickAsyncImageProvider.__init__": (),
-    "PySide2.QtQuick.QQuickAsyncImageProvider.requestImageResponse": ('str', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickFramebufferObject:
-# class PySide2.QtQuick.QQuickFramebufferObject.Renderer:
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.__init__": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.createFramebufferObject": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.framebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.invalidateFramebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.render": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.synchronize": ('PySide2.QtQuick.QQuickFramebufferObject',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.update": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickFramebufferObject.createRenderer": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickFramebufferObject.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.mirrorVertically": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.releaseResources": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.setMirrorVertically": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.setTextureFollowsItemSize": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureFollowsItemSize": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickImageProvider:
-    "PySide2.QtQuick.QQuickImageProvider.__init__": ('PySide2.QtQml.QQmlImageProviderBase.ImageType', 'PySide2.QtQml.QQmlImageProviderBase.Flags'),
-    "PySide2.QtQuick.QQuickImageProvider.flags": (),
-    "PySide2.QtQuick.QQuickImageProvider.imageType": (),
-    "PySide2.QtQuick.QQuickImageProvider.requestImage": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestPixmap": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestTexture": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickImageResponse:
-    "PySide2.QtQuick.QQuickImageResponse.__init__": (),
-    "PySide2.QtQuick.QQuickImageResponse.cancel": (),
-    "PySide2.QtQuick.QQuickImageResponse.errorString": (),
-    "PySide2.QtQuick.QQuickImageResponse.textureFactory": (),
-# class PySide2.QtQuick.QQuickItem:
-# class PySide2.QtQuick.QQuickItem.Flag:
-# class PySide2.QtQuick.QQuickItem.Flags:
-# class PySide2.QtQuick.QQuickItem.ItemChange:
-# class PySide2.QtQuick.QQuickItem.TransformOrigin:
-# class PySide2.QtQuick.QQuickItem.UpdatePaintNodeData:
-    "PySide2.QtQuick.QQuickItem.UpdatePaintNodeData.__copy__": (),
-    "PySide2.QtQuick.QQuickItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.acceptHoverEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptTouchEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptedMouseButtons": (),
-    "PySide2.QtQuick.QQuickItem.activeFocusOnTab": (),
-    "PySide2.QtQuick.QQuickItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickItem.baselineOffset": (),
-    "PySide2.QtQuick.QQuickItem.boundingRect": (),
-    "PySide2.QtQuick.QQuickItem.childAt": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.childItems": (),
-    "PySide2.QtQuick.QQuickItem.childMouseEventFilter": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickItem.childrenRect": (),
-    "PySide2.QtQuick.QQuickItem.classBegin": (),
-    "PySide2.QtQuick.QQuickItem.clip": (),
-    "PySide2.QtQuick.QQuickItem.clipRect": (),
-    "PySide2.QtQuick.QQuickItem.componentComplete": (),
-    "PySide2.QtQuick.QQuickItem.containmentMask": (),
-    "PySide2.QtQuick.QQuickItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.cursor": (),
-    "PySide2.QtQuick.QQuickItem.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuick.QQuickItem.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuick.QQuickItem.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuick.QQuickItem.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuick.QQuickItem.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItem.filtersChildMouseEvents": (),
-    "PySide2.QtQuick.QQuickItem.flags": (),
-    "PySide2.QtQuick.QQuickItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.forceActiveFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtQuick.QQuickItem.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.grabMouse": (),
-    "PySide2.QtQuick.QQuickItem.grabToImage": [('PySide2.QtCore.QSize',), ('PySide2.QtQml.QJSValue', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickItem.grabTouchPoints": ('typing.List[int]',),
-    "PySide2.QtQuick.QQuickItem.hasActiveFocus": (),
-    "PySide2.QtQuick.QQuickItem.hasFocus": (),
-    "PySide2.QtQuick.QQuickItem.height": (),
-    "PySide2.QtQuick.QQuickItem.heightValid": (),
-    "PySide2.QtQuick.QQuickItem.hoverEnterEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverLeaveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverMoveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.implicitHeight": (),
-    "PySide2.QtQuick.QQuickItem.implicitWidth": (),
-    "PySide2.QtQuick.QQuickItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtQuick.QQuickItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtQuick.QQuickItem.isAncestorOf": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.isComponentComplete": (),
-    "PySide2.QtQuick.QQuickItem.isEnabled": (),
-    "PySide2.QtQuick.QQuickItem.isFocusScope": (),
-    "PySide2.QtQuick.QQuickItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickItem.isUnderMouse": (),
-    "PySide2.QtQuick.QQuickItem.isVisible": (),
-    "PySide2.QtQuick.QQuickItem.itemTransform": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.keepMouseGrab": (),
-    "PySide2.QtQuick.QQuickItem.keepTouchGrab": (),
-    "PySide2.QtQuick.QQuickItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.mapFromGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapFromScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapRectFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectFromScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapRectToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectToScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapToGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapToScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.nextItemInFocusChain": ('bool',),
-    "PySide2.QtQuick.QQuickItem.opacity": (),
-    "PySide2.QtQuick.QQuickItem.parentItem": (),
-    "PySide2.QtQuick.QQuickItem.polish": (),
-    "PySide2.QtQuick.QQuickItem.position": (),
-    "PySide2.QtQuick.QQuickItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickItem.resetAntialiasing": (),
-    "PySide2.QtQuick.QQuickItem.resetHeight": (),
-    "PySide2.QtQuick.QQuickItem.resetWidth": (),
-    "PySide2.QtQuick.QQuickItem.rotation": (),
-    "PySide2.QtQuick.QQuickItem.scale": (),
-    "PySide2.QtQuick.QQuickItem.scopedFocusItem": (),
-    "PySide2.QtQuick.QQuickItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtQuick.QQuickItem.setActiveFocusOnTab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setBaselineOffset": ('float',),
-    "PySide2.QtQuick.QQuickItem.setClip": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setContainmentMask": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtQuick.QQuickItem.setEnabled": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFiltersChildMouseEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFlag": ('PySide2.QtQuick.QQuickItem.Flag', 'bool'),
-    "PySide2.QtQuick.QQuickItem.setFlags": ('PySide2.QtQuick.QQuickItem.Flags',),
-    "PySide2.QtQuick.QQuickItem.setFocus": [('bool',), ('bool', 'PySide2.QtCore.Qt.FocusReason')],
-    "PySide2.QtQuick.QQuickItem.setHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitSize": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.setImplicitWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setKeepMouseGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setKeepTouchGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setOpacity": ('float',),
-    "PySide2.QtQuick.QQuickItem.setParentItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setRotation": ('float',),
-    "PySide2.QtQuick.QQuickItem.setScale": ('float',),
-    "PySide2.QtQuick.QQuickItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtQuick.QQuickItem.setSmooth": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setState": ('str',),
-    "PySide2.QtQuick.QQuickItem.setTransformOrigin": ('PySide2.QtQuick.QQuickItem.TransformOrigin',),
-    "PySide2.QtQuick.QQuickItem.setTransformOriginPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setVisible": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setX": ('float',),
-    "PySide2.QtQuick.QQuickItem.setY": ('float',),
-    "PySide2.QtQuick.QQuickItem.setZ": ('float',),
-    "PySide2.QtQuick.QQuickItem.size": (),
-    "PySide2.QtQuick.QQuickItem.smooth": (),
-    "PySide2.QtQuick.QQuickItem.stackAfter": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.stackBefore": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.state": (),
-    "PySide2.QtQuick.QQuickItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickItem.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtQuick.QQuickItem.touchUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.transformOrigin": (),
-    "PySide2.QtQuick.QQuickItem.transformOriginPoint": (),
-    "PySide2.QtQuick.QQuickItem.ungrabMouse": (),
-    "PySide2.QtQuick.QQuickItem.ungrabTouchPoints": (),
-    "PySide2.QtQuick.QQuickItem.unsetCursor": (),
-    "PySide2.QtQuick.QQuickItem.update": (),
-    "PySide2.QtQuick.QQuickItem.updateInputMethod": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtQuick.QQuickItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-    "PySide2.QtQuick.QQuickItem.updatePolish": (),
-    "PySide2.QtQuick.QQuickItem.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtQuick.QQuickItem.width": (),
-    "PySide2.QtQuick.QQuickItem.widthValid": (),
-    "PySide2.QtQuick.QQuickItem.window": (),
-    "PySide2.QtQuick.QQuickItem.windowDeactivateEvent": (),
-    "PySide2.QtQuick.QQuickItem.x": (),
-    "PySide2.QtQuick.QQuickItem.y": (),
-    "PySide2.QtQuick.QQuickItem.z": (),
-# class PySide2.QtQuick.QQuickItemGrabResult:
-    "PySide2.QtQuick.QQuickItemGrabResult.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItemGrabResult.image": (),
-    "PySide2.QtQuick.QQuickItemGrabResult.saveToFile": ('str',),
-    "PySide2.QtQuick.QQuickItemGrabResult.url": (),
-# class PySide2.QtQuick.QQuickPaintedItem:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHint:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHints:
-# class PySide2.QtQuick.QQuickPaintedItem.RenderTarget:
-    "PySide2.QtQuick.QQuickPaintedItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickPaintedItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsBoundingRect": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsScale": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.fillColor": (),
-    "PySide2.QtQuick.QQuickPaintedItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.mipmap": (),
-    "PySide2.QtQuick.QQuickPaintedItem.opaquePainting": (),
-    "PySide2.QtQuick.QQuickPaintedItem.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtQuick.QQuickPaintedItem.performanceHints": (),
-    "PySide2.QtQuick.QQuickPaintedItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickPaintedItem.renderTarget": (),
-    "PySide2.QtQuick.QQuickPaintedItem.resetContentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsScale": ('float',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.setFillColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickPaintedItem.setMipmap": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setOpaquePainting": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHint": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHint', 'bool'),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHints": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHints',),
-    "PySide2.QtQuick.QQuickPaintedItem.setRenderTarget": ('PySide2.QtQuick.QQuickPaintedItem.RenderTarget',),
-    "PySide2.QtQuick.QQuickPaintedItem.setTextureSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.textureSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.update": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtQuick.QQuickPaintedItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickRenderControl:
-    "PySide2.QtQuick.QQuickRenderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickRenderControl.grab": (),
-    "PySide2.QtQuick.QQuickRenderControl.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QQuickRenderControl.invalidate": (),
-    "PySide2.QtQuick.QQuickRenderControl.polishItems": (),
-    "PySide2.QtQuick.QQuickRenderControl.prepareThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtQuick.QQuickRenderControl.render": (),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindow": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindowFor": ('PySide2.QtQuick.QQuickWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtQuick.QQuickRenderControl.sync": (),
-# class PySide2.QtQuick.QQuickTextDocument:
-    "PySide2.QtQuick.QQuickTextDocument.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTextDocument.textDocument": (),
-# class PySide2.QtQuick.QQuickTextureFactory:
-    "PySide2.QtQuick.QQuickTextureFactory.__init__": (),
-    "PySide2.QtQuick.QQuickTextureFactory.createTexture": ('PySide2.QtQuick.QQuickWindow',),
-    "PySide2.QtQuick.QQuickTextureFactory.image": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureByteCount": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureFactoryForImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtQuick.QQuickTextureFactory.textureSize": (),
-# class PySide2.QtQuick.QQuickTransform:
-    "PySide2.QtQuick.QQuickTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickTransform.appendToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QQuickTransform.prependToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.update": (),
-# class PySide2.QtQuick.QQuickView:
-# class PySide2.QtQuick.QQuickView.ResizeMode:
-# class PySide2.QtQuick.QQuickView.Status:
-    "PySide2.QtQuick.QQuickView.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtGui.QWindow'), ('PySide2.QtCore.QUrl', 'PySide2.QtQuick.QQuickRenderControl'), ('PySide2.QtGui.QWindow',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtQuick.QQuickView.engine": (),
-    "PySide2.QtQuick.QQuickView.errors": (),
-    "PySide2.QtQuick.QQuickView.initialSize": (),
-    "PySide2.QtQuick.QQuickView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickView.resizeMode": (),
-    "PySide2.QtQuick.QQuickView.rootContext": (),
-    "PySide2.QtQuick.QQuickView.rootObject": (),
-    "PySide2.QtQuick.QQuickView.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuick.QQuickView.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtQuick.QQuickView.setResizeMode": ('PySide2.QtQuick.QQuickView.ResizeMode',),
-    "PySide2.QtQuick.QQuickView.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuick.QQuickView.sizeHint": (),
-    "PySide2.QtQuick.QQuickView.source": (),
-    "PySide2.QtQuick.QQuickView.status": (),
-    "PySide2.QtQuick.QQuickView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtQuick.QQuickWindow:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOption:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOptions:
-# class PySide2.QtQuick.QQuickWindow.NativeObjectType:
-# class PySide2.QtQuick.QQuickWindow.RenderStage:
-# class PySide2.QtQuick.QQuickWindow.SceneGraphError:
-# class PySide2.QtQuick.QQuickWindow.TextRenderType:
-    "PySide2.QtQuick.QQuickWindow.__init__": [('PySide2.QtGui.QWindow',), ('PySide2.QtQuick.QQuickRenderControl',)],
-    "PySide2.QtQuick.QQuickWindow.accessibleRoot": (),
-    "PySide2.QtQuick.QQuickWindow.activeFocusItem": (),
-    "PySide2.QtQuick.QQuickWindow.beginExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.clearBeforeRendering": (),
-    "PySide2.QtQuick.QQuickWindow.color": (),
-    "PySide2.QtQuick.QQuickWindow.contentItem": (),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromImage": [('PySide2.QtGui.QImage',), ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions')],
-    "PySide2.QtQuick.QQuickWindow.createTextureFromNativeObject": ('PySide2.QtQuick.QQuickWindow.NativeObjectType', 'int', 'int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.effectiveDevicePixelRatio": (),
-    "PySide2.QtQuick.QQuickWindow.endExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusObject": (),
-    "PySide2.QtQuick.QQuickWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.grabWindow": (),
-    "PySide2.QtQuick.QQuickWindow.hasDefaultAlphaBuffer": (),
-    "PySide2.QtQuick.QQuickWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuick.QQuickWindow.incubationController": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentOpenGLContext": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentSceneGraph": (),
-    "PySide2.QtQuick.QQuickWindow.isSceneGraphInitialized": (),
-    "PySide2.QtQuick.QQuickWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseGrabberItem": (),
-    "PySide2.QtQuick.QQuickWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.openglContext": (),
-    "PySide2.QtQuick.QQuickWindow.releaseResources": (),
-    "PySide2.QtQuick.QQuickWindow.renderTarget": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetId": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetSize": (),
-    "PySide2.QtQuick.QQuickWindow.resetOpenGLState": (),
-    "PySide2.QtQuick.QQuickWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickWindow.sceneGraphBackend": (),
-    "PySide2.QtQuick.QQuickWindow.scheduleRenderJob": ('PySide2.QtCore.QRunnable', 'PySide2.QtQuick.QQuickWindow.RenderStage'),
-    "PySide2.QtQuick.QQuickWindow.sendEvent": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickWindow.setClearBeforeRendering": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickWindow.setDefaultAlphaBuffer": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentOpenGLContext": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentSceneGraph": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setRenderTarget": [('PySide2.QtGui.QOpenGLFramebufferObject',), ('int', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickWindow.setSceneGraphBackend": ('str',),
-    "PySide2.QtQuick.QQuickWindow.setTextRenderType": ('PySide2.QtQuick.QQuickWindow.TextRenderType',),
-    "PySide2.QtQuick.QQuickWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuick.QQuickWindow.textRenderType": (),
-    "PySide2.QtQuick.QQuickWindow.update": (),
-    "PySide2.QtQuick.QQuickWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtQuick.QSGAbstractRenderer:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearMode:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearModeBit:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlag:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags:
-    "PySide2.QtQuick.QSGAbstractRenderer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearColor": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearMode": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.deviceRect": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.nodeChanged": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode.DirtyState'),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrix": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrixWithNativeNDC": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.renderScene": ('int',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearMode": ('PySide2.QtQuick.QSGAbstractRenderer.ClearMode',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setDeviceRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixToRect": [('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRectF', 'PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags')],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixWithNativeNDC": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setViewportRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.viewportRect": (),
-# class PySide2.QtQuick.QSGBasicGeometryNode:
-    "PySide2.QtQuick.QSGBasicGeometryNode.__init__": ('PySide2.QtQuick.QSGNode.NodeType',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.clipList": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.geometry": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.matrix": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setGeometry": ('PySide2.QtQuick.QSGGeometry',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererClipList": ('PySide2.QtQuick.QSGClipNode',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSGClipNode:
-    "PySide2.QtQuick.QSGClipNode.__init__": (),
-    "PySide2.QtQuick.QSGClipNode.clipRect": (),
-    "PySide2.QtQuick.QSGClipNode.isRectangular": (),
-    "PySide2.QtQuick.QSGClipNode.setClipRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGClipNode.setIsRectangular": ('bool',),
-# class PySide2.QtQuick.QSGDynamicTexture:
-    "PySide2.QtQuick.QSGDynamicTexture.__init__": (),
-    "PySide2.QtQuick.QSGDynamicTexture.updateTexture": (),
-# class PySide2.QtQuick.QSGEngine:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOption:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOptions:
-    "PySide2.QtQuick.QSGEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGEngine.createRenderer": (),
-    "PySide2.QtQuick.QSGEngine.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.createTextureFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QSGEngine.invalidate": (),
-# class PySide2.QtQuick.QSGGeometry:
-# class PySide2.QtQuick.QSGGeometry.Attribute:
-    "PySide2.QtQuick.QSGGeometry.Attribute.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Attribute',)],
-    "PySide2.QtQuick.QSGGeometry.Attribute.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Attribute.create": ('int', 'int', 'int', 'bool'),
-    "PySide2.QtQuick.QSGGeometry.Attribute.createWithAttributeType": ('int', 'int', 'int', 'PySide2.QtQuick.QSGGeometry.AttributeType'),
-# class PySide2.QtQuick.QSGGeometry.AttributeSet:
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__init__": [(), ('PySide2.QtQuick.QSGGeometry.AttributeSet',)],
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__copy__": (),
-# class PySide2.QtQuick.QSGGeometry.AttributeType:
-# class PySide2.QtQuick.QSGGeometry.ColoredPoint2D:
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.ColoredPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.set": ('float', 'float', 'int', 'int', 'int', 'int'),
-# class PySide2.QtQuick.QSGGeometry.DataPattern:
-# class PySide2.QtQuick.QSGGeometry.DrawingMode:
-# class PySide2.QtQuick.QSGGeometry.Point2D:
-    "PySide2.QtQuick.QSGGeometry.Point2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Point2D',)],
-    "PySide2.QtQuick.QSGGeometry.Point2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Point2D.set": ('float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.TexturedPoint2D:
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.TexturedPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.set": ('float', 'float', 'float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.Type:
-    "PySide2.QtQuick.QSGGeometry.__init__": ('PySide2.QtQuick.QSGGeometry.AttributeSet', 'int', 'int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.allocate": ('int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.attributeCount": (),
-    "PySide2.QtQuick.QSGGeometry.attributes": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_ColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_Point2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_TexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.drawingMode": (),
-    "PySide2.QtQuick.QSGGeometry.indexCount": (),
-    "PySide2.QtQuick.QSGGeometry.indexData": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUInt": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUShort": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataPattern": (),
-    "PySide2.QtQuick.QSGGeometry.indexType": (),
-    "PySide2.QtQuick.QSGGeometry.lineWidth": (),
-    "PySide2.QtQuick.QSGGeometry.markIndexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.markVertexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.setDrawingMode": ('int',),
-    "PySide2.QtQuick.QSGGeometry.setIndexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.setLineWidth": ('float',),
-    "PySide2.QtQuick.QSGGeometry.setVertexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.sizeOfIndex": (),
-    "PySide2.QtQuick.QSGGeometry.sizeOfVertex": (),
-    "PySide2.QtQuick.QSGGeometry.updateColoredRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateTexturedRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.vertexCount": (),
-    "PySide2.QtQuick.QSGGeometry.vertexData": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsTexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataPattern": (),
-# class PySide2.QtQuick.QSGGeometryNode:
-    "PySide2.QtQuick.QSGGeometryNode.__init__": (),
-    "PySide2.QtQuick.QSGGeometryNode.inheritedOpacity": (),
-    "PySide2.QtQuick.QSGGeometryNode.renderOrder": (),
-    "PySide2.QtQuick.QSGGeometryNode.setInheritedOpacity": ('float',),
-    "PySide2.QtQuick.QSGGeometryNode.setRenderOrder": ('int',),
-# class PySide2.QtQuick.QSGMaterialType:
-    "PySide2.QtQuick.QSGMaterialType.__init__": (),
-# class PySide2.QtQuick.QSGNode:
-# class PySide2.QtQuick.QSGNode.DirtyState:
-# class PySide2.QtQuick.QSGNode.DirtyStateBit:
-# class PySide2.QtQuick.QSGNode.Flag:
-# class PySide2.QtQuick.QSGNode.Flags:
-# class PySide2.QtQuick.QSGNode.NodeType:
-    "PySide2.QtQuick.QSGNode.__init__": [(), ('PySide2.QtQuick.QSGNode.NodeType',)],
-    "PySide2.QtQuick.QSGNode.appendChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.childAtIndex": ('int',),
-    "PySide2.QtQuick.QSGNode.childCount": (),
-    "PySide2.QtQuick.QSGNode.clearDirty": (),
-    "PySide2.QtQuick.QSGNode.dirtyState": (),
-    "PySide2.QtQuick.QSGNode.firstChild": (),
-    "PySide2.QtQuick.QSGNode.flags": (),
-    "PySide2.QtQuick.QSGNode.insertChildNodeAfter": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.insertChildNodeBefore": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGNode.lastChild": (),
-    "PySide2.QtQuick.QSGNode.markDirty": ('PySide2.QtQuick.QSGNode.DirtyState',),
-    "PySide2.QtQuick.QSGNode.nextSibling": (),
-    "PySide2.QtQuick.QSGNode.parent": (),
-    "PySide2.QtQuick.QSGNode.prependChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.preprocess": (),
-    "PySide2.QtQuick.QSGNode.previousSibling": (),
-    "PySide2.QtQuick.QSGNode.removeAllChildNodes": (),
-    "PySide2.QtQuick.QSGNode.removeChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.reparentChildNodesTo": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.setFlag": ('PySide2.QtQuick.QSGNode.Flag', 'bool'),
-    "PySide2.QtQuick.QSGNode.setFlags": ('PySide2.QtQuick.QSGNode.Flags', 'bool'),
-    "PySide2.QtQuick.QSGNode.type": (),
-# class PySide2.QtQuick.QSGOpacityNode:
-    "PySide2.QtQuick.QSGOpacityNode.__init__": (),
-    "PySide2.QtQuick.QSGOpacityNode.combinedOpacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGOpacityNode.opacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.setCombinedOpacity": ('float',),
-    "PySide2.QtQuick.QSGOpacityNode.setOpacity": ('float',),
-# class PySide2.QtQuick.QSGSimpleRectNode:
-    "PySide2.QtQuick.QSGSimpleRectNode.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor')],
-    "PySide2.QtQuick.QSGSimpleRectNode.color": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGSimpleRectNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-# class PySide2.QtQuick.QSGSimpleTextureNode:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformFlag:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode:
-    "PySide2.QtQuick.QSGSimpleTextureNode.__init__": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.filtering": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.ownsTexture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setOwnsTexture": ('bool',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setSourceRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTexture": ('PySide2.QtQuick.QSGTexture',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTextureCoordinatesTransform": ('PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.sourceRect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.texture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.textureCoordinatesTransform": (),
-# class PySide2.QtQuick.QSGTexture:
-# class PySide2.QtQuick.QSGTexture.AnisotropyLevel:
-# class PySide2.QtQuick.QSGTexture.Filtering:
-# class PySide2.QtQuick.QSGTexture.WrapMode:
-    "PySide2.QtQuick.QSGTexture.__init__": (),
-    "PySide2.QtQuick.QSGTexture.anisotropyLevel": (),
-    "PySide2.QtQuick.QSGTexture.bind": (),
-    "PySide2.QtQuick.QSGTexture.comparisonKey": (),
-    "PySide2.QtQuick.QSGTexture.convertToNormalizedSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGTexture.filtering": (),
-    "PySide2.QtQuick.QSGTexture.hasAlphaChannel": (),
-    "PySide2.QtQuick.QSGTexture.hasMipmaps": (),
-    "PySide2.QtQuick.QSGTexture.horizontalWrapMode": (),
-    "PySide2.QtQuick.QSGTexture.isAtlasTexture": (),
-    "PySide2.QtQuick.QSGTexture.mipmapFiltering": (),
-    "PySide2.QtQuick.QSGTexture.normalizedTextureSubRect": (),
-    "PySide2.QtQuick.QSGTexture.removedFromAtlas": (),
-    "PySide2.QtQuick.QSGTexture.setAnisotropyLevel": ('PySide2.QtQuick.QSGTexture.AnisotropyLevel',),
-    "PySide2.QtQuick.QSGTexture.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setHorizontalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.setMipmapFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setVerticalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.textureId": (),
-    "PySide2.QtQuick.QSGTexture.textureSize": (),
-    "PySide2.QtQuick.QSGTexture.updateBindOptions": ('bool',),
-    "PySide2.QtQuick.QSGTexture.verticalWrapMode": (),
-# class PySide2.QtQuick.QSGTextureProvider:
-    "PySide2.QtQuick.QSGTextureProvider.__init__": (),
-    "PySide2.QtQuick.QSGTextureProvider.texture": (),
-# class PySide2.QtQuick.QSGTransformNode:
-    "PySide2.QtQuick.QSGTransformNode.__init__": (),
-    "PySide2.QtQuick.QSGTransformNode.combinedMatrix": (),
-    "PySide2.QtQuick.QSGTransformNode.matrix": (),
-    "PySide2.QtQuick.QSGTransformNode.setCombinedMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGTransformNode.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >:
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.__copy__": (),
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.data": (),
-    }) if "PySide2.QtQuick" in sys.modules else None
-# Module PySide2.QtQuickWidgets
-sig_dict.update({
-# class PySide2.QtQuickWidgets.QQuickWidget:
-# class PySide2.QtQuickWidgets.QQuickWidget.ResizeMode:
-# class PySide2.QtQuickWidgets.QQuickWidget.Status:
-    "PySide2.QtQuickWidgets.QQuickWidget.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtQuickWidgets.QQuickWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.engine": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.errors": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.format": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.grabFramebuffer": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.initialSize": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.quickWindow": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeMode": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootContext": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootObject": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuickWidgets.QQuickWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setResizeMode": ('PySide2.QtQuickWidgets.QQuickWidget.ResizeMode',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuickWidgets.QQuickWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.sizeHint": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.source": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.status": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    }) if "PySide2.QtQuickWidgets" in sys.modules else None
-# Module PySide2.QtRemoteObjects
-sig_dict.update({
-# class PySide2.QtRemoteObjects.QAbstractItemModelReplica:
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.availableRoles": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasData": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.roleNames": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.selectionModel": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-# class PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-# class PySide2.QtRemoteObjects.QRemoteObjectDynamicReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase:
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas:
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.addHostSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.disableRemoting": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.enableRemoting": [('PySide2.QtCore.QAbstractItemModel', 'str', 'typing.List[int]', 'PySide2.QtCore.QItemSelectionModel'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.proxy": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.reverseProxy": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setName": ('str',),
-# class PySide2.QtRemoteObjects.QRemoteObjectNode:
-# class PySide2.QtRemoteObjects.QRemoteObjectNode.ErrorCode:
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireDynamic": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireModel": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.addClientSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.connectToNode": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.heartbeatInterval": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.instances": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.lastError": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.persistedStore": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registry": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registryUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setHeartbeatInterval": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setName": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setPersistedStore": ('PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.waitForRegistry": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall:
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall.Error:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.__init__": [(), ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall',)],
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.error": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.fromCompletedCall": ('typing.Any',),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.returnValue": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.waitForFinished": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.__init__": ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.waitForFinished": [(), ('int',)],
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistry:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.pushToRegistryIfNeeded": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.registerMetatypes": (),
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistryHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.__init__": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica.State:
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.__init__": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initializeNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode', 'str'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isReplicaValid": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.node": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.persistProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.propAsVariant": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.retrieveProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.send": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.sendWithReply": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setChild": ('int', 'typing.Any'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setProperties": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.state": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.waitForSource": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectSettingsStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    }) if "PySide2.QtRemoteObjects" in sys.modules else None
-# Module PySide2.QtScxml
-sig_dict.update({
-# class PySide2.QtScxml.QScxmlCompiler:
-# class PySide2.QtScxml.QScxmlCompiler.Loader:
-    "PySide2.QtScxml.QScxmlCompiler.Loader.__init__": (),
-    "PySide2.QtScxml.QScxmlCompiler.Loader.load": ('str', 'str'),
-    "PySide2.QtScxml.QScxmlCompiler.__init__": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtScxml.QScxmlCompiler.compile": (),
-    "PySide2.QtScxml.QScxmlCompiler.errors": (),
-    "PySide2.QtScxml.QScxmlCompiler.fileName": (),
-    "PySide2.QtScxml.QScxmlCompiler.loader": (),
-    "PySide2.QtScxml.QScxmlCompiler.setFileName": ('str',),
-    "PySide2.QtScxml.QScxmlCompiler.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-# class PySide2.QtScxml.QScxmlCppDataModel:
-    "PySide2.QtScxml.QScxmlCppDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.inState": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlEvent": (),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlCppDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlDataModel:
-# class PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody:
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.__init__": (),
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.run": (),
-    "PySide2.QtScxml.QScxmlDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlDataModel.setStateMachine": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlDataModel.setup": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlDataModel.stateMachine": (),
-# class PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlEcmaScriptDataModel:
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlError:
-    "PySide2.QtScxml.QScxmlError.__init__": [(), ('PySide2.QtScxml.QScxmlError',), ('str', 'int', 'int', 'str')],
-    "PySide2.QtScxml.QScxmlError.__copy__": (),
-    "PySide2.QtScxml.QScxmlError.column": (),
-    "PySide2.QtScxml.QScxmlError.description": (),
-    "PySide2.QtScxml.QScxmlError.fileName": (),
-    "PySide2.QtScxml.QScxmlError.isValid": (),
-    "PySide2.QtScxml.QScxmlError.line": (),
-    "PySide2.QtScxml.QScxmlError.toString": (),
-# class PySide2.QtScxml.QScxmlEvent:
-# class PySide2.QtScxml.QScxmlEvent.EventType:
-    "PySide2.QtScxml.QScxmlEvent.__init__": [(), ('PySide2.QtScxml.QScxmlEvent',)],
-    "PySide2.QtScxml.QScxmlEvent.clear": (),
-    "PySide2.QtScxml.QScxmlEvent.data": (),
-    "PySide2.QtScxml.QScxmlEvent.delay": (),
-    "PySide2.QtScxml.QScxmlEvent.errorMessage": (),
-    "PySide2.QtScxml.QScxmlEvent.eventType": (),
-    "PySide2.QtScxml.QScxmlEvent.invokeId": (),
-    "PySide2.QtScxml.QScxmlEvent.isErrorEvent": (),
-    "PySide2.QtScxml.QScxmlEvent.name": (),
-    "PySide2.QtScxml.QScxmlEvent.origin": (),
-    "PySide2.QtScxml.QScxmlEvent.originType": (),
-    "PySide2.QtScxml.QScxmlEvent.scxmlType": (),
-    "PySide2.QtScxml.QScxmlEvent.sendId": (),
-    "PySide2.QtScxml.QScxmlEvent.setData": ('typing.Any',),
-    "PySide2.QtScxml.QScxmlEvent.setDelay": ('int',),
-    "PySide2.QtScxml.QScxmlEvent.setErrorMessage": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setEventType": ('PySide2.QtScxml.QScxmlEvent.EventType',),
-    "PySide2.QtScxml.QScxmlEvent.setInvokeId": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setName": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOrigin": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOriginType": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setSendId": ('str',),
-# class PySide2.QtScxml.QScxmlExecutableContent:
-# class PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlInvokableService:
-    "PySide2.QtScxml.QScxmlInvokableService.__init__": ('PySide2.QtScxml.QScxmlStateMachine', 'PySide2.QtScxml.QScxmlInvokableServiceFactory'),
-    "PySide2.QtScxml.QScxmlInvokableService.id": (),
-    "PySide2.QtScxml.QScxmlInvokableService.name": (),
-    "PySide2.QtScxml.QScxmlInvokableService.parentStateMachine": (),
-    "PySide2.QtScxml.QScxmlInvokableService.postEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlInvokableService.start": (),
-# class PySide2.QtScxml.QScxmlInvokableServiceFactory:
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invokeInfo": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.names": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.parameters": (),
-# class PySide2.QtScxml.QScxmlNullDataModel:
-    "PySide2.QtScxml.QScxmlNullDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlNullDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlStateMachine:
-    "PySide2.QtScxml.QScxmlStateMachine.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStateMachine.activeStateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.cancelDelayedEvent": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToEvent": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToState": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.dataModel": (),
-    "PySide2.QtScxml.QScxmlStateMachine.fromData": ('PySide2.QtCore.QIODevice', 'str'),
-    "PySide2.QtScxml.QScxmlStateMachine.fromFile": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.init": (),
-    "PySide2.QtScxml.QScxmlStateMachine.initialValues": (),
-    "PySide2.QtScxml.QScxmlStateMachine.invokedServices": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isActive": [('int',), ('str',)],
-    "PySide2.QtScxml.QScxmlStateMachine.isDispatchableTarget": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.isInitialized": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isInvoked": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isRunning": (),
-    "PySide2.QtScxml.QScxmlStateMachine.loader": (),
-    "PySide2.QtScxml.QScxmlStateMachine.name": (),
-    "PySide2.QtScxml.QScxmlStateMachine.parseErrors": (),
-    "PySide2.QtScxml.QScxmlStateMachine.sessionId": (),
-    "PySide2.QtScxml.QScxmlStateMachine.setDataModel": ('PySide2.QtScxml.QScxmlDataModel',),
-    "PySide2.QtScxml.QScxmlStateMachine.setInitialValues": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlStateMachine.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-    "PySide2.QtScxml.QScxmlStateMachine.setRunning": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.setTableData": ('PySide2.QtScxml.QScxmlTableData',),
-    "PySide2.QtScxml.QScxmlStateMachine.start": (),
-    "PySide2.QtScxml.QScxmlStateMachine.stateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.stop": (),
-    "PySide2.QtScxml.QScxmlStateMachine.submitEvent": [('PySide2.QtScxml.QScxmlEvent',), ('str',), ('str', 'typing.Any')],
-    "PySide2.QtScxml.QScxmlStateMachine.tableData": (),
-# class PySide2.QtScxml.QScxmlStaticScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlTableData:
-    "PySide2.QtScxml.QScxmlTableData.__init__": (),
-    "PySide2.QtScxml.QScxmlTableData.assignmentInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.dataNames": (),
-    "PySide2.QtScxml.QScxmlTableData.evaluatorInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.foreachInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.initialSetup": (),
-    "PySide2.QtScxml.QScxmlTableData.instructions": (),
-    "PySide2.QtScxml.QScxmlTableData.name": (),
-    "PySide2.QtScxml.QScxmlTableData.serviceFactory": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.stateMachineTable": (),
-    "PySide2.QtScxml.QScxmlTableData.string": ('int',),
-    }) if "PySide2.QtScxml" in sys.modules else None
-# Module PySide2.QtScript
-sig_dict.update({
-# class PySide2.QtScript.QScriptClass:
-# class PySide2.QtScript.QScriptClass.Extension:
-# class PySide2.QtScript.QScriptClass.QueryFlag:
-    "PySide2.QtScript.QScriptClass.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptClass.engine": (),
-    "PySide2.QtScript.QScriptClass.extension": ('PySide2.QtScript.QScriptClass.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptClass.name": (),
-    "PySide2.QtScript.QScriptClass.newIterator": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClass.property": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.propertyFlags": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.prototype": (),
-    "PySide2.QtScript.QScriptClass.setProperty": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptClass.supportsExtension": ('PySide2.QtScript.QScriptClass.Extension',),
-# class PySide2.QtScript.QScriptClassPropertyIterator:
-    "PySide2.QtScript.QScriptClassPropertyIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClassPropertyIterator.flags": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasNext": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.id": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.name": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.object": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.previous": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toBack": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toFront": (),
-# class PySide2.QtScript.QScriptContext:
-# class PySide2.QtScript.QScriptContext.Error:
-# class PySide2.QtScript.QScriptContext.ExecutionState:
-    "PySide2.QtScript.QScriptContext.activationObject": (),
-    "PySide2.QtScript.QScriptContext.argument": ('int',),
-    "PySide2.QtScript.QScriptContext.argumentCount": (),
-    "PySide2.QtScript.QScriptContext.argumentsObject": (),
-    "PySide2.QtScript.QScriptContext.backtrace": (),
-    "PySide2.QtScript.QScriptContext.callee": (),
-    "PySide2.QtScript.QScriptContext.engine": (),
-    "PySide2.QtScript.QScriptContext.isCalledAsConstructor": (),
-    "PySide2.QtScript.QScriptContext.parentContext": (),
-    "PySide2.QtScript.QScriptContext.popScope": (),
-    "PySide2.QtScript.QScriptContext.pushScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.returnValue": (),
-    "PySide2.QtScript.QScriptContext.scopeChain": (),
-    "PySide2.QtScript.QScriptContext.setActivationObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setReturnValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setThisObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.state": (),
-    "PySide2.QtScript.QScriptContext.thisObject": (),
-    "PySide2.QtScript.QScriptContext.throwError": [('PySide2.QtScript.QScriptContext.Error', 'str'), ('str',)],
-    "PySide2.QtScript.QScriptContext.throwValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.toString": (),
-# class PySide2.QtScript.QScriptContextInfo:
-# class PySide2.QtScript.QScriptContextInfo.FunctionType:
-    "PySide2.QtScript.QScriptContextInfo.__init__": [(), ('PySide2.QtScript.QScriptContext',), ('PySide2.QtScript.QScriptContextInfo',)],
-    "PySide2.QtScript.QScriptContextInfo.__copy__": (),
-    "PySide2.QtScript.QScriptContextInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.columnNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.fileName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionEndLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionMetaIndex": (),
-    "PySide2.QtScript.QScriptContextInfo.functionName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionParameterNames": (),
-    "PySide2.QtScript.QScriptContextInfo.functionStartLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionType": (),
-    "PySide2.QtScript.QScriptContextInfo.isNull": (),
-    "PySide2.QtScript.QScriptContextInfo.lineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.scriptId": (),
-# class PySide2.QtScript.QScriptEngine:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOption:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOptions:
-# class PySide2.QtScript.QScriptEngine.ValueOwnership:
-    "PySide2.QtScript.QScriptEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtScript.QScriptEngine.abortEvaluation": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.agent": (),
-    "PySide2.QtScript.QScriptEngine.availableExtensions": (),
-    "PySide2.QtScript.QScriptEngine.canEvaluate": ('str',),
-    "PySide2.QtScript.QScriptEngine.clearExceptions": (),
-    "PySide2.QtScript.QScriptEngine.collectGarbage": (),
-    "PySide2.QtScript.QScriptEngine.currentContext": (),
-    "PySide2.QtScript.QScriptEngine.defaultPrototype": ('int',),
-    "PySide2.QtScript.QScriptEngine.evaluate": [('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptEngine.globalObject": (),
-    "PySide2.QtScript.QScriptEngine.hasUncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.importExtension": ('str',),
-    "PySide2.QtScript.QScriptEngine.importedExtensions": (),
-    "PySide2.QtScript.QScriptEngine.installTranslatorFunctions": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.isEvaluating": (),
-    "PySide2.QtScript.QScriptEngine.newActivationObject": (),
-    "PySide2.QtScript.QScriptEngine.newArray": ('int',),
-    "PySide2.QtScript.QScriptEngine.newDate": [('PySide2.QtCore.QDateTime',), ('float',)],
-    "PySide2.QtScript.QScriptEngine.newObject": [(), ('PySide2.QtScript.QScriptClass', 'PySide2.QtScript.QScriptValue')],
-    "PySide2.QtScript.QScriptEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.newQObject": [('PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions'), ('PySide2.QtScript.QScriptValue', 'PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions')],
-    "PySide2.QtScript.QScriptEngine.newRegExp": [('PySide2.QtCore.QRegExp',), ('str', 'str')],
-    "PySide2.QtScript.QScriptEngine.newVariant": [('PySide2.QtScript.QScriptValue', 'typing.Any'), ('typing.Any',)],
-    "PySide2.QtScript.QScriptEngine.nullValue": (),
-    "PySide2.QtScript.QScriptEngine.objectById": ('int',),
-    "PySide2.QtScript.QScriptEngine.popContext": (),
-    "PySide2.QtScript.QScriptEngine.processEventsInterval": (),
-    "PySide2.QtScript.QScriptEngine.pushContext": (),
-    "PySide2.QtScript.QScriptEngine.reportAdditionalMemoryCost": ('int',),
-    "PySide2.QtScript.QScriptEngine.setAgent": ('PySide2.QtScript.QScriptEngineAgent',),
-    "PySide2.QtScript.QScriptEngine.setDefaultPrototype": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.setGlobalObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.setProcessEventsInterval": ('int',),
-    "PySide2.QtScript.QScriptEngine.toObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.toStringHandle": ('str',),
-    "PySide2.QtScript.QScriptEngine.uncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionBacktrace": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionLineNumber": (),
-    "PySide2.QtScript.QScriptEngine.undefinedValue": (),
-# class PySide2.QtScript.QScriptEngineAgent:
-# class PySide2.QtScript.QScriptEngineAgent.Extension:
-    "PySide2.QtScript.QScriptEngineAgent.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptEngineAgent.contextPop": (),
-    "PySide2.QtScript.QScriptEngineAgent.contextPush": (),
-    "PySide2.QtScript.QScriptEngineAgent.engine": (),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionCatch": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionThrow": ('int', 'PySide2.QtScript.QScriptValue', 'bool'),
-    "PySide2.QtScript.QScriptEngineAgent.extension": ('PySide2.QtScript.QScriptEngineAgent.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptEngineAgent.functionEntry": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.functionExit": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.positionChange": ('int', 'int', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptLoad": ('int', 'str', 'str', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptUnload": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.supportsExtension": ('PySide2.QtScript.QScriptEngineAgent.Extension',),
-# class PySide2.QtScript.QScriptExtensionInterface:
-    "PySide2.QtScript.QScriptExtensionInterface.__init__": (),
-    "PySide2.QtScript.QScriptExtensionInterface.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptExtensionPlugin:
-    "PySide2.QtScript.QScriptExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScript.QScriptExtensionPlugin.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-    "PySide2.QtScript.QScriptExtensionPlugin.keys": (),
-    "PySide2.QtScript.QScriptExtensionPlugin.setupPackage": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptProgram:
-    "PySide2.QtScript.QScriptProgram.__init__": [(), ('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptProgram.__copy__": (),
-    "PySide2.QtScript.QScriptProgram.fileName": (),
-    "PySide2.QtScript.QScriptProgram.firstLineNumber": (),
-    "PySide2.QtScript.QScriptProgram.isNull": (),
-    "PySide2.QtScript.QScriptProgram.sourceCode": (),
-# class PySide2.QtScript.QScriptString:
-    "PySide2.QtScript.QScriptString.__init__": [(), ('PySide2.QtScript.QScriptString',)],
-    "PySide2.QtScript.QScriptString.__copy__": (),
-    "PySide2.QtScript.QScriptString.isValid": (),
-    "PySide2.QtScript.QScriptString.toArrayIndex": (),
-    "PySide2.QtScript.QScriptString.toString": (),
-# class PySide2.QtScript.QScriptValue:
-# class PySide2.QtScript.QScriptValue.PropertyFlag:
-# class PySide2.QtScript.QScriptValue.PropertyFlags:
-# class PySide2.QtScript.QScriptValue.ResolveFlag:
-# class PySide2.QtScript.QScriptValue.ResolveFlags:
-# class PySide2.QtScript.QScriptValue.SpecialValue:
-    "PySide2.QtScript.QScriptValue.__init__": [(), ('PySide2.QtScript.QScriptEngine', 'PySide2.QtScript.QScriptValue.SpecialValue'), ('PySide2.QtScript.QScriptEngine', 'bool'), ('PySide2.QtScript.QScriptEngine', 'float'), ('PySide2.QtScript.QScriptEngine', 'int'), ('PySide2.QtScript.QScriptEngine', 'str'), ('PySide2.QtScript.QScriptValue',), ('PySide2.QtScript.QScriptValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtScript.QScriptValue.__copy__": (),
-    "PySide2.QtScript.QScriptValue.__iter__": (),
-    "PySide2.QtScript.QScriptValue.__repr__": (),
-    "PySide2.QtScript.QScriptValue.call": [('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue'), ('PySide2.QtScript.QScriptValue', 'typing.Sequence[PySide2.QtScript.QScriptValue]')],
-    "PySide2.QtScript.QScriptValue.construct": [('PySide2.QtScript.QScriptValue',), ('typing.Sequence[PySide2.QtScript.QScriptValue]',)],
-    "PySide2.QtScript.QScriptValue.data": (),
-    "PySide2.QtScript.QScriptValue.engine": (),
-    "PySide2.QtScript.QScriptValue.equals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.instanceOf": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.isArray": (),
-    "PySide2.QtScript.QScriptValue.isBool": (),
-    "PySide2.QtScript.QScriptValue.isBoolean": (),
-    "PySide2.QtScript.QScriptValue.isDate": (),
-    "PySide2.QtScript.QScriptValue.isError": (),
-    "PySide2.QtScript.QScriptValue.isFunction": (),
-    "PySide2.QtScript.QScriptValue.isNull": (),
-    "PySide2.QtScript.QScriptValue.isNumber": (),
-    "PySide2.QtScript.QScriptValue.isObject": (),
-    "PySide2.QtScript.QScriptValue.isQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.isQObject": (),
-    "PySide2.QtScript.QScriptValue.isRegExp": (),
-    "PySide2.QtScript.QScriptValue.isString": (),
-    "PySide2.QtScript.QScriptValue.isUndefined": (),
-    "PySide2.QtScript.QScriptValue.isValid": (),
-    "PySide2.QtScript.QScriptValue.isVariant": (),
-    "PySide2.QtScript.QScriptValue.lessThan": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.objectId": (),
-    "PySide2.QtScript.QScriptValue.property": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('int', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.propertyFlags": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.prototype": (),
-    "PySide2.QtScript.QScriptValue.scope": (),
-    "PySide2.QtScript.QScriptValue.scriptClass": (),
-    "PySide2.QtScript.QScriptValue.setData": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setProperty": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('int', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('str', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags')],
-    "PySide2.QtScript.QScriptValue.setPrototype": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScriptClass": ('PySide2.QtScript.QScriptClass',),
-    "PySide2.QtScript.QScriptValue.strictlyEquals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.toBool": (),
-    "PySide2.QtScript.QScriptValue.toBoolean": (),
-    "PySide2.QtScript.QScriptValue.toDateTime": (),
-    "PySide2.QtScript.QScriptValue.toInt32": (),
-    "PySide2.QtScript.QScriptValue.toInteger": (),
-    "PySide2.QtScript.QScriptValue.toNumber": (),
-    "PySide2.QtScript.QScriptValue.toObject": (),
-    "PySide2.QtScript.QScriptValue.toQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.toQObject": (),
-    "PySide2.QtScript.QScriptValue.toRegExp": (),
-    "PySide2.QtScript.QScriptValue.toString": (),
-    "PySide2.QtScript.QScriptValue.toUInt16": (),
-    "PySide2.QtScript.QScriptValue.toUInt32": (),
-    "PySide2.QtScript.QScriptValue.toVariant": (),
-# class PySide2.QtScript.QScriptValueIterator:
-    "PySide2.QtScript.QScriptValueIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.__iter__": (),
-    "PySide2.QtScript.QScriptValueIterator.flags": (),
-    "PySide2.QtScript.QScriptValueIterator.hasNext": (),
-    "PySide2.QtScript.QScriptValueIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptValueIterator.name": (),
-    "PySide2.QtScript.QScriptValueIterator.previous": (),
-    "PySide2.QtScript.QScriptValueIterator.remove": (),
-    "PySide2.QtScript.QScriptValueIterator.scriptName": (),
-    "PySide2.QtScript.QScriptValueIterator.setValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.toBack": (),
-    "PySide2.QtScript.QScriptValueIterator.toFront": (),
-    "PySide2.QtScript.QScriptValueIterator.value": (),
-# class PySide2.QtScript.QScriptable:
-    "PySide2.QtScript.QScriptable.__init__": (),
-    "PySide2.QtScript.QScriptable.argument": ('int',),
-    "PySide2.QtScript.QScriptable.argumentCount": (),
-    "PySide2.QtScript.QScriptable.context": (),
-    "PySide2.QtScript.QScriptable.engine": (),
-    "PySide2.QtScript.QScriptable.thisObject": (),
-    }) if "PySide2.QtScript" in sys.modules else None
-# Module PySide2.QtScriptTools
-sig_dict.update({
-# class PySide2.QtScriptTools.QScriptEngineDebugger:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerState:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget:
-    "PySide2.QtScriptTools.QScriptEngineDebugger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.action": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.attachTo": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.autoShowStandardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardMenu": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardToolBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.setAutoShowStandardWindow": ('bool',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.standardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.state": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.widget": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget',),
-    }) if "PySide2.QtScriptTools" in sys.modules else None
-# Module PySide2.QtSensors
-sig_dict.update({
-# class PySide2.QtSensors.QAccelerometer:
-# class PySide2.QtSensors.QAccelerometer.AccelerationMode:
-    "PySide2.QtSensors.QAccelerometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometer.accelerationMode": (),
-    "PySide2.QtSensors.QAccelerometer.reading": (),
-    "PySide2.QtSensors.QAccelerometer.setAccelerationMode": ('PySide2.QtSensors.QAccelerometer.AccelerationMode',),
-# class PySide2.QtSensors.QAccelerometerFilter:
-    "PySide2.QtSensors.QAccelerometerFilter.__init__": (),
-    "PySide2.QtSensors.QAccelerometerFilter.filter": [('PySide2.QtSensors.QAccelerometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAccelerometerReading:
-    "PySide2.QtSensors.QAccelerometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAccelerometerReading.setX": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setY": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.x": (),
-    "PySide2.QtSensors.QAccelerometerReading.y": (),
-    "PySide2.QtSensors.QAccelerometerReading.z": (),
-# class PySide2.QtSensors.QAltimeter:
-    "PySide2.QtSensors.QAltimeter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeter.reading": (),
-# class PySide2.QtSensors.QAltimeterFilter:
-    "PySide2.QtSensors.QAltimeterFilter.__init__": (),
-    "PySide2.QtSensors.QAltimeterFilter.filter": [('PySide2.QtSensors.QAltimeterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAltimeterReading:
-    "PySide2.QtSensors.QAltimeterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeterReading.altitude": (),
-    "PySide2.QtSensors.QAltimeterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAltimeterReading.setAltitude": ('float',),
-# class PySide2.QtSensors.QAmbientLightFilter:
-    "PySide2.QtSensors.QAmbientLightFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientLightFilter.filter": [('PySide2.QtSensors.QAmbientLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientLightReading:
-# class PySide2.QtSensors.QAmbientLightReading.LightLevel:
-    "PySide2.QtSensors.QAmbientLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientLightReading.lightLevel": (),
-    "PySide2.QtSensors.QAmbientLightReading.setLightLevel": ('PySide2.QtSensors.QAmbientLightReading.LightLevel',),
-# class PySide2.QtSensors.QAmbientLightSensor:
-    "PySide2.QtSensors.QAmbientLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightSensor.reading": (),
-# class PySide2.QtSensors.QAmbientTemperatureFilter:
-    "PySide2.QtSensors.QAmbientTemperatureFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientTemperatureFilter.filter": [('PySide2.QtSensors.QAmbientTemperatureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientTemperatureReading:
-    "PySide2.QtSensors.QAmbientTemperatureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.temperature": (),
-# class PySide2.QtSensors.QAmbientTemperatureSensor:
-    "PySide2.QtSensors.QAmbientTemperatureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureSensor.reading": (),
-# class PySide2.QtSensors.QCompass:
-    "PySide2.QtSensors.QCompass.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompass.reading": (),
-# class PySide2.QtSensors.QCompassFilter:
-    "PySide2.QtSensors.QCompassFilter.__init__": (),
-    "PySide2.QtSensors.QCompassFilter.filter": [('PySide2.QtSensors.QCompassReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QCompassReading:
-    "PySide2.QtSensors.QCompassReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompassReading.azimuth": (),
-    "PySide2.QtSensors.QCompassReading.calibrationLevel": (),
-    "PySide2.QtSensors.QCompassReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QCompassReading.setAzimuth": ('float',),
-    "PySide2.QtSensors.QCompassReading.setCalibrationLevel": ('float',),
-# class PySide2.QtSensors.QDistanceFilter:
-    "PySide2.QtSensors.QDistanceFilter.__init__": (),
-    "PySide2.QtSensors.QDistanceFilter.filter": [('PySide2.QtSensors.QDistanceReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QDistanceReading:
-    "PySide2.QtSensors.QDistanceReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QDistanceReading.distance": (),
-    "PySide2.QtSensors.QDistanceReading.setDistance": ('float',),
-# class PySide2.QtSensors.QDistanceSensor:
-    "PySide2.QtSensors.QDistanceSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceSensor.reading": (),
-# class PySide2.QtSensors.QGyroscope:
-    "PySide2.QtSensors.QGyroscope.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscope.reading": (),
-# class PySide2.QtSensors.QGyroscopeFilter:
-    "PySide2.QtSensors.QGyroscopeFilter.__init__": (),
-    "PySide2.QtSensors.QGyroscopeFilter.filter": [('PySide2.QtSensors.QGyroscopeReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QGyroscopeReading:
-    "PySide2.QtSensors.QGyroscopeReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscopeReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QGyroscopeReading.setX": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setY": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setZ": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.x": (),
-    "PySide2.QtSensors.QGyroscopeReading.y": (),
-    "PySide2.QtSensors.QGyroscopeReading.z": (),
-# class PySide2.QtSensors.QHolsterFilter:
-    "PySide2.QtSensors.QHolsterFilter.__init__": (),
-    "PySide2.QtSensors.QHolsterFilter.filter": [('PySide2.QtSensors.QHolsterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHolsterReading:
-    "PySide2.QtSensors.QHolsterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHolsterReading.holstered": (),
-    "PySide2.QtSensors.QHolsterReading.setHolstered": ('bool',),
-# class PySide2.QtSensors.QHolsterSensor:
-    "PySide2.QtSensors.QHolsterSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterSensor.reading": (),
-# class PySide2.QtSensors.QHumidityFilter:
-    "PySide2.QtSensors.QHumidityFilter.__init__": (),
-    "PySide2.QtSensors.QHumidityFilter.filter": [('PySide2.QtSensors.QHumidityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHumidityReading:
-    "PySide2.QtSensors.QHumidityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumidityReading.absoluteHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHumidityReading.relativeHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.setAbsoluteHumidity": ('float',),
-    "PySide2.QtSensors.QHumidityReading.setRelativeHumidity": ('float',),
-# class PySide2.QtSensors.QHumiditySensor:
-    "PySide2.QtSensors.QHumiditySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumiditySensor.reading": (),
-# class PySide2.QtSensors.QIRProximityFilter:
-    "PySide2.QtSensors.QIRProximityFilter.__init__": (),
-    "PySide2.QtSensors.QIRProximityFilter.filter": [('PySide2.QtSensors.QIRProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QIRProximityReading:
-    "PySide2.QtSensors.QIRProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QIRProximityReading.reflectance": (),
-    "PySide2.QtSensors.QIRProximityReading.setReflectance": ('float',),
-# class PySide2.QtSensors.QIRProximitySensor:
-    "PySide2.QtSensors.QIRProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximitySensor.reading": (),
-# class PySide2.QtSensors.QLidFilter:
-    "PySide2.QtSensors.QLidFilter.__init__": (),
-    "PySide2.QtSensors.QLidFilter.filter": [('PySide2.QtSensors.QLidReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLidReading:
-    "PySide2.QtSensors.QLidReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidReading.backLidClosed": (),
-    "PySide2.QtSensors.QLidReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLidReading.frontLidClosed": (),
-    "PySide2.QtSensors.QLidReading.setBackLidClosed": ('bool',),
-    "PySide2.QtSensors.QLidReading.setFrontLidClosed": ('bool',),
-# class PySide2.QtSensors.QLidSensor:
-    "PySide2.QtSensors.QLidSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidSensor.reading": (),
-# class PySide2.QtSensors.QLightFilter:
-    "PySide2.QtSensors.QLightFilter.__init__": (),
-    "PySide2.QtSensors.QLightFilter.filter": [('PySide2.QtSensors.QLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLightReading:
-    "PySide2.QtSensors.QLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLightReading.lux": (),
-    "PySide2.QtSensors.QLightReading.setLux": ('float',),
-# class PySide2.QtSensors.QLightSensor:
-    "PySide2.QtSensors.QLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightSensor.fieldOfView": (),
-    "PySide2.QtSensors.QLightSensor.reading": (),
-    "PySide2.QtSensors.QLightSensor.setFieldOfView": ('float',),
-# class PySide2.QtSensors.QMagnetometer:
-    "PySide2.QtSensors.QMagnetometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometer.reading": (),
-    "PySide2.QtSensors.QMagnetometer.returnGeoValues": (),
-    "PySide2.QtSensors.QMagnetometer.setReturnGeoValues": ('bool',),
-# class PySide2.QtSensors.QMagnetometerFilter:
-    "PySide2.QtSensors.QMagnetometerFilter.__init__": (),
-    "PySide2.QtSensors.QMagnetometerFilter.filter": [('PySide2.QtSensors.QMagnetometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QMagnetometerReading:
-    "PySide2.QtSensors.QMagnetometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometerReading.calibrationLevel": (),
-    "PySide2.QtSensors.QMagnetometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QMagnetometerReading.setCalibrationLevel": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setX": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setY": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.x": (),
-    "PySide2.QtSensors.QMagnetometerReading.y": (),
-    "PySide2.QtSensors.QMagnetometerReading.z": (),
-# class PySide2.QtSensors.QOrientationFilter:
-    "PySide2.QtSensors.QOrientationFilter.__init__": (),
-    "PySide2.QtSensors.QOrientationFilter.filter": [('PySide2.QtSensors.QOrientationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QOrientationReading:
-# class PySide2.QtSensors.QOrientationReading.Orientation:
-    "PySide2.QtSensors.QOrientationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QOrientationReading.orientation": (),
-    "PySide2.QtSensors.QOrientationReading.setOrientation": ('PySide2.QtSensors.QOrientationReading.Orientation',),
-# class PySide2.QtSensors.QOrientationSensor:
-    "PySide2.QtSensors.QOrientationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationSensor.reading": (),
-# class PySide2.QtSensors.QPressureFilter:
-    "PySide2.QtSensors.QPressureFilter.__init__": (),
-    "PySide2.QtSensors.QPressureFilter.filter": [('PySide2.QtSensors.QPressureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QPressureReading:
-    "PySide2.QtSensors.QPressureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QPressureReading.pressure": (),
-    "PySide2.QtSensors.QPressureReading.setPressure": ('float',),
-    "PySide2.QtSensors.QPressureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QPressureReading.temperature": (),
-# class PySide2.QtSensors.QPressureSensor:
-    "PySide2.QtSensors.QPressureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureSensor.reading": (),
-# class PySide2.QtSensors.QProximityFilter:
-    "PySide2.QtSensors.QProximityFilter.__init__": (),
-    "PySide2.QtSensors.QProximityFilter.filter": [('PySide2.QtSensors.QProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QProximityReading:
-    "PySide2.QtSensors.QProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximityReading.close": (),
-    "PySide2.QtSensors.QProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QProximityReading.setClose": ('bool',),
-# class PySide2.QtSensors.QProximitySensor:
-    "PySide2.QtSensors.QProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximitySensor.reading": (),
-# class PySide2.QtSensors.QRotationFilter:
-    "PySide2.QtSensors.QRotationFilter.__init__": (),
-    "PySide2.QtSensors.QRotationFilter.filter": [('PySide2.QtSensors.QRotationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QRotationReading:
-    "PySide2.QtSensors.QRotationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QRotationReading.setFromEuler": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QRotationReading.x": (),
-    "PySide2.QtSensors.QRotationReading.y": (),
-    "PySide2.QtSensors.QRotationReading.z": (),
-# class PySide2.QtSensors.QRotationSensor:
-    "PySide2.QtSensors.QRotationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationSensor.hasZ": (),
-    "PySide2.QtSensors.QRotationSensor.reading": (),
-    "PySide2.QtSensors.QRotationSensor.setHasZ": ('bool',),
-# class PySide2.QtSensors.QSensor:
-# class PySide2.QtSensors.QSensor.AxesOrientationMode:
-# class PySide2.QtSensors.QSensor.Feature:
-    "PySide2.QtSensors.QSensor.__init__": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensor.addFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.availableDataRates": (),
-    "PySide2.QtSensors.QSensor.axesOrientationMode": (),
-    "PySide2.QtSensors.QSensor.backend": (),
-    "PySide2.QtSensors.QSensor.bufferSize": (),
-    "PySide2.QtSensors.QSensor.connectToBackend": (),
-    "PySide2.QtSensors.QSensor.currentOrientation": (),
-    "PySide2.QtSensors.QSensor.dataRate": (),
-    "PySide2.QtSensors.QSensor.defaultSensorForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.description": (),
-    "PySide2.QtSensors.QSensor.efficientBufferSize": (),
-    "PySide2.QtSensors.QSensor.error": (),
-    "PySide2.QtSensors.QSensor.filters": (),
-    "PySide2.QtSensors.QSensor.identifier": (),
-    "PySide2.QtSensors.QSensor.isActive": (),
-    "PySide2.QtSensors.QSensor.isAlwaysOn": (),
-    "PySide2.QtSensors.QSensor.isBusy": (),
-    "PySide2.QtSensors.QSensor.isConnectedToBackend": (),
-    "PySide2.QtSensors.QSensor.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensor.maxBufferSize": (),
-    "PySide2.QtSensors.QSensor.outputRange": (),
-    "PySide2.QtSensors.QSensor.outputRanges": (),
-    "PySide2.QtSensors.QSensor.reading": (),
-    "PySide2.QtSensors.QSensor.removeFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.sensorTypes": (),
-    "PySide2.QtSensors.QSensor.sensorsForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setActive": ('bool',),
-    "PySide2.QtSensors.QSensor.setAlwaysOn": ('bool',),
-    "PySide2.QtSensors.QSensor.setAxesOrientationMode": ('PySide2.QtSensors.QSensor.AxesOrientationMode',),
-    "PySide2.QtSensors.QSensor.setBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setCurrentOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.setDataRate": ('int',),
-    "PySide2.QtSensors.QSensor.setEfficientBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setIdentifier": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setMaxBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setOutputRange": ('int',),
-    "PySide2.QtSensors.QSensor.setSkipDuplicates": ('bool',),
-    "PySide2.QtSensors.QSensor.setUserOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.skipDuplicates": (),
-    "PySide2.QtSensors.QSensor.start": (),
-    "PySide2.QtSensors.QSensor.stop": (),
-    "PySide2.QtSensors.QSensor.type": (),
-    "PySide2.QtSensors.QSensor.userOrientation": (),
-# class PySide2.QtSensors.QSensorBackend:
-    "PySide2.QtSensors.QSensorBackend.__init__": ('PySide2.QtSensors.QSensor', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensorBackend.addDataRate": ('float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.addOutputRange": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensorBackend.newReadingAvailable": (),
-    "PySide2.QtSensors.QSensorBackend.reading": (),
-    "PySide2.QtSensors.QSensorBackend.sensor": (),
-    "PySide2.QtSensors.QSensorBackend.sensorBusy": (),
-    "PySide2.QtSensors.QSensorBackend.sensorError": ('int',),
-    "PySide2.QtSensors.QSensorBackend.sensorStopped": (),
-    "PySide2.QtSensors.QSensorBackend.setDataRates": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorBackend.setDescription": ('str',),
-    "PySide2.QtSensors.QSensorBackend.start": (),
-    "PySide2.QtSensors.QSensorBackend.stop": (),
-# class PySide2.QtSensors.QSensorBackendFactory:
-    "PySide2.QtSensors.QSensorBackendFactory.__init__": (),
-    "PySide2.QtSensors.QSensorBackendFactory.createBackend": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorChangesInterface:
-    "PySide2.QtSensors.QSensorChangesInterface.__init__": (),
-    "PySide2.QtSensors.QSensorChangesInterface.sensorsChanged": (),
-# class PySide2.QtSensors.QSensorFilter:
-    "PySide2.QtSensors.QSensorFilter.__init__": (),
-    "PySide2.QtSensors.QSensorFilter.filter": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorFilter.setSensor": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorGestureManager:
-    "PySide2.QtSensors.QSensorGestureManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureManager.gestureIds": (),
-    "PySide2.QtSensors.QSensorGestureManager.recognizerSignals": ('str',),
-    "PySide2.QtSensors.QSensorGestureManager.registerSensorGestureRecognizer": ('PySide2.QtSensors.QSensorGestureRecognizer',),
-    "PySide2.QtSensors.QSensorGestureManager.sensorGestureRecognizer": ('str',),
-# class PySide2.QtSensors.QSensorGesturePluginInterface:
-    "PySide2.QtSensors.QSensorGesturePluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.createRecognizers": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.name": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.supportedIds": (),
-# class PySide2.QtSensors.QSensorGestureRecognizer:
-    "PySide2.QtSensors.QSensorGestureRecognizer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureRecognizer.create": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.createBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.gestureSignals": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.id": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.isActive": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.start": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.startBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stop": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stopBackend": (),
-# class PySide2.QtSensors.QSensorManager:
-    "PySide2.QtSensors.QSensorManager.__init__": (),
-    "PySide2.QtSensors.QSensorManager.createBackend": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorManager.isBackendRegistered": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.registerBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtSensors.QSensorBackendFactory'),
-    "PySide2.QtSensors.QSensorManager.setDefaultBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.unregisterBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtSensors.QSensorPluginInterface:
-    "PySide2.QtSensors.QSensorPluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorPluginInterface.registerSensors": (),
-# class PySide2.QtSensors.QSensorReading:
-    "PySide2.QtSensors.QSensorReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorReading.setTimestamp": ('int',),
-    "PySide2.QtSensors.QSensorReading.timestamp": (),
-    "PySide2.QtSensors.QSensorReading.value": ('int',),
-    "PySide2.QtSensors.QSensorReading.valueCount": (),
-# class PySide2.QtSensors.QTapFilter:
-    "PySide2.QtSensors.QTapFilter.__init__": (),
-    "PySide2.QtSensors.QTapFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTapReading',)],
-# class PySide2.QtSensors.QTapReading:
-# class PySide2.QtSensors.QTapReading.TapDirection:
-    "PySide2.QtSensors.QTapReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTapReading.isDoubleTap": (),
-    "PySide2.QtSensors.QTapReading.setDoubleTap": ('bool',),
-    "PySide2.QtSensors.QTapReading.setTapDirection": ('PySide2.QtSensors.QTapReading.TapDirection',),
-    "PySide2.QtSensors.QTapReading.tapDirection": (),
-# class PySide2.QtSensors.QTapSensor:
-    "PySide2.QtSensors.QTapSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapSensor.reading": (),
-    "PySide2.QtSensors.QTapSensor.returnDoubleTapEvents": (),
-    "PySide2.QtSensors.QTapSensor.setReturnDoubleTapEvents": ('bool',),
-# class PySide2.QtSensors.QTiltFilter:
-    "PySide2.QtSensors.QTiltFilter.__init__": (),
-    "PySide2.QtSensors.QTiltFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTiltReading',)],
-# class PySide2.QtSensors.QTiltReading:
-    "PySide2.QtSensors.QTiltReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTiltReading.setXRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.setYRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.xRotation": (),
-    "PySide2.QtSensors.QTiltReading.yRotation": (),
-# class PySide2.QtSensors.QTiltSensor:
-    "PySide2.QtSensors.QTiltSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltSensor.calibrate": (),
-    "PySide2.QtSensors.QTiltSensor.reading": (),
-# class PySide2.QtSensors.qoutputrange:
-    "PySide2.QtSensors.qoutputrange.__init__": [(), ('PySide2.QtSensors.qoutputrange',)],
-    "PySide2.QtSensors.qoutputrange.__copy__": (),
-    }) if "PySide2.QtSensors" in sys.modules else None
-# Module PySide2.QtTextToSpeech
-sig_dict.update({
-# class PySide2.QtTextToSpeech.QTextToSpeech:
-# class PySide2.QtTextToSpeech.QTextToSpeech.State:
-    "PySide2.QtTextToSpeech.QTextToSpeech.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableEngines": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.volume": (),
-# class PySide2.QtTextToSpeech.QTextToSpeechEngine:
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.createVoice": ('str', 'PySide2.QtTextToSpeech.QVoice.Gender', 'PySide2.QtTextToSpeech.QVoice.Age', 'typing.Any'),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voiceData": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.volume": (),
-# class PySide2.QtTextToSpeech.QVoice:
-# class PySide2.QtTextToSpeech.QVoice.Age:
-# class PySide2.QtTextToSpeech.QVoice.Gender:
-    "PySide2.QtTextToSpeech.QVoice.__init__": [(), ('PySide2.QtTextToSpeech.QVoice',)],
-    "PySide2.QtTextToSpeech.QVoice.__copy__": (),
-    "PySide2.QtTextToSpeech.QVoice.age": (),
-    "PySide2.QtTextToSpeech.QVoice.ageName": ('PySide2.QtTextToSpeech.QVoice.Age',),
-    "PySide2.QtTextToSpeech.QVoice.gender": (),
-    "PySide2.QtTextToSpeech.QVoice.genderName": ('PySide2.QtTextToSpeech.QVoice.Gender',),
-    "PySide2.QtTextToSpeech.QVoice.name": (),
-    }) if "PySide2.QtTextToSpeech" in sys.modules else None
-# Module PySide2.QtCharts
-sig_dict.update({
-# class PySide2.QtCharts.QtCharts:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis.AxisType:
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.alignment": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isMinorGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isReverse": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isTitleVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsEditable": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePenColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.orientation": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsAngle": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsEditable": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePenColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMax": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMin": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setRange": ('typing.Any', 'typing.Any'),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setReverse": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleText": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBorderColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesPen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleText": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition:
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.append": [('PySide2.QtCharts.QtCharts.QBarSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBarSet]',)],
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barSets": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barWidth": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBarSet'),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.isLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPrecision": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.remove": ('PySide2.QtCharts.QtCharts.QBarSet',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setBarWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPrecision": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.take": ('PySide2.QtCharts.QtCharts.QBarSet',),
-# class PySide2.QtCharts.QtCharts.QAbstractSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractSeries.SeriesType:
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachedAxes": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.chart": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.detachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.name": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.opacity": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setName": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setOpacity": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setUseOpenGL": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.useOpenGL": (),
-# class PySide2.QtCharts.QtCharts.QAreaLegendMarker:
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAreaSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QAreaSeries:
-    "PySide2.QtCharts.QtCharts.QAreaSeries.__init__": [('PySide2.QtCharts.QtCharts.QLineSeries', 'PySide2.QtCharts.QtCharts.QLineSeries'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCharts.QtCharts.QAreaSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.lowerSeries": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setLowerSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setUpperSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.upperSeries": (),
-# class PySide2.QtCharts.QtCharts.QBarCategoryAxis:
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.append": [('str',), ('typing.Sequence[str]',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.categories": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.clear": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.insert": ('int', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.replace": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setCategories": ('typing.Sequence[str]',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMax": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMin": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setRange": [('str', 'str'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QBarLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries', 'PySide2.QtCharts.QtCharts.QBarSet', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.barset": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.firstBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.lastBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirstBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setLastBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QBarSeries:
-    "PySide2.QtCharts.QtCharts.QBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBarSet:
-    "PySide2.QtCharts.QtCharts.QBarSet.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBarSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBarSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarSet.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.color": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.insert": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.remove": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QBarSet.replace": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBarSet.sum": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.firstBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.lastBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirstBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setLastBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QBoxPlotSeries:
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.append": [('PySide2.QtCharts.QtCharts.QBoxSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBoxSet]',)],
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxSets": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxWidth": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBoxSet'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.remove": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.take": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxSet:
-# class PySide2.QtCharts.QtCharts.QBoxSet.ValuePositions:
-    "PySide2.QtCharts.QtCharts.QBoxSet.__init__": [('float', 'float', 'float', 'float', 'float', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QBoxSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBoxSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setValue": ('int', 'float'),
-# class PySide2.QtCharts.QtCharts.QCandlestickLegendMarker:
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QCandlestickSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.firstSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.lastSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setClose": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setFirstSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setHigh": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLastSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLow": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setOpen": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QCandlestickSeries',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setTimestamp": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSeries:
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.append": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.decreasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.increasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QCandlestickSet'),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.maximumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.minimumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.remove": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setDecreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setIncreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMaximumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMinimumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.sets": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.take": ('PySide2.QtCharts.QtCharts.QCandlestickSet',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSet:
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.__init__": [('float', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setClose": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setHigh": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setLow": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setOpen": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setTimestamp": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCategoryAxis:
-# class PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition:
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.append": ('str', 'float'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.categoriesLabels": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.endValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.replaceLabel": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setStartValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.startValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QChart:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOption:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOptions:
-# class PySide2.QtCharts.QtCharts.QChart.ChartTheme:
-# class PySide2.QtCharts.QtCharts.QChart.ChartType:
-    "PySide2.QtCharts.QtCharts.QChart.__init__": [('PySide2.QtCharts.QtCharts.QChart.ChartType', 'PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtCharts.QtCharts.QChart.addAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtCharts.QtCharts.QChart.addSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.animationDuration": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationEasingCurve": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationOptions": (),
-    "PySide2.QtCharts.QtCharts.QChart.axes": ('PySide2.QtCore.Qt.Orientations', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.axisX": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.axisY": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundRoundness": (),
-    "PySide2.QtCharts.QtCharts.QChart.chartType": (),
-    "PySide2.QtCharts.QtCharts.QChart.createDefaultAxes": (),
-    "PySide2.QtCharts.QtCharts.QChart.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isDropShadowEnabled": (),
-    "PySide2.QtCharts.QtCharts.QChart.isPlotAreaBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isZoomed": (),
-    "PySide2.QtCharts.QtCharts.QChart.legend": (),
-    "PySide2.QtCharts.QtCharts.QChart.locale": (),
-    "PySide2.QtCharts.QtCharts.QChart.localizeNumbers": (),
-    "PySide2.QtCharts.QtCharts.QChart.mapToPosition": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.mapToValue": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.margins": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotArea": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAllSeries": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QChart.removeSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.scroll": ('float', 'float'),
-    "PySide2.QtCharts.QtCharts.QChart.series": (),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationDuration": ('int',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationOptions": ('PySide2.QtCharts.QtCharts.QChart.AnimationOptions',),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisX": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisY": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundRoundness": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setDropShadowEnabled": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocalizeNumbers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setMargins": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotArea": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setTheme": ('PySide2.QtCharts.QtCharts.QChart.ChartTheme',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitle": ('str',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QChart.theme": (),
-    "PySide2.QtCharts.QtCharts.QChart.title": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoom": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.zoomIn": [(), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtCharts.QtCharts.QChart.zoomOut": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoomReset": (),
-# class PySide2.QtCharts.QtCharts.QChartView:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBand:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBands:
-    "PySide2.QtCharts.QtCharts.QChartView.__init__": [('PySide2.QtCharts.QtCharts.QChart', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtCharts.QtCharts.QChartView.chart": (),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.rubberBand": (),
-    "PySide2.QtCharts.QtCharts.QChartView.setChart": ('PySide2.QtCharts.QtCharts.QChart',),
-    "PySide2.QtCharts.QtCharts.QChartView.setRubberBand": ('PySide2.QtCharts.QtCharts.QChartView.RubberBands',),
-    "PySide2.QtCharts.QtCharts.QChartView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtCharts.QtCharts.QDateTimeAxis:
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.format": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMax": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMin": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setRange": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QHBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.lastBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setLastBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.lastBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setLastBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QHCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.closeColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.firstSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.highColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lastSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lowColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.openColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setCloseColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setFirstSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setHighColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLastSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLowColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setOpenColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setTimestampColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.timestampColumn": (),
-# class PySide2.QtCharts.QtCharts.QHPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.labelsRow": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setLabelsRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setValuesRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.valuesRow": (),
-# class PySide2.QtCharts.QtCharts.QHXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setXRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setYRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.xRow": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.yRow": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLegend:
-# class PySide2.QtCharts.QtCharts.QLegend.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QLegend.alignment": (),
-    "PySide2.QtCharts.QtCharts.QLegend.attachToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.color": (),
-    "PySide2.QtCharts.QtCharts.QLegend.detachFromChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.font": (),
-    "PySide2.QtCharts.QtCharts.QLegend.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.isAttachedToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markers": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QLegend.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtCharts.QtCharts.QLegend.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegend.reverseMarkers": (),
-    "PySide2.QtCharts.QtCharts.QLegend.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setMarkerShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegend.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegend.setReverseMarkers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setShowToolTips": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.showToolTips": (),
-# class PySide2.QtCharts.QtCharts.QLegendMarker:
-# class PySide2.QtCharts.QtCharts.QLegendMarker.LegendMarkerType:
-    "PySide2.QtCharts.QtCharts.QLegendMarker.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.font": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.label": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.shape": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QLineSeries:
-    "PySide2.QtCharts.QtCharts.QLineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLogValueAxis:
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.base": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setBase": ('float',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QPieLegendMarker:
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QPieSeries', 'PySide2.QtCharts.QtCharts.QPieSlice', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.slice": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.labelsSection": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setLabelsSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setValuesSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.valuesSection": (),
-# class PySide2.QtCharts.QtCharts.QPieSeries:
-    "PySide2.QtCharts.QtCharts.QPieSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.__lshift__": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.append": [('PySide2.QtCharts.QtCharts.QPieSlice',), ('str', 'float'), ('typing.Sequence[PySide2.QtCharts.QtCharts.QPieSlice]',)],
-    "PySide2.QtCharts.QtCharts.QPieSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.holeSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.horizontalPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QPieSlice'),
-    "PySide2.QtCharts.QtCharts.QPieSeries.isEmpty": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieEndAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieStartAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.remove": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHoleSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHorizontalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieEndAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieStartAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setVerticalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.slices": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.sum": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.take": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.verticalPosition": (),
-# class PySide2.QtCharts.QtCharts.QPieSlice:
-# class PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition:
-    "PySide2.QtCharts.QtCharts.QPieSlice.__init__": [('PySide2.QtCore.QObject',), ('str', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QPieSlice.angleSpan": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderWidth": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.brush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.color": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.explodeDistanceFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isExploded": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isLabelVisible": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.label": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelArmLengthFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.pen": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.percentage": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.series": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderWidth": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExplodeDistanceFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExploded": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelArmLengthFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.startAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.value": (),
-# class PySide2.QtCharts.QtCharts.QPolarChart:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientations:
-    "PySide2.QtCharts.QtCharts.QPolarChart.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtCharts.QtCharts.QPolarChart.addAxis": [('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation'), ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtCharts.QtCharts.QPolarChart.axisPolarOrientation": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-# class PySide2.QtCharts.QtCharts.QScatterSeries:
-# class PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QScatterSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerSize": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerShape": ('PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QSplineSeries:
-    "PySide2.QtCharts.QtCharts.QSplineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QSplineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QVBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.lastBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setLastBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.lastBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setLastBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QVCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.closeRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.firstSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.highRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lastSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lowRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.openRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setCloseRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setFirstSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setHighRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLastSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLowRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setOpenRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setTimestampRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.timestampRow": (),
-# class PySide2.QtCharts.QtCharts.QVPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.labelsColumn": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setLabelsColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setValuesColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.valuesColumn": (),
-# class PySide2.QtCharts.QtCharts.QVXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setXColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setYColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.xColumn": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.yColumn": (),
-# class PySide2.QtCharts.QtCharts.QValueAxis:
-    "PySide2.QtCharts.QtCharts.QValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.applyNiceNumbers": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickAnchor": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickInterval": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickAnchor": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickInterval": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QXYLegendMarker:
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QXYSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setXSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setYSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.xSection": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.ySection": (),
-# class PySide2.QtCharts.QtCharts.QXYSeries:
-    "PySide2.QtCharts.QtCharts.QXYSeries.__lshift__": [('PySide2.QtCore.QPointF',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.append": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.insert": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.points": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVector": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.remove": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('int',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.removePoints": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.replace": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'float', 'float'), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointsVisible": ('bool',),
-    }) if "PySide2.QtCharts" in sys.modules else None
-# Module PySide2.QtSvg
-sig_dict.update({
-# class PySide2.QtSvg.QGraphicsSvgItem:
-    "PySide2.QtSvg.QGraphicsSvgItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtSvg.QGraphicsSvgItem.boundingRect": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.elementId": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.isCachingEnabled": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.maximumCacheSize": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtSvg.QGraphicsSvgItem.renderer": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.setCachingEnabled": ('bool',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setElementId": ('str',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setMaximumCacheSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setSharedRenderer": ('PySide2.QtSvg.QSvgRenderer',),
-    "PySide2.QtSvg.QGraphicsSvgItem.type": (),
-# class PySide2.QtSvg.QSvgGenerator:
-    "PySide2.QtSvg.QSvgGenerator.__init__": (),
-    "PySide2.QtSvg.QSvgGenerator.description": (),
-    "PySide2.QtSvg.QSvgGenerator.fileName": (),
-    "PySide2.QtSvg.QSvgGenerator.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtSvg.QSvgGenerator.outputDevice": (),
-    "PySide2.QtSvg.QSvgGenerator.paintEngine": (),
-    "PySide2.QtSvg.QSvgGenerator.resolution": (),
-    "PySide2.QtSvg.QSvgGenerator.setDescription": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setFileName": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setOutputDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtSvg.QSvgGenerator.setResolution": ('int',),
-    "PySide2.QtSvg.QSvgGenerator.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QSvgGenerator.setTitle": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgGenerator.size": (),
-    "PySide2.QtSvg.QSvgGenerator.title": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBox": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBoxF": (),
-# class PySide2.QtSvg.QSvgRenderer:
-    "PySide2.QtSvg.QSvgRenderer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QXmlStreamReader', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtSvg.QSvgRenderer.animated": (),
-    "PySide2.QtSvg.QSvgRenderer.animationDuration": (),
-    "PySide2.QtSvg.QSvgRenderer.boundsOnElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.currentFrame": (),
-    "PySide2.QtSvg.QSvgRenderer.defaultSize": (),
-    "PySide2.QtSvg.QSvgRenderer.elementExists": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.framesPerSecond": (),
-    "PySide2.QtSvg.QSvgRenderer.isValid": (),
-    "PySide2.QtSvg.QSvgRenderer.load": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QXmlStreamReader',), ('str',)],
-    "PySide2.QtSvg.QSvgRenderer.matrixForElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.render": [('PySide2.QtGui.QPainter',), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'), ('PySide2.QtGui.QPainter', 'str', 'PySide2.QtCore.QRectF')],
-    "PySide2.QtSvg.QSvgRenderer.setCurrentFrame": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setFramesPerSecond": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgRenderer.viewBox": (),
-    "PySide2.QtSvg.QSvgRenderer.viewBoxF": (),
-# class PySide2.QtSvg.QSvgWidget:
-    "PySide2.QtSvg.QSvgWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtSvg.QSvgWidget.load": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtSvg.QSvgWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtSvg.QSvgWidget.renderer": (),
-    "PySide2.QtSvg.QSvgWidget.sizeHint": (),
-    }) if "PySide2.QtSvg" in sys.modules else None
-# Module PySide2.QtDataVisualization
-sig_dict.update({
-# class PySide2.QtDataVisualization.QtDataVisualization:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DBars:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barSpacing": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barThickness": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.columnAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.floorLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.insertSeries": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isBarSpacingRelative": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isMultiSeriesUniform": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.primarySeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.rowAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacing": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacingRelative": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarThickness": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setColumnAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setFloorLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setMultiSeriesUniform": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setPrimarySeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setRowAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setValueAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.valueAxis": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.cameraPreset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.maxZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.minZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPosition": ('float', 'float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPreset": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMaxZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMinZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setTarget": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapXRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapYRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setXRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setYRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.target": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapXRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapYRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.xRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.yRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.zoomLevel": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isRotationEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isSelectionEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomAtTargetEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setRotationEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setSelectionEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomAtTargetEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DLight:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.isAutoPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.setAutoPosition": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DObject:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.isDirty": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.parentScene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setPosition": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScene:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeLight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.devicePixelRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.graphPositionQuery": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.invalidSelectionPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInPrimarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInSecondarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSecondarySubviewOnTop": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSlicingActive": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.primarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.secondarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.selectionQueryPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveCamera": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveLight": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DLight',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setDevicePixelRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setGraphPositionQuery": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setPrimarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubviewOnTop": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSelectionQueryPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSlicingActive": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.viewport": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.flipHorizontalGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setFlipHorizontalGrid": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ambientLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseColors": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseGradients": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.gridLineColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.highlightLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isGridEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelBackgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelTextColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setAmbientLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseColors": ('typing.Sequence[PySide2.QtGui.QColor]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseGradients": ('typing.Sequence[PySide2.QtGui.QLinearGradient]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setHighlightLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setType": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setWindowColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.windowColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisOrientation:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isAutoAdjustRange": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleFixed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labelAutoRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.max": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.min": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.orientation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setAutoAdjustRange": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabelAutoRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMax": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setRange": ('float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitle": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleFixed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.title": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ElementType:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHint:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeInputHandler": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeTheme": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.aspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.clearSelection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.currentFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.customItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.hasContext": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.horizontalAspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.inputHandlers": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isOrthoProjection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isPolar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isReflection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.margin": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.measureFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.optimizationHints": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.queriedGraphPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.radialLabelOffset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.reflectivity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItemAt": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.renderToImage": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItemIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedElement": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedLabelIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectionMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setHorizontalAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMargin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMeasureFps": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOptimizationHints": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOrthoProjection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setPolar": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setRadialLabelOffset": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflectivity": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setSelectionMode": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setShadowQuality": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowQuality": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowsSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.themes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputView": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.prevDistance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.previousInputPos": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputView": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPrevDistance": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPreviousInputPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setScene": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DScene',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.SeriesType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isItemLabelVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isMeshSmooth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.mesh": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.meshRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.name": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMesh": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshSmooth": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setName": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setUserDefinedMesh": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.userDefinedMesh": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.DataType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.meshAngle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.selectedBar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setMeshAngle": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setSelectedBar": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem',), ('float',), ('float', 'float')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.value": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRow": [('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]',), ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRows": [('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.columnLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.removeRows": ('int', 'int', 'bool'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.resetArray": [(), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setColumnLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRowLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.setLabels": ('typing.Sequence[str]',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isPositionAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isScalingAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isShadowCasting": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.meshFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.scaling": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setMeshFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPositionAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotationAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScaling": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScalingAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setShadowCasting": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isFacingCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFacingCamera": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setText": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.text": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.textColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'int', 'int', 'int', 'typing.List[int]', 'PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.alphaMultiplier": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.colorTable": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.createTextureData": ('typing.List[PySide2.QtGui.QImage]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSliceFrames": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSlices": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.preserveOpacity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.renderSlice": ('PySide2.QtCore.Qt.Axis', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setAlphaMultiplier": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setColorTable": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSliceFrames": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSlices": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setPreserveOpacity": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameGaps": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameThicknesses": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameWidths": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexX": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexY": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexZ": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndices": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSubTextureData": [('PySide2.QtCore.Qt.Axis', 'int', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.Qt.Axis', 'int', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureData": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDepth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDimensions": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureHeight": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureWidth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setUseHighDefShader": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameGaps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameThicknesses": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameWidths": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDataWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDepth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureHeight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.useHighDefShader": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QImage', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMap": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMapFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMapFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setValueRanges": ('float', 'float', 'float', 'float'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.remap": ('str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.remap": ('str', 'str', 'str', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.remap": ('str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.autoSubGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.base": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setAutoSubGrid": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setBase": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setShowEdgeLabels": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.showEdgeLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.valueAt": ('float',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.invalidSelectionIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.itemSize": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.selectedItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setItemSize": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setSelectedItem": ('int',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItem": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItems": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.removeItems": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.resetArray": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.drawMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.selectedPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDrawMode": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setFlatShadingEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setSelectedPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTexture": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.texture": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRow": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRows": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.columnCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.removeRows": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.resetArray": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.formatter": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.labelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.reversed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.segmentCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setFormatter": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setReversed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSubSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.subSegmentCount": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowNegatives": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowZero": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.axis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.gridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelStrings": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.markDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowNegatives": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowZero": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.stringForValue": ('float', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.subGridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.valueAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.qDefaultSurfaceFormat": ('bool',),
-    }) if "PySide2.QtDataVisualization" in sys.modules else None
-# Module PySide2.QtUiTools
-sig_dict.update({
-# class PySide2.QtUiTools.QUiLoader:
-    "PySide2.QtUiTools.QUiLoader.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtUiTools.QUiLoader.addPluginPath": ('str',),
-    "PySide2.QtUiTools.QUiLoader.availableLayouts": (),
-    "PySide2.QtUiTools.QUiLoader.availableWidgets": (),
-    "PySide2.QtUiTools.QUiLoader.clearPluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.createAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createActionGroup": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createLayout": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createWidget": ('str', 'PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtUiTools.QUiLoader.errorString": (),
-    "PySide2.QtUiTools.QUiLoader.isLanguageChangeEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.isTranslationEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.load": [('PySide2.QtCore.QIODevice', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtUiTools.QUiLoader.pluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.registerCustomWidget": ('object',),
-    "PySide2.QtUiTools.QUiLoader.setLanguageChangeEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setTranslationEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setWorkingDirectory": ('PySide2.QtCore.QDir',),
-    "PySide2.QtUiTools.QUiLoader.workingDirectory": (),
-    }) if "PySide2.QtUiTools" in sys.modules else None
-# Module PySide2.QtWebChannel
-sig_dict.update({
-# class PySide2.QtWebChannel.QWebChannel:
-    "PySide2.QtWebChannel.QWebChannel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.blockUpdates": (),
-    "PySide2.QtWebChannel.QWebChannel.connectTo": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.deregisterObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.disconnectFrom": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.registerObject": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebChannel.QWebChannel.registerObjects": ('typing.Dict[str, PySide2.QtCore.QObject]',),
-    "PySide2.QtWebChannel.QWebChannel.registeredObjects": (),
-    "PySide2.QtWebChannel.QWebChannel.setBlockUpdates": ('bool',),
-# class PySide2.QtWebChannel.QWebChannelAbstractTransport:
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.sendMessage": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    }) if "PySide2.QtWebChannel" in sys.modules else None
-# Module PySide2.QtWebEngineCore
-sig_dict.update({
-# class PySide2.QtWebEngineCore.QWebEngineCookieStore:
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteAllCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteSessionCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.loadAllCookies": (),
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest:
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method:
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method'), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.hasHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.header": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.headers": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.method": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postData": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postRequest": ('PySide2.QtCore.QUrl', 'typing.Dict[str, str]'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setMethod": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setPostData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.swap": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.unsetHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.url": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.NavigationType:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.ResourceType:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.block": ('bool',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.changed": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.firstPartyUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.navigationType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.resourceType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.setHttpHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.interceptRequest": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo',),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.fail": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.reply": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestHeaders": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestUrl": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flag:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.SpecialPort:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax:
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',)],
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__copy__": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.defaultPort": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.flags": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.name": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.registerScheme": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.schemeByName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setDefaultPort": ('int',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setFlags": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setSyntax": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.syntax": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler:
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.requestStarted": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob',),
-    }) if "PySide2.QtWebEngineCore" in sys.modules else None
-# Module PySide2.QtWebEngine
-sig_dict.update({
-# class PySide2.QtWebEngine.QtWebEngine:
-    "PySide2.QtWebEngine.QtWebEngine.initialize": (),
-    }) if "PySide2.QtWebEngine" in sys.modules else None
-# Module PySide2.QtWebEngineWidgets
-sig_dict.update({
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError:
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError.Error:
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.__init__": [('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',), ('int', 'PySide2.QtCore.QUrl', 'bool', 'str')],
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.answered": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.certificateChain": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.defer": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.deferred": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.error": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.errorDescription": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.ignoreCertificateError": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.isOverridable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.rejectCertificate": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaType:
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineContextMenuData',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.editFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isContentEditable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.misspelledWord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.position": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.spellCheckerSuggestions": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadInterruptReason:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadState:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadType:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat:
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.cancel": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadDirectory": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.id": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReason": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReasonString": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isFinished": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isPaused": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isSavePageDownload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.mimeType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.path": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.pause": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.receivedBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.resume": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.savePageFormat": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadDirectory": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadFileName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setSavePageFormat": ('PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.state": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.suggestedFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.totalBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.type": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest:
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.origin": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.reject": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.toggleOn": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistory:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoBack": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoForward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItemIndex": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.goToItem": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.itemAt": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.items": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistoryItem:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__init__": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.lastVisited": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.originalUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.swap": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEnginePage:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.Feature:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlag:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.RenderProcessTerminationStatus:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType:
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtWebEngineWidgets.QWebEngineProfile', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.acceptNavigationRequest": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.action": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.backgroundColor": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.certificateError": ('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.chooseFiles": ('PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contentsSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contextMenuData": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createStandardContextMenu": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.devToolsPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.download": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.inspectedPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isAudioMuted": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isVisible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptAlert": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConfirm": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConsoleMessage": ('PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel', 'str', 'int', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptPrompt": ('PySide2.QtCore.QUrl', 'str', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.printToPdf": [('object', 'PySide2.QtGui.QPageLayout'), ('str', 'PySide2.QtGui.QPageLayout')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.profile": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.recentlyAudible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.replaceMisspelledWord": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.requestedUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.runJavaScript": [('str',), ('str', 'int'), ('str', 'int', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.save": ('str', 'PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scrollPosition": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setAudioMuted": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setDevToolsPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setFeaturePermission": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.Feature', 'PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setInspectedPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setView": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setVisible": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setWebChannel": [('PySide2.QtWebChannel.QWebChannel',), ('PySide2.QtWebChannel.QWebChannel', 'int')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toHtml": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toPlainText": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.triggerAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.view": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.webChannel": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.zoomFactor": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy:
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cachePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearAllVisitedLinks": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearHttpCache": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearVisitedLinks": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cookieStore": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.defaultProfile": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.downloadPath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpAcceptLanguage": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheMaximumSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpUserAgent": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.installUrlSchemeHandler": ('PySide2.QtCore.QByteArray', 'PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler'),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isOffTheRecord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isSpellCheckEnabled": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isUsedForGlobalCertificateVerification": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentCookiesPolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentStoragePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeAllUrlSchemeHandlers": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlScheme": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlSchemeHandler": ('PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setCachePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setDownloadPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpAcceptLanguage": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheMaximumSize": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheType": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpUserAgent": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentCookiesPolicy": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentStoragePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckEnabled": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckLanguages": ('typing.Sequence[str]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUseForGlobalCertificateVerification": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.spellCheckLanguages": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.storageName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.urlSchemeHandler": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.visitedLinksContainsUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtWebEngineWidgets.QWebEngineScript:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.ScriptWorldId:
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineScript',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.injectionPoint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.isNull": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.name": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.runsOnSubFrames": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setInjectionPoint": ('PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setRunsOnSubFrames": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setSourceCode": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setWorldId": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.sourceCode": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.swap": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.worldId": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineScriptCollection:
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.contains": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScript": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScripts": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.insert": [('PySide2.QtWebEngineWidgets.QWebEngineScript',), ('typing.Sequence[PySide2.QtWebEngineWidgets.QWebEngineScript]',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.isEmpty": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.remove": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.size": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.toList": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute:
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultTextEncoding": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.globalSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetUnknownUrlSchemePolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setDefaultTextEncoding": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize', 'int'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setUnknownUrlSchemePolicy": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.testAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.unknownUrlSchemePolicy": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineView:
-    "PySide2.QtWebEngineWidgets.QWebEngineView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.pageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.reload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.sizeHint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.stop": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.triggerPageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.zoomFactor": (),
-    }) if "PySide2.QtWebEngineWidgets" in sys.modules else None
-# Module PySide2.QtWebSockets
-sig_dict.update({
-# class PySide2.QtWebSockets.QMaskGenerator:
-    "PySide2.QtWebSockets.QMaskGenerator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebSockets.QMaskGenerator.nextMask": (),
-    "PySide2.QtWebSockets.QMaskGenerator.seed": (),
-# class PySide2.QtWebSockets.QWebSocket:
-    "PySide2.QtWebSockets.QWebSocket.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketProtocol.Version', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocket.abort": (),
-    "PySide2.QtWebSockets.QWebSocket.bytesToWrite": (),
-    "PySide2.QtWebSockets.QWebSocket.close": ('PySide2.QtWebSockets.QWebSocketProtocol.CloseCode', 'str'),
-    "PySide2.QtWebSockets.QWebSocket.closeCode": (),
-    "PySide2.QtWebSockets.QWebSocket.closeReason": (),
-    "PySide2.QtWebSockets.QWebSocket.error": (),
-    "PySide2.QtWebSockets.QWebSocket.errorString": (),
-    "PySide2.QtWebSockets.QWebSocket.flush": (),
-    "PySide2.QtWebSockets.QWebSocket.isValid": (),
-    "PySide2.QtWebSockets.QWebSocket.localAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.localPort": (),
-    "PySide2.QtWebSockets.QWebSocket.maskGenerator": (),
-    "PySide2.QtWebSockets.QWebSocket.open": [('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtWebSockets.QWebSocket.origin": (),
-    "PySide2.QtWebSockets.QWebSocket.pauseMode": (),
-    "PySide2.QtWebSockets.QWebSocket.peerAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.peerName": (),
-    "PySide2.QtWebSockets.QWebSocket.peerPort": (),
-    "PySide2.QtWebSockets.QWebSocket.ping": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.proxy": (),
-    "PySide2.QtWebSockets.QWebSocket.readBufferSize": (),
-    "PySide2.QtWebSockets.QWebSocket.request": (),
-    "PySide2.QtWebSockets.QWebSocket.requestUrl": (),
-    "PySide2.QtWebSockets.QWebSocket.resourceName": (),
-    "PySide2.QtWebSockets.QWebSocket.resume": (),
-    "PySide2.QtWebSockets.QWebSocket.sendBinaryMessage": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.sendTextMessage": ('str',),
-    "PySide2.QtWebSockets.QWebSocket.setMaskGenerator": ('PySide2.QtWebSockets.QMaskGenerator',),
-    "PySide2.QtWebSockets.QWebSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtWebSockets.QWebSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocket.setReadBufferSize": ('int',),
-    "PySide2.QtWebSockets.QWebSocket.state": (),
-    "PySide2.QtWebSockets.QWebSocket.version": (),
-# class PySide2.QtWebSockets.QWebSocketCorsAuthenticator:
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.__init__": [('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',), ('str',)],
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.allowed": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.origin": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.setAllowed": ('bool',),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.swap": ('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',),
-# class PySide2.QtWebSockets.QWebSocketProtocol:
-# class PySide2.QtWebSockets.QWebSocketProtocol.CloseCode:
-# class PySide2.QtWebSockets.QWebSocketProtocol.Version:
-# class PySide2.QtWebSockets.QWebSocketServer:
-# class PySide2.QtWebSockets.QWebSocketServer.SslMode:
-    "PySide2.QtWebSockets.QWebSocketServer.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketServer.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocketServer.close": (),
-    "PySide2.QtWebSockets.QWebSocketServer.error": (),
-    "PySide2.QtWebSockets.QWebSocketServer.errorString": (),
-    "PySide2.QtWebSockets.QWebSocketServer.handleConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtWebSockets.QWebSocketServer.handshakeTimeoutMS": (),
-    "PySide2.QtWebSockets.QWebSocketServer.hasPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.isListening": (),
-    "PySide2.QtWebSockets.QWebSocketServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtWebSockets.QWebSocketServer.maxPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nativeDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nextPendingConnection": (),
-    "PySide2.QtWebSockets.QWebSocketServer.pauseAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.proxy": (),
-    "PySide2.QtWebSockets.QWebSocketServer.resumeAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.secureMode": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverAddress": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverName": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverPort": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverUrl": (),
-    "PySide2.QtWebSockets.QWebSocketServer.setHandshakeTimeout": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setNativeDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocketServer.setServerName": ('str',),
-    "PySide2.QtWebSockets.QWebSocketServer.setSocketDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.socketDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.supportedVersions": (),
-    }) if "PySide2.QtWebSockets" in sys.modules else None
-# Module PySide2.Qt3DCore
-sig_dict.update({
-# class PySide2.Qt3DCore.Qt3DCore:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlag:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlags:
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractAspect:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.rootEntityId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.unregisterBackendType": ('PySide2.QtCore.QMetaObject',),
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton.jointCount": (),
-# class PySide2.Qt3DCore.Qt3DCore.QArmature:
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.skeleton": (),
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine:
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.aspects": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.executeCommand": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.processFrame": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.runMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.setRunMode": ('PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.unregisterAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-# class PySide2.Qt3DCore.Qt3DCore.QAspectJob:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.__init__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.run": (),
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode:
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode:
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode',),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.mode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.peerId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.setEnabled": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponent:
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.entities": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.isShareable": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.setShareable": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QEntity:
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.addComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.components": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.parentEntity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.removeComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-# class PySide2.Qt3DCore.Qt3DCore.QJoint:
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.addChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.childJoints": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.inverseBindMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.removeChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setInverseBindMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setScale": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setToIdentity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.translation": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNode:
-# class PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode:
-    "PySide2.Qt3DCore.Qt3DCore.QNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.blockNotifications": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.childNodes": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTrackings": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.defaultPropertyTrackingMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.notificationsBlocked": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.parentNode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.propertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setDefaultPropertyTrackingMode": ('PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setParent": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QObject',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setPropertyTracking": ('str', 'PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode'),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCommand:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.commandId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.data": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.inReplyTo": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setData": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setReplyToCommandId": ('int',),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.isNodeEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.parentId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode', 'typing.List[PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair]'),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.subtreeIdsAndTypes": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeId:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__copy__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.createId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.isNull": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.QtCore.QMetaObject'), ('PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__copy__": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.addedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.removedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.addedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.setAddedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.removedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.setRemovedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlag:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags:
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.ChangeFlag', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.deliveryFlags": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.setDeliveryFlags": ('PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags',),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.subjectId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.type": (),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.setRootJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader:
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.Status:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.isCreateJointsEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setCreateJointsEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.source": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.status": (),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QTransform:
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxesAndAngles": [('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.matrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateAround": ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateFromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale3D": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale3D": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.translation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.worldMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.qHash": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'int'),
-    "PySide2.Qt3DCore.Qt3DCore.qIdForNode": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    }) if "PySide2.Qt3DCore" in sys.modules else None
-# Module PySide2.Qt3DRender
-sig_dict.update({
-# class PySide2.Qt3DRender.Qt3DRender:
-# class PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface:
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.readProperty": ('typing.Any',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.id": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight.Type:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.color": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.intensity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setIntensity": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.type": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.hits": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.runMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setRunMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.addTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.generateMipMaps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.removeTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.samples": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setGenerateMipMaps": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSamples": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWrapMode": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.textureImages": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.wrapMode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.notifyDataGeneratorChanged": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setMipLevel": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest:
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.alphaFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setAlphaFunction": ('PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setReferenceValue": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType:
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'str', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.attributeType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.buffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteStride": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.count": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultColorAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointIndicesAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointWeightsAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultNormalAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultPositionAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTangentAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate1AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate2AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinateAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.divisor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setAttributeType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setBuffer": ('PySide2.Qt3DRender.Qt3DRender.QBuffer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteStride": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDivisor": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexBaseType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexBaseType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexSize": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.blendFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.setBlendFunction": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.bufferIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationRgb": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setBufferIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceRgb": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod:
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destination": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.interpolationMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestination": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setInterpolationMethod": ('PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSource": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceRect": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType:
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.accessType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.data": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.isSyncData": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setAccessType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setSyncData": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setUsage": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.updateData": ('int', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.usage": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCamera:
-# class PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption:
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.lens": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.pan": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panAboutViewCenter": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.roll": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotate": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotateAboutViewCenter": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotation": ('float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setUpVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setViewCenter": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tilt": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.transform": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translate": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translateWorld": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.upVector": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewCenter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewVector": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens:
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFrustumProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setOrthographicProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setPerspectiveProjection": ('float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewAll": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferTypeFlags:
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.buffers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearColor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearDepthValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearStencilValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.colorBuffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setBuffers": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearDepthValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearStencilValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setColorBuffer": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QClipPlane:
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.normal": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.planeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setDistance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setNormal": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setPlaneIndex": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QColorMask:
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isAlphaMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isBlueMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isGreenMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isRedMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setAlphaMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setBlueMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setGreenMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setRedMasked": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand:
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType:
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.runType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setRunType": ('PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.trigger": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace:
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode:
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.mode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.setMode": ('PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest:
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.depthFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.setDepthFunction": ('PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QDirectionalLight:
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.setWorldDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.worldDirection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDispatchCompute:
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDithering:
-    "PySide2.Qt3DRender.Qt3DRender.QDithering.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QEffect:
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.techniques": (),
-# class PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight:
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.irradiance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setIrradiance": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.specular": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFilterKey:
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.parentFrameGraphNode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.__init__": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.parentFrameGraphNodeId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace:
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection:
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.setDirection": ('PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection',),
-# class PySide2.Qt3DRender.Qt3DRender.QFrustumCulling:
-    "PySide2.Qt3DRender.Qt3DRender.QFrustumCulling.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometry:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.attributes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.boundingVolumePositionAttribute": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.maxExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.minExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.setBoundingVolumePositionAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryFactory:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryFactory.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer:
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstInstance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstVertex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.geometry": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexBufferByteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.instanceCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveRestartEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.restartIndexValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstInstance": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstVertex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexBufferByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setInstanceCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVertexCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVerticesPerPatch": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.vertexCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.verticesPerPatch": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile:
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.api": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.extensions": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.majorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.minorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.profile": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setApi": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setExtensions": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMajorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMinorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setProfile": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setVendor": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.vendor": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLayer:
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.recursive": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.setRecursive": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode:
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail:
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.createBoundingSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.currentIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCurrentIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholdType": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholds": ('typing.List[float]',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setVolumeOverride": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholdType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholds": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.volumeOverride": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.__init__": [('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',), ('PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.center": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.isEmpty": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.radius": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLineWidth:
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setSmooth": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.smooth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMaterial:
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.effect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.setEffect": ('PySide2.Qt3DRender.Qt3DRender.QEffect',),
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operation:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations:
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.setWaitOperations": ('PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.waitOperations": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMesh:
-# class PySide2.Qt3DRender.Qt3DRender.QMesh.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.meshName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setMeshName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing:
-    "PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDepthMask:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDepthMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDraw:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDraw.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoPicking:
-    "PySide2.Qt3DRender.Qt3DRender.QNoPicking.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QObjectPicker:
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.containsMouse": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isDragEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isHoverEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isPressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.priority": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setDragEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setHoverEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setPriority": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.size": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.update": ('PySide2.QtCore.QRect',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QParameter:
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('str', 'PySide2.Qt3DRender.Qt3DRender.QAbstractTexture', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('str', 'typing.Any', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Modifiers:
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.button": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.buttons": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.isAccepted": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.modifiers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.viewport": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickLineEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.edgeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex2Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickPointEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.pointIndex": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.triangleIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.uvw": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex3Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.faceOrientationPickingMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickResultMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setFaceOrientationPickingMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickMethod": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickResultMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setWorldSpaceTolerance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.worldSpaceTolerance": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPointLight:
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize:
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setSizeMode": ('PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.sizeMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPolygonOffset:
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.depthSteps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.scaleFactor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setDepthSteps": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setScaleFactor": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QProximityFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.distanceThreshold": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setDistanceThreshold": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.length": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.origin": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setLength": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.trigger": [(), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float')],
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit:
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__init__": [(), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit',), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType', 'PySide2.Qt3DCore.Qt3DCore.QNodeId', 'float', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__copy__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entityId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.primitiveIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex3Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderAspect.__init__": [('PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.requestCapture": [(), ('PySide2.QtCore.QRect',), ('int',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.captureId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.image": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.isComplete": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveImage": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveToFile": ('str',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPass:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.renderStates": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.shaderProgram": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.matchAny": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.activeFrameGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.pickingSettings": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.renderPolicy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setRenderPolicy": ('PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderState:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderStateSet:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.renderStates": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.externalRenderTargetSize": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurfacePixelRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surface": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surfacePixelRatio": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTarget:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.addOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.removeOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.attachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setOutputs": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint]',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.target": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.component": ('str', 'PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType'),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entity": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entityNames": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScissorTest:
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setBottom": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setLeft": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.setPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.trigger": [(), ('PySide2.QtCore.QPoint',)],
-# class PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap:
-    "PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence:
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handleType": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderData:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.event": ('PySide2.QtCore.QEvent',),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.access": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layered": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setAccess": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayered": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.loadSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.log": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setComputeShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setFragmentShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setGeometryShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setShaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationControlShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationEvaluationShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setVertexShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.shaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.vertexShaderCode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.enabledLayers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setComputeShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setEnabledLayers": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setFragmentShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setGeometryShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationControlShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationEvaluationShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setVertexShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.shaderProgram": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderGraph": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture:
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.setTextureId": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.textureId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy:
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType:
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.setSortTypes": [('typing.List[PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType]',), ('typing.List[int]',)],
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypesInt": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSpotLight:
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.cutOffAngle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.localDirection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setCutOffAngle": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLocalDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilMask:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.backOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.frontOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setBackOutputMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setFrontOutputMask": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.FaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.allTestsPassOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.depthTestFailureOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setAllTestsPassOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setDepthTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setStencilTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.stencilTestFailureOperation": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTest:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.comparisonMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setComparisonMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setReferenceValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setStencilFunction": ('PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.stencilFunction": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechnique:
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.graphicsApiFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.renderPasses": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.matchAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture3D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture3D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureBuffer:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureBuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.isAutoMipMapGenerationEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.cleanup": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.data": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.faces": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.isCompressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.mipLevels": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelFormat": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setData": ('PySide2.QtCore.QByteArray', 'int', 'bool'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFaces": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setImage": ('PySide2.QtGui.QImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setMipLevels": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelFormat": ('PySide2.QtGui.QOpenGLTexture.PixelFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelType": ('PySide2.QtGui.QOpenGLTexture.PixelType',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setTarget": ('PySide2.QtGui.QOpenGLTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageDataGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureLoader:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.source": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureRectangle:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureRectangle.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.__init__": [('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject'), ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject')],
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.x": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.y": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.z": (),
-# class PySide2.Qt3DRender.Qt3DRender.QViewport:
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.gamma": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.normalizedRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setGamma": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setNormalizedRect": ('PySide2.QtCore.QRectF',),
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence:
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setTimeout": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setWaitOnCPU": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.timeout": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.waitOnCPU": (),
-    }) if "PySide2.Qt3DRender" in sys.modules else None
-# Module PySide2.Qt3DInput
-sig_dict.update({
-# class PySide2.Qt3DInput.Qt3DInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.addAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisSettings": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.removeAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-# class PySide2.Qt3DInput.Qt3DInput.QAction:
-    "PySide2.Qt3DInput.Qt3DInput.QAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.isActive": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-# class PySide2.Qt3DInput.Qt3DInput.QActionInput:
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.axis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.setAxis": ('int',),
-# class PySide2.Qt3DInput.Qt3DInput.QAxis:
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.value": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator:
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setScale": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxisType": ('PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxisType": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.value": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.velocity": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisSetting:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.deadZoneRadius": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.isSmoothEnabled": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setAxes": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setDeadZoneRadius": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setSmoothEnabled": ('bool',),
-# class PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.acceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.deceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setAcceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setDeceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setScale": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputAspect:
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.availablePhysicalDevices": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.createPhysicalDevice": ('str',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputChord:
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.addChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.chords": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.removeChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSequence:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.addSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.buttonInterval": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.removeSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.sequences": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setButtonInterval": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSettings:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.eventSource": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.setEventSource": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyEvent:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.count": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAutoRepeat": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.key": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.nativeScanCode": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.text": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.type": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.activeInput": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonNames": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.focus": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setFocus": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QLogicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.actions": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice.Axis:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.sensitivity": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.setSensitivity": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.button": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.wasHeld": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.y": (),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.containsMouse": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setContainsMouse": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QMouseDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.angleDelta": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.y": (),
-    }) if "PySide2.Qt3DInput" in sys.modules else None
-# Module PySide2.Qt3DLogic
-sig_dict.update({
-# class PySide2.Qt3DLogic.Qt3DLogic:
-# class PySide2.Qt3DLogic.Qt3DLogic.QFrameAction:
-    "PySide2.Qt3DLogic.Qt3DLogic.QFrameAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect:
-    "PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect.__init__": ('PySide2.QtCore.QObject',),
-    }) if "PySide2.Qt3DLogic" in sys.modules else None
-# Module PySide2.Qt3DAnimation
-sig_dict.update({
-# class PySide2.Qt3DAnimation.Qt3DAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.AnimationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setAnimationName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setDuration": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip.duration": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractChannelMapping:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.Loops:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.clock": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.isRunning": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.loopCount": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.normalizedTime": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setClock": ('PySide2.Qt3DAnimation.Qt3DAnimation.QClock',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setLoopCount": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setNormalizedTime": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setRunning": ('bool',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.start": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.stop": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.baseClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setBaseClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.Flag:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.__init__": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.valueChanged": ('typing.Any',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.Status:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.source": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.status": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.activeAnimationGroup": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.addAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.animationGroupList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.entity": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getAnimationIndex": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionOffset": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionScale": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.recursive": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.removeAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setActiveAnimationGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setAnimationGroups": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPosition": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionOffset": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionScale": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setRecursive": ('bool',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.addAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.animationList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.name": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.removeAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setAnimations": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.blendTree": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.setBlendTree": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.clip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.setClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClock:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.playbackRate": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.setPlaybackRate": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.__init__": [(), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.coordinates": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.interpolationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.leftControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.rightControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setCoordinates": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setInterpolationType": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setLeftControlPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setRightControlPoint": ('PySide2.QtGui.QVector2D',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.addKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.endMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.framePositions": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.keyframeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.removeKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEndMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setFramePositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setKeyframes": ('typing.List[PySide2.Qt3DCore.Qt3DCore.QTransform]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setStartMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTarget": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.startMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.targetName": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.blendFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.endClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setBlendFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setEndClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setStartClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.startClip": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeNames": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.fromGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry', 'typing.Sequence[str]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.setAttributes": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QAttribute]',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.getWeights": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.method": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMethod": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setWeights": ('int', 'typing.List[float]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetPositions": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.skeleton": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetPositions": (),
-    }) if "PySide2.Qt3DAnimation" in sys.modules else None
-# Module PySide2.Qt3DExtras
-sig_dict.update({
-# class PySide2.Qt3DExtras.Qt3DExtras:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__init__": [(), ('PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__copy__": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.acceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.deceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.linearSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.lookSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setAcceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setDeceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLinearSpeed": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLookSpeed": ('float',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.currentIndex": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setCurrentIndex": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.topRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.topRadius": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setDiffuse": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setSpecular": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.extrusionLength": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.depth": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer:
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.buffersToClear": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.clearColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.externalRenderTargetSize": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.gamma": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.isFrustumCullingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setBuffersToClear": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setFrustumCullingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setGamma": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setViewportRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.surface": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.viewportRect": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.beta": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.cool": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setBeta": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setCool": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setWarm": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.warm": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.ambientOcclusion": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.baseColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.metalness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.roughness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setAmbientOcclusion": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setBaseColor": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setMetalness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setRoughness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.interpolator": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setInterpolator": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.setZoomInLimit": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.zoomInLimit": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.blendFunctionArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setBlendFunctionArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.resolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.meshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.baseName": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.extension": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.isGammaCorrectEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setBaseName": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setExtension": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setGammaCorrectEnabled": ('bool',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.columns": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.rows": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setColumns": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setRows": ('int',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.addSprite": [('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.removeSprite": ('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.setSprites": ('typing.List[PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem]',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.sprites": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setHeight": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setWidth": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setX": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setY": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.width": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.x": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.y": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.color": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.text": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureOffset": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureTransform": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureOffset": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow:
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.__init__": ('PySide2.QtGui.QScreen',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.activeFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.defaultFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.renderSettings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setRootEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    }) if "PySide2.Qt3DExtras" in sys.modules else None
-# Module testbinding
-sig_dict.update({
-# class testbinding.Enum1:
-# class testbinding.IntValue:
-    "testbinding.IntValue.__init__": [(), ('int',), ('testbinding.IntValue',)],
-    "testbinding.IntValue.__copy__": (),
-# class testbinding.PySideCPP:
-# class testbinding.PySideCPP.TestObject2WithNamespace:
-    "testbinding.PySideCPP.TestObject2WithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObject2WithNamespace.__repr__": (),
-    "testbinding.PySideCPP.TestObject2WithNamespace.name": (),
-# class testbinding.PySideCPP.TestObjectWithNamespace:
-    "testbinding.PySideCPP.TestObjectWithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignal": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithNamespace": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.name": (),
-# class testbinding.TestObject:
-    "testbinding.TestObject.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "testbinding.TestObject.addChild": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObject.checkType": ('typing.Any',),
-    "testbinding.TestObject.createApp": (),
-    "testbinding.TestObject.emitIdValueSignal": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_bool": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_void": (),
-    "testbinding.TestObject.emitSignalWithTypedefValue": ('int',),
-    "testbinding.TestObject.emitStaticMethodDoubleSignal": (),
-    "testbinding.TestObject.idValue": (),
-    "testbinding.TestObject.staticMethodDouble": ('int',),
-# class testbinding.TestObjectWithoutNamespace:
-# class testbinding.TestObjectWithoutNamespace.Enum2:
-    "testbinding.TestObjectWithoutNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObjectWithoutNamespace.callSignal": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithNamespace": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.TestObjectWithoutNamespace.name": (),
-# class testbinding.TestView:
-    "testbinding.TestView.__init__": ('PySide2.QtCore.QAbstractListModel', 'PySide2.QtCore.QObject'),
-    "testbinding.TestView.getData": (),
-    "testbinding.TestView.getEditorWidgetFromItemDelegate": (),
-    "testbinding.TestView.model": (),
-    "testbinding.TestView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "testbinding.TestView.getHiddenObject": (),
-    }) if "testbinding" in sys.modules else None
-# Module Shiboken
-sig_dict.update({
-# class Shiboken.VoidPtr:
-    }) if "Shiboken" in sys.modules else None
-# Module minimal
-sig_dict.update({
-# class minimal.ListUser:
-    "minimal.ListUser.__init__": [(), ('minimal.ListUser',)],
-    "minimal.ListUser.__copy__": (),
-    "minimal.ListUser.callCreateIntList": ('int',),
-    "minimal.ListUser.callCreateListOfIntLists": ('int',),
-    "minimal.ListUser.callCreateMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.callCreateObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.callCreateValList": ('int',),
-    "minimal.ListUser.callOredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.callSumIntList": ('typing.List[int]',),
-    "minimal.ListUser.callSumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.callSumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.callSumValList": ('typing.List[minimal.Val]',),
-    "minimal.ListUser.createIntList": ('int',),
-    "minimal.ListUser.createListOfIntLists": ('int',),
-    "minimal.ListUser.createMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.createObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.createValList": ('int',),
-    "minimal.ListUser.oredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.sumIntList": ('typing.List[int]',),
-    "minimal.ListUser.sumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.sumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.sumValList": ('typing.List[minimal.Val]',),
-# class minimal.MinBoolUser:
-    "minimal.MinBoolUser.__init__": [(), ('minimal.MinBoolUser',)],
-    "minimal.MinBoolUser.__copy__": (),
-    "minimal.MinBoolUser.callInvertedMinBool": (),
-    "minimal.MinBoolUser.invertedMinBool": (),
-    "minimal.MinBoolUser.minBool": (),
-    "minimal.MinBoolUser.setMinBool": ('bool',),
-# class minimal.Obj:
-    "minimal.Obj.__init__": ('int',),
-    "minimal.Obj.callPassObjectType": ('minimal.Obj',),
-    "minimal.Obj.callPassObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.callVirtualMethod": ('int',),
-    "minimal.Obj.objId": (),
-    "minimal.Obj.passObjectType": ('minimal.Obj',),
-    "minimal.Obj.passObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.setObjId": ('int',),
-    "minimal.Obj.virtualMethod": ('int',),
-# class minimal.Val:
-# class minimal.Val.ValEnum:
-    "minimal.Val.__init__": [('int',), ('minimal.Val',)],
-    "minimal.Val.__copy__": (),
-    "minimal.Val.callPassValueType": ('minimal.Val',),
-    "minimal.Val.callPassValueTypePointer": ('minimal.Val',),
-    "minimal.Val.callPassValueTypeReference": ('minimal.Val',),
-    "minimal.Val.oneOrTheOtherEnumValue": ('minimal.Val.ValEnum',),
-    "minimal.Val.passValueType": ('minimal.Val',),
-    "minimal.Val.passValueTypePointer": ('minimal.Val',),
-    "minimal.Val.passValueTypeReference": ('minimal.Val',),
-    "minimal.Val.setValId": ('int',),
-    "minimal.Val.valId": (),
-    "minimal.Val.arrayFunc": ('typing.List[int]',),
-    "minimal.Val.arrayFuncInt": ('typing.List[int]',),
-    "minimal.Val.arrayFuncIntReturn": ('int',),
-    "minimal.Val.arrayFuncIntReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncIntTypedef": ('typing.List[int]',),
-    "minimal.Val.arrayFuncReturn": ('int',),
-    "minimal.Val.arrayFuncReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncTypedef": ('typing.List[int]',),
-    }) if "minimal" in sys.modules else None
-# Module sample
-sig_dict.update({
-# class sample.Abstract:
-# class sample.Abstract.PrintFormat:
-# class sample.Abstract.Type:
-    "sample.Abstract.__init__": ('int',),
-    "sample.Abstract.callPureVirtual": (),
-    "sample.Abstract.callUnpureVirtual": (),
-    "sample.Abstract.callVirtualGettingEnum": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.className": (),
-    "sample.Abstract.createObject": (),
-    "sample.Abstract.getObjectId": ('sample.Abstract',),
-    "sample.Abstract.id_": (),
-    "sample.Abstract.pureVirtual": (),
-    "sample.Abstract.pureVirtualReturningVoidPtr": (),
-    "sample.Abstract.returnAnEnum": (),
-    "sample.Abstract.show": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.type": (),
-    "sample.Abstract.unpureVirtual": (),
-    "sample.Abstract.virtualGettingAEnum": ('sample.Abstract.PrintFormat',),
-# class sample.AbstractModifications:
-    "sample.AbstractModifications.__init__": (),
-    "sample.AbstractModifications.invert": ('bool',),
-    "sample.AbstractModifications.pointlessPureVirtualMethod": (),
-# class sample.ArrayModifyTest:
-    "sample.ArrayModifyTest.__init__": [(), ('sample.ArrayModifyTest',)],
-    "sample.ArrayModifyTest.__copy__": (),
-    "sample.ArrayModifyTest.sumIntArray": ('int', 'typing.Sequence[int]'),
-# class sample.Base1:
-    "sample.Base1.__init__": (),
-    "sample.Base1.base1Method": (),
-    "sample.Base1.publicMethod": (),
-# class sample.Base2:
-    "sample.Base2.__init__": (),
-    "sample.Base2.base2Method": (),
-# class sample.Base3:
-    "sample.Base3.__init__": ('int',),
-    "sample.Base3.base3Method": (),
-# class sample.Base4:
-    "sample.Base4.__init__": (),
-    "sample.Base4.base4Method": (),
-# class sample.Base5:
-    "sample.Base5.__init__": (),
-    "sample.Base5.base5Method": (),
-# class sample.Base6:
-    "sample.Base6.__init__": (),
-    "sample.Base6.base6Method": (),
-# class sample.BlackBox:
-    "sample.BlackBox.__init__": [(), ('sample.BlackBox',)],
-    "sample.BlackBox.__copy__": (),
-    "sample.BlackBox.disposeObjectType": ('int',),
-    "sample.BlackBox.disposePoint": ('int',),
-    "sample.BlackBox.keepObjectType": ('object',),
-    "sample.BlackBox.keepPoint": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.objects": (),
-    "sample.BlackBox.points": (),
-    "sample.BlackBox.referenceToObjectPointer": ('object',),
-    "sample.BlackBox.referenceToValuePointer": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.retrieveObjectType": ('int',),
-    "sample.BlackBox.retrievePoint": ('int',),
-# class sample.Bucket:
-    "sample.Bucket.__init__": (),
-    "sample.Bucket.callVirtualBlockerMethodButYouDontKnowThis": (),
-    "sample.Bucket.empty": (),
-    "sample.Bucket.lock": (),
-    "sample.Bucket.locked": (),
-    "sample.Bucket.pop": (),
-    "sample.Bucket.push": ('int',),
-    "sample.Bucket.unlock": (),
-    "sample.Bucket.virtualBlockerMethod": (),
-# class sample.ByteArray:
-    "sample.ByteArray.__init__": [(), ('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__add__": [('int',), ('sample.ByteArray',), ('str',), ('unicode',)],
-    "sample.ByteArray.__copy__": (),
-    "sample.ByteArray.__iadd__": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__repr__": (),
-    "sample.ByteArray.__str__": (),
-    "sample.ByteArray.append": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.at": ('int',),
-    "sample.ByteArray.data": (),
-    "sample.ByteArray.size": (),
-# class sample.CVListUser:
-    "sample.CVListUser.__init__": [(), ('sample.CVListUser',)],
-    "sample.CVListUser.__copy__": (),
-    "sample.CVListUser.consume": ('typing.List[sample.CVValueType]',),
-    "sample.CVListUser.produce": (),
-# class sample.CVValueType:
-    "sample.CVValueType.__copy__": (),
-# class sample.ClassWithFunctionPointer:
-    "sample.ClassWithFunctionPointer.__init__": [(), ('sample.ClassWithFunctionPointer',)],
-    "sample.ClassWithFunctionPointer.__copy__": (),
-    "sample.ClassWithFunctionPointer.doNothing": ('int',),
-# class sample.Collector:
-    "sample.Collector.__init__": (),
-    "sample.Collector.__lshift__": [('Missing("sample.ObjectType.Identifier")',), ('object',), ('sample.IntWrapper',)],
-    "sample.Collector.clear": (),
-    "sample.Collector.items": (),
-    "sample.Collector.size": (),
-# class sample.Color:
-    "sample.Color.__init__": [(), ('int',), ('sample.Color',), ('sample.SampleNamespace.InValue',)],
-    "sample.Color.__copy__": (),
-    "sample.Color.isNull": (),
-# class sample.CtorConvRule:
-    "sample.CtorConvRule.__init__": [('int',), ('sample.CtorConvRule',)],
-    "sample.CtorConvRule.__copy__": (),
-    "sample.CtorConvRule.dummyVirtualMethod": (),
-    "sample.CtorConvRule.value": (),
-# class sample.Data:
-# class sample.Data.Field:
-    "sample.Data.__init__": [('sample.Data',), ('sample.Data.Field', 'str')],
-    "sample.Data.__and__": ('sample.Union',),
-    "sample.Data.__copy__": (),
-    "sample.Data.field": (),
-    "sample.Data.value": (),
-# class sample.Derived:
-# class sample.Derived.OtherOverloadedFuncEnum:
-# class sample.Derived.SomeInnerClass:
-    "sample.Derived.SomeInnerClass.__init__": [(), ('sample.Derived.SomeInnerClass',)],
-    "sample.Derived.SomeInnerClass.__add__": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.SomeInnerClass.__copy__": (),
-    "sample.Derived.SomeInnerClass.uselessMethod": (),
-    "sample.Derived.__init__": ('int',),
-    "sample.Derived.className": (),
-    "sample.Derived.createObject": (),
-    "sample.Derived.defaultValue": ('int',),
-    "sample.Derived.getClassName": (),
-    "sample.Derived.otherOverloaded": [('int', 'float'), ('int', 'int', 'bool', 'float')],
-    "sample.Derived.overloaded": [('float',), ('int', 'int')],
-    "sample.Derived.pureVirtual": (),
-    "sample.Derived.pureVirtualReturningVoidPtr": (),
-    "sample.Derived.returnAnEnum": (),
-    "sample.Derived.returnMyParameter": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.singleArgument": ('bool',),
-    "sample.Derived.triggerAnotherImpossibleTypeDiscovery": (),
-    "sample.Derived.triggerImpossibleTypeDiscovery": (),
-    "sample.Derived.type": (),
-    "sample.Derived.unpureVirtual": (),
-# class sample.Echo:
-    "sample.Echo.__init__": [(), ('sample.Echo',)],
-    "sample.Echo.__call__": ('sample.Str', 'int'),
-    "sample.Echo.__copy__": (),
-    "sample.Echo.__lshift__": [('int',), ('object',), ('sample.Str',)],
-    "sample.Echo.doNothingWithConstBool": ('bool',),
-    "sample.Echo.echo": ('str',),
-    "sample.Echo.methodWithNamedArg": ('sample.Str',),
-# class sample.EnumOnNamespace:
-# class sample.Event:
-# class sample.Event.EventType:
-# class sample.Event.EventTypeClass:
-    "sample.Event.__init__": [('sample.Event',), ('sample.Event.EventType',)],
-    "sample.Event.__copy__": (),
-    "sample.Event.eventType": (),
-    "sample.Event.setEventType": ('sample.Event.EventType',),
-    "sample.Event.setEventTypeByConstRef": ('sample.Event.EventType',),
-# class sample.ExceptionTest:
-    "sample.ExceptionTest.__init__": (),
-    "sample.ExceptionTest.intThrowInt": ('bool',),
-    "sample.ExceptionTest.intThrowStdException": ('bool',),
-    "sample.ExceptionTest.voidThrowInt": ('bool',),
-    "sample.ExceptionTest.voidThrowStdException": ('bool',),
-# class sample.Expression:
-    "sample.Expression.__init__": [('int',), ('sample.Expression',)],
-    "sample.Expression.__add__": ('sample.Expression',),
-    "sample.Expression.__copy__": (),
-    "sample.Expression.__sub__": ('sample.Expression',),
-    "sample.Expression.toString": (),
-# class sample.Filter:
-    "sample.Filter.__init__": [(), ('sample.Filter',)],
-    "sample.Filter.__copy__": (),
-# class sample.FriendOfOnlyCopy:
-    "sample.FriendOfOnlyCopy.__init__": [(), ('sample.FriendOfOnlyCopy',)],
-    "sample.FriendOfOnlyCopy.__copy__": (),
-    "sample.FriendOfOnlyCopy.createListOfOnlyCopy": ('int',),
-    "sample.FriendOfOnlyCopy.createOnlyCopy": ('int',),
-# class sample.GlobalEnum:
-# class sample.GlobalOverloadFuncEnum:
-# class sample.HandleHolder:
-    "sample.HandleHolder.__init__": ('int',),
-    "sample.HandleHolder.compare": ('sample.HandleHolder',),
-    "sample.HandleHolder.compare2": ('sample.HandleHolder',),
-    "sample.HandleHolder.createHandle": (),
-    "sample.HandleHolder.handle": (),
-    "sample.HandleHolder.handle2": (),
-    "sample.HandleHolder.set": ('int',),
-# class sample.ImplicitBase:
-    "sample.ImplicitBase.__init__": [(), ('sample.ImplicitBase',), ('sample.ImplicitTarget',)],
-    "sample.ImplicitBase.__copy__": (),
-# class sample.ImplicitConv:
-# class sample.ImplicitConv.CtorEnum:
-# class sample.ImplicitConv.ICOverloadedFuncEnum:
-    "sample.ImplicitConv.__init__": [(), ('None',), ('float', 'bool'), ('int',), ('object',), ('sample.ImplicitConv',), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.__copy__": (),
-    "sample.ImplicitConv.ctorEnum": (),
-    "sample.ImplicitConv.implicitConvCommon": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvDefault": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvOverloading": [('int',), ('sample.ImplicitConv', 'bool'), ('sample.ImplicitConv', 'int'), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.objId": (),
-    "sample.ImplicitConv.value": (),
-# class sample.ImplicitTarget:
-    "sample.ImplicitTarget.__init__": [(), ('sample.ImplicitTarget',)],
-    "sample.ImplicitTarget.__copy__": (),
-# class sample.InjectCode:
-    "sample.InjectCode.__init__": [(), ('sample.InjectCode',)],
-    "sample.InjectCode.__copy__": (),
-    "sample.InjectCode.arrayMethod": ('int',),
-    "sample.InjectCode.callArrayMethod": ('int',),
-    "sample.InjectCode.overloadedMethod": [('int', 'bool'), ('int', 'float'), ('int', 'typing.List[str]')],
-    "sample.InjectCode.simpleMethod1": ('int', 'int'),
-    "sample.InjectCode.simpleMethod2": (),
-    "sample.InjectCode.simpleMethod3": ('int', 'typing.List[str]'),
-    "sample.InjectCode.sumArrayAndLength": (),
-    "sample.InjectCode.virtualMethod": ('int',),
-# class sample.IntArray2:
-    "sample.IntArray2.__init__": [('int',), ('sample.IntArray2',), ('typing.Sequence[int]',)],
-    "sample.IntArray2.__copy__": (),
-    "sample.IntArray2.sum": (),
-# class sample.IntArray3:
-    "sample.IntArray3.__init__": [('int',), ('sample.IntArray3',), ('typing.Sequence[int]',)],
-    "sample.IntArray3.__copy__": (),
-    "sample.IntArray3.sum": (),
-# class sample.IntList:
-# class sample.IntList.CtorEnum:
-    "sample.IntList.__init__": [(), ('int',), ('sample.IntList',), ('typing.Sequence[int]',)],
-    "sample.IntList.__copy__": (),
-    "sample.IntList.append": ('int',),
-    "sample.IntList.constructorUsed": (),
-# class sample.IntWrapper:
-    "sample.IntWrapper.__init__": [('int',), ('sample.IntWrapper',)],
-    "sample.IntWrapper.__copy__": (),
-# class sample.Intersection:
-    "sample.Intersection.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Intersection.__and__": ('sample.Intersection',),
-    "sample.Intersection.__copy__": (),
-    "sample.Intersection.addFilter": ('sample.Filter',),
-    "sample.Intersection.filters": (),
-# class sample.ListUser:
-# class sample.ListUser.ListOfSomething:
-    "sample.ListUser.__init__": [(), ('sample.ListUser',)],
-    "sample.ListUser.__copy__": (),
-    "sample.ListUser.callCreateList": (),
-    "sample.ListUser.createComplexList": ('complex', 'complex'),
-    "sample.ListUser.createList": (),
-    "sample.ListUser.getList": (),
-    "sample.ListUser.listOfPoints": [('typing.List[sample.PointF]',), ('typing.List[typing.Tuple]',)],
-    "sample.ListUser.multiplyPointList": ('typing.List[typing.Tuple]', 'float'),
-    "sample.ListUser.setList": ('typing.List[int]',),
-    "sample.ListUser.sumList": [('typing.List[float]',), ('typing.List[int]',)],
-# class sample.MDerived1:
-    "sample.MDerived1.__init__": (),
-    "sample.MDerived1.base1Method": (),
-    "sample.MDerived1.base2Method": (),
-    "sample.MDerived1.castToBase1": (),
-    "sample.MDerived1.castToBase2": (),
-    "sample.MDerived1.mderived1Method": (),
-    "sample.MDerived1.publicMethod": (),
-    "sample.MDerived1.transformFromBase1": ('sample.Base1',),
-    "sample.MDerived1.transformFromBase2": ('sample.Base2',),
-# class sample.MDerived2:
-    "sample.MDerived2.__init__": (),
-    "sample.MDerived2.base4Method": (),
-    "sample.MDerived2.castToBase3": (),
-    "sample.MDerived2.castToBase4": (),
-    "sample.MDerived2.castToBase5": (),
-    "sample.MDerived2.castToBase6": (),
-    "sample.MDerived2.mderived2Method": (),
-# class sample.MDerived3:
-    "sample.MDerived3.__init__": (),
-    "sample.MDerived3.castToBase3": (),
-    "sample.MDerived3.castToMDerived1": (),
-    "sample.MDerived3.castToMDerived2": (),
-    "sample.MDerived3.mderived3Method": (),
-# class sample.MDerived4:
-    "sample.MDerived4.__init__": (),
-    "sample.MDerived4.castToBase3": (),
-    "sample.MDerived4.castToBase4": (),
-    "sample.MDerived4.justDummyMethod": (),
-    "sample.MDerived4.mderived4Method": (),
-# class sample.MDerived5:
-    "sample.MDerived5.__init__": (),
-    "sample.MDerived5.castToBase3": (),
-    "sample.MDerived5.castToBase4": (),
-    "sample.MDerived5.mderived5Method": (),
-# class sample.MapUser:
-    "sample.MapUser.__init__": [(), ('sample.MapUser',)],
-    "sample.MapUser.__copy__": (),
-    "sample.MapUser.callCreateMap": (),
-    "sample.MapUser.createMap": (),
-    "sample.MapUser.foo": (),
-    "sample.MapUser.getMap": (),
-    "sample.MapUser.passMapIntValueType": ('typing.Dict[int, sample.ByteArray]',),
-    "sample.MapUser.pointerToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.referenceToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.setMap": ('typing.Dict[str, typing.List]',),
-    "sample.MapUser.showMap": ('typing.Dict[str, int]',),
-# class sample.ModelIndex:
-    "sample.ModelIndex.__init__": [(), ('sample.ModelIndex',)],
-    "sample.ModelIndex.__copy__": (),
-    "sample.ModelIndex.getValue": ('sample.ModelIndex',),
-    "sample.ModelIndex.setValue": ('int',),
-    "sample.ModelIndex.value": (),
-# class sample.Modifications:
-# class sample.Modifications.OverloadedModFunc:
-# class sample.Modifications.TestEnum:
-    "sample.Modifications.__init__": (),
-    "sample.Modifications.argRemoval0": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'int')],
-    "sample.Modifications.argRemoval1": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.argRemoval2": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval3": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval4": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval5": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.calculateArea": ('int', 'int'),
-    "sample.Modifications.callDifferenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.defaultEnumValue": (),
-    "sample.Modifications.differenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.doublePlus": ('int', 'int'),
-    "sample.Modifications.enumValue": (),
-    "sample.Modifications.getObject": (),
-    "sample.Modifications.getSize": ('int', 'int'),
-    "sample.Modifications.increment": ('int',),
-    "sample.Modifications.invertBoolean": ('bool',),
-    "sample.Modifications.multiplyPointCoordsPlusValue": ('typing.Tuple[float, float]', 'float'),
-    "sample.Modifications.name": (),
-    "sample.Modifications.nonConversionRuleForArgumentWithDefaultValue": ('object',),
-    "sample.Modifications.over": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Modifications.overloaded": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'float'), ('int', 'bool', 'int', 'int'), ('int', 'bool', 'int', 'typing.Tuple[float, float]')],
-    "sample.Modifications.pointToPair": ('typing.Tuple[float, float]',),
-    "sample.Modifications.power": ('int', 'int'),
-    "sample.Modifications.setEnumValue": ('sample.Modifications.TestEnum',),
-    "sample.Modifications.sumPointArray": ('int', 'typing.Sequence[typing.Tuple]'),
-    "sample.Modifications.sumPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.timesTen": ('int',),
-# class sample.ModifiedConstructor:
-    "sample.ModifiedConstructor.__init__": ('int',),
-    "sample.ModifiedConstructor.retrieveValue": (),
-# class sample.NoImplicitConversion:
-    "sample.NoImplicitConversion.__init__": [('int',), ('sample.NoImplicitConversion',)],
-    "sample.NoImplicitConversion.__copy__": (),
-    "sample.NoImplicitConversion.objId": (),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByPointer": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByReference": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByValue": ('sample.NoImplicitConversion',),
-# class sample.NonDefaultCtor:
-    "sample.NonDefaultCtor.__init__": [('int',), ('sample.NonDefaultCtor',)],
-    "sample.NonDefaultCtor.__copy__": (),
-    "sample.NonDefaultCtor.callReturnMyselfVirtual": (),
-    "sample.NonDefaultCtor.returnMyself": [(), ('int',), ('int', 'sample.NonDefaultCtor')],
-    "sample.NonDefaultCtor.returnMyselfVirtual": (),
-    "sample.NonDefaultCtor.value": (),
-# class sample.ObjTypeReference:
-    "sample.ObjTypeReference.__init__": [(), ('sample.ObjTypeReference',)],
-    "sample.ObjTypeReference.justAPureVirtualFunc": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMyFirstArg": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMySecondArg": ('int', 'sample.ObjTypeReference'),
-# class sample.ObjectModel:
-# class sample.ObjectModel.MethodCalled:
-    "sample.ObjectModel.__init__": ('object',),
-    "sample.ObjectModel.data": (),
-    "sample.ObjectModel.receivesObjectTypeFamily": [('object',), ('sample.ObjectModel',)],
-    "sample.ObjectModel.setData": ('object',),
-# class sample.ObjectType:
-    "sample.ObjectType.__init__": ('object',),
-    "sample.ObjectType.callId": (),
-    "sample.ObjectType.callInvalidateEvent": ('sample.Event',),
-    "sample.ObjectType.callVirtualCreateChild": (),
-    "sample.ObjectType.callWithEnum": [('sample.Str', 'int'), ('sample.Str', 'sample.Event.EventType', 'int')],
-    "sample.ObjectType.causeEvent": ('sample.Event.EventType',),
-    "sample.ObjectType.children": (),
-    "sample.ObjectType.create": (),
-    "sample.ObjectType.createChild": ('object',),
-    "sample.ObjectType.createObjectType": (),
-    "sample.ObjectType.createWithChild": (),
-    "sample.ObjectType.deprecatedFunction": (),
-    "sample.ObjectType.destroyCppParent": (),
-    "sample.ObjectType.event": ('sample.Event',),
-    "sample.ObjectType.findChild": ('sample.Str',),
-    "sample.ObjectType.getCppParent": (),
-    "sample.ObjectType.identifier": (),
-    "sample.ObjectType.invalidateEvent": ('sample.Event',),
-    "sample.ObjectType.isLayoutType": (),
-    "sample.ObjectType.isPython": (),
-    "sample.ObjectType.killChild": ('sample.Str',),
-    "sample.ObjectType.layout": (),
-    "sample.ObjectType.nextInFocusChain": (),
-    "sample.ObjectType.objectName": (),
-    "sample.ObjectType.parent": (),
-    "sample.ObjectType.processEvent": ('typing.List[object]', 'sample.Event'),
-    "sample.ObjectType.removeChild": ('object',),
-    "sample.ObjectType.setLayout": ('sample.ObjectTypeLayout',),
-    "sample.ObjectType.setNullObject": ('None',),
-    "sample.ObjectType.setObject": ('object',),
-    "sample.ObjectType.setObjectName": ('sample.Str',),
-    "sample.ObjectType.setObjectNameWithSize": [('sample.Str', 'int'), ('str', 'int', 'sample.Str')],
-    "sample.ObjectType.setObjectSplittedName": ('str', 'sample.Str', 'sample.Str'),
-    "sample.ObjectType.setParent": ('object',),
-    "sample.ObjectType.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeByValue:
-    "sample.ObjectTypeByValue.__init__": (),
-    "sample.ObjectTypeByValue.acceptKindOfMeAsValue": ('sample.ObjectTypeByValue',),
-    "sample.ObjectTypeByValue.acceptListOfObjectTypeByValue": ('typing.List[sample.ObjectTypeByValue]',),
-    "sample.ObjectTypeByValue.returnSomeKindOfMe": (),
-# class sample.ObjectTypeDerived:
-    "sample.ObjectTypeDerived.__init__": (),
-    "sample.ObjectTypeDerived.event": ('sample.Event',),
-# class sample.ObjectTypeHolder:
-    "sample.ObjectTypeHolder.__init__": [('sample.ObjectTypeHolder',), ('str',)],
-    "sample.ObjectTypeHolder.__copy__": (),
-    "sample.ObjectTypeHolder.callPassObjectTypeAsReference": (),
-    "sample.ObjectTypeHolder.getObjecType": (),
-    "sample.ObjectTypeHolder.passObjectTypeAsReference": ('object',),
-# class sample.ObjectTypeLayout:
-    "sample.ObjectTypeLayout.__init__": (),
-    "sample.ObjectTypeLayout.addObject": ('object',),
-    "sample.ObjectTypeLayout.create": (),
-    "sample.ObjectTypeLayout.isLayoutType": (),
-    "sample.ObjectTypeLayout.objects": (),
-    "sample.ObjectTypeLayout.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeOperators:
-    "sample.ObjectTypeOperators.__init__": ('str',),
-    "sample.ObjectTypeOperators.__add__": ('str',),
-    "sample.ObjectTypeOperators.key": (),
-# class sample.ObjectTypePtrList:
-# class sample.ObjectTypePtrList.CtorEnum:
-    "sample.ObjectTypePtrList.__init__": [(), ('object',), ('sample.ObjectTypePtrList',), ('typing.Sequence[object]',)],
-    "sample.ObjectTypePtrList.__copy__": (),
-    "sample.ObjectTypePtrList.append": ('object',),
-    "sample.ObjectTypePtrList.constructorUsed": (),
-# class sample.ObjectView:
-    "sample.ObjectView.__init__": ('sample.ObjectModel', 'object'),
-    "sample.ObjectView.displayModelData": (),
-    "sample.ObjectView.getRawModelData": (),
-    "sample.ObjectView.model": (),
-    "sample.ObjectView.modifyModelData": ('sample.Str',),
-    "sample.ObjectView.setModel": ('sample.ObjectModel',),
-# class sample.OddBoolUser:
-    "sample.OddBoolUser.__init__": [(), ('bool',), ('sample.OddBoolUser',)],
-    "sample.OddBoolUser.__copy__": (),
-    "sample.OddBoolUser.callInvertedOddBool": (),
-    "sample.OddBoolUser.getOddBool": ('sample.OddBoolUser',),
-    "sample.OddBoolUser.invertedOddBool": (),
-    "sample.OddBoolUser.oddBool": (),
-    "sample.OddBoolUser.setOddBool": ('bool',),
-# class sample.OnlyCopy:
-    "sample.OnlyCopy.__init__": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.__copy__": (),
-    "sample.OnlyCopy.getValue": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.getValueFromReference": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.value": (),
-# class sample.OtherBase:
-    "sample.OtherBase.__init__": (),
-# class sample.Overload:
-# class sample.Overload.FunctionEnum:
-# class sample.Overload.ParamEnum:
-    "sample.Overload.__init__": (),
-    "sample.Overload.acceptSequence": [(), ('int',), ('int', 'int'), ('sample.Size',), ('sample.Str', 'sample.Overload.ParamEnum'), ('typing.Sequence[str]',)],
-    "sample.Overload.differentReturnTypes": [('sample.Overload.ParamEnum',), ('sample.Overload.ParamEnum', 'int')],
-    "sample.Overload.drawText": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText2": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText3": [('int', 'int', 'int', 'int', 'int'), ('sample.Str', 'sample.Str', 'sample.Str')],
-    "sample.Overload.drawText4": [('int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "sample.Overload.intDoubleOverloads": [('float', 'float'), ('int', 'int')],
-    "sample.Overload.intOverloads": [('int', 'int'), ('int', 'int', 'float'), ('typing.Tuple[float, float]', 'float')],
-    "sample.Overload.overloaded": [(), ('sample.Size',), ('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'sample.Overload.ParamEnum')],
-    "sample.Overload.singleOverload": [(), ('typing.Tuple[float, float]',)],
-    "sample.Overload.strBufferOverloads": [(), ('sample.Str', 'int'), ('sample.Str', 'str', 'bool'), ('str', 'int')],
-    "sample.Overload.wrapperIntIntOverloads": [('sample.Polygon', 'int', 'int'), ('typing.Tuple[float, float]', 'int', 'int')],
-# class sample.Overload2:
-    "sample.Overload2.__init__": (),
-    "sample.Overload2.doNothingInPublic": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic2": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic3": [(), ('int',)],
-# class sample.OverloadedFuncEnum:
-# class sample.PairUser:
-    "sample.PairUser.__init__": [(), ('sample.PairUser',)],
-    "sample.PairUser.__copy__": (),
-    "sample.PairUser.callCreatePair": (),
-    "sample.PairUser.createComplexPair": ('complex', 'complex'),
-    "sample.PairUser.createPair": (),
-    "sample.PairUser.getPair": (),
-    "sample.PairUser.setPair": ('typing.Tuple[int, int]',),
-    "sample.PairUser.sumPair": ('typing.Tuple[int, float]',),
-# class sample.Pen:
-    "sample.Pen.__init__": [(), ('sample.Color',), ('sample.Pen',), ('sample.SampleNamespace.Option',)],
-    "sample.Pen.__copy__": (),
-    "sample.Pen.ctorType": (),
-# class sample.PersistentModelIndex:
-    "sample.PersistentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.PersistentModelIndex',)],
-    "sample.PersistentModelIndex.__copy__": (),
-    "sample.PersistentModelIndex.setValue": ('int',),
-    "sample.PersistentModelIndex.value": (),
-# class sample.Photon:
-# class sample.Photon.Base:
-    "sample.Photon.Base.__init__": [('int',), ('sample.Photon.Base',)],
-    "sample.Photon.Base.__copy__": (),
-    "sample.Photon.Base.isType": ('sample.Photon.ClassType',),
-    "sample.Photon.Base.setValue": ('int',),
-    "sample.Photon.Base.type": (),
-    "sample.Photon.Base.value": (),
-# class sample.Photon.ClassType:
-# class sample.Photon.ValueDuplicator:
-    "sample.Photon.ValueDuplicator.__init__": [('int',), ('sample.Photon.ValueDuplicator',)],
-    "sample.Photon.ValueDuplicator.__copy__": (),
-    "sample.Photon.ValueDuplicator.calculate": (),
-    "sample.Photon.ValueDuplicator.classType": (),
-    "sample.Photon.ValueDuplicator.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueDuplicator.multiplicator": (),
-    "sample.Photon.ValueDuplicator.passPointerThrough": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.type": (),
-# class sample.Photon.ValueIdentity:
-    "sample.Photon.ValueIdentity.__init__": [('int',), ('sample.Photon.ValueIdentity',)],
-    "sample.Photon.ValueIdentity.__copy__": (),
-    "sample.Photon.ValueIdentity.calculate": (),
-    "sample.Photon.ValueIdentity.classType": (),
-    "sample.Photon.ValueIdentity.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueIdentity.multiplicator": (),
-    "sample.Photon.ValueIdentity.passPointerThrough": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingPointer": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingReference": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.type": (),
-    "sample.Photon.callCalculateForValueDuplicatorPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.callCalculateForValueDuplicatorReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.countValueDuplicators": ('typing.List[sample.Photon.ValueDuplicator]',),
-    "sample.Photon.countValueIdentities": ('typing.List[sample.Photon.ValueIdentity]',),
-# class sample.Point:
-    "sample.Point.__init__": [('float', 'float'), ('int', 'int'), ('typing.Tuple[float, float]',)],
-    "sample.Point.__add__": ('typing.Tuple[float, float]',),
-    "sample.Point.__copy__": (),
-    "sample.Point.__iadd__": ('typing.Tuple[float, float]',),
-    "sample.Point.__isub__": ('typing.Tuple[float, float]',),
-    "sample.Point.__mul__": [('float',), ('int',)],
-    "sample.Point.__neg__": (),
-    "sample.Point.__reduce__": (),
-    "sample.Point.__repr__": (),
-    "sample.Point.__str__": (),
-    "sample.Point.__sub__": [('typing.Tuple[float, float]',), ('unicode',)],
-    "sample.Point.copy": (),
-    "sample.Point.getConstReferenceToSelf": (),
-    "sample.Point.getSelf": (),
-    "sample.Point.midpoint": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Point.setX": ('float',),
-    "sample.Point.setXAsUint": ('int',),
-    "sample.Point.setY": ('float',),
-    "sample.Point.setYAsUint": ('int',),
-    "sample.Point.show": (),
-    "sample.Point.x": (),
-    "sample.Point.y": (),
-# class sample.PointF:
-    "sample.PointF.__init__": [('float', 'float'), ('sample.PointF',), ('typing.Tuple[float, float]',)],
-    "sample.PointF.__add__": ('sample.PointF',),
-    "sample.PointF.__copy__": (),
-    "sample.PointF.__iadd__": ('sample.PointF',),
-    "sample.PointF.__isub__": ('sample.PointF',),
-    "sample.PointF.__mul__": [('float',), ('int',)],
-    "sample.PointF.__neg__": (),
-    "sample.PointF.__reduce__": (),
-    "sample.PointF.__repr__": (),
-    "sample.PointF.__str__": (),
-    "sample.PointF.__sub__": ('sample.PointF',),
-    "sample.PointF.midpoint": ('sample.PointF', 'sample.PointF'),
-    "sample.PointF.setX": ('float',),
-    "sample.PointF.setY": ('float',),
-    "sample.PointF.show": (),
-    "sample.PointF.x": (),
-    "sample.PointF.y": (),
-# class sample.PointValueList:
-# class sample.PointValueList.CtorEnum:
-    "sample.PointValueList.__init__": [(), ('sample.PointValueList',), ('typing.Sequence[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.PointValueList.__copy__": (),
-    "sample.PointValueList.append": ('typing.Tuple[float, float]',),
-    "sample.PointValueList.constructorUsed": (),
-# class sample.PointerHolder:
-    "sample.PointerHolder.__init__": [('object',), ('sample.PointerHolder',)],
-    "sample.PointerHolder.__copy__": (),
-    "sample.PointerHolder.pointer": (),
-# class sample.Polygon:
-    "sample.Polygon.__init__": [(), ('float', 'float'), ('sample.Polygon',), ('typing.List[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.Polygon.__copy__": (),
-    "sample.Polygon.addPoint": ('typing.Tuple[float, float]',),
-    "sample.Polygon.doublePolygonScale": ('sample.Polygon',),
-    "sample.Polygon.points": (),
-    "sample.Polygon.stealOwnershipFromPython": [('sample.Polygon',), ('typing.Tuple[float, float]',)],
-# class sample.PrimitiveStructPointerHolder:
-    "sample.PrimitiveStructPointerHolder.__init__": [(), ('sample.PrimitiveStructPointerHolder',)],
-    "sample.PrimitiveStructPointerHolder.__copy__": (),
-# class sample.PrivateCtor:
-    "sample.PrivateCtor.instance": (),
-    "sample.PrivateCtor.instanceCalls": (),
-# class sample.PrivateDtor:
-    "sample.PrivateDtor.instance": (),
-    "sample.PrivateDtor.instanceCalls": (),
-    "sample.PrivateDtor.protectedInstanceCalls": (),
-# class sample.ProtectedEnumClass:
-# class sample.ProtectedEnumClass.ProtectedEnum:
-# class sample.ProtectedEnumClass.PublicEnum:
-    "sample.ProtectedEnumClass.__init__": (),
-    "sample.ProtectedEnumClass.callProtectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.callPublicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-    "sample.ProtectedEnumClass.protectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.publicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-# class sample.ProtectedNonPolymorphic:
-    "sample.ProtectedNonPolymorphic.__init__": [('sample.ProtectedNonPolymorphic',), ('str',)],
-    "sample.ProtectedNonPolymorphic.__copy__": (),
-    "sample.ProtectedNonPolymorphic.create": (),
-    "sample.ProtectedNonPolymorphic.dataTypeName": [('int',), ('object',)],
-    "sample.ProtectedNonPolymorphic.modifiedProtectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.protectedName": (),
-    "sample.ProtectedNonPolymorphic.protectedStatic": (),
-    "sample.ProtectedNonPolymorphic.protectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphic:
-    "sample.ProtectedPolymorphic.__init__": [('sample.ProtectedPolymorphic',), ('str',)],
-    "sample.ProtectedPolymorphic.__copy__": (),
-    "sample.ProtectedPolymorphic.callProtectedName": (),
-    "sample.ProtectedPolymorphic.create": (),
-    "sample.ProtectedPolymorphic.protectedName": (),
-    "sample.ProtectedPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphicDaughter:
-    "sample.ProtectedPolymorphicDaughter.__init__": [('sample.ProtectedPolymorphicDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicDaughter.create": (),
-# class sample.ProtectedPolymorphicGrandDaughter:
-    "sample.ProtectedPolymorphicGrandDaughter.__init__": [('sample.ProtectedPolymorphicGrandDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicGrandDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicGrandDaughter.create": (),
-# class sample.ProtectedProperty:
-    "sample.ProtectedProperty.__init__": [(), ('sample.ProtectedProperty',)],
-    "sample.ProtectedProperty.__copy__": (),
-# class sample.ProtectedVirtualDestructor:
-    "sample.ProtectedVirtualDestructor.__init__": (),
-    "sample.ProtectedVirtualDestructor.create": (),
-    "sample.ProtectedVirtualDestructor.dtorCalled": (),
-    "sample.ProtectedVirtualDestructor.resetDtorCounter": (),
-# class sample.Rect:
-    "sample.Rect.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',)],
-    "sample.Rect.__copy__": (),
-    "sample.Rect.bottom": (),
-    "sample.Rect.left": (),
-    "sample.Rect.right": (),
-    "sample.Rect.top": (),
-# class sample.RectF:
-    "sample.RectF.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',), ('sample.RectF',)],
-    "sample.RectF.__copy__": (),
-    "sample.RectF.bottom": (),
-    "sample.RectF.left": (),
-    "sample.RectF.right": (),
-    "sample.RectF.top": (),
-# class sample.Reference:
-    "sample.Reference.__init__": [('int',), ('sample.Reference',)],
-    "sample.Reference.__copy__": (),
-    "sample.Reference.alterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callAlterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callUsesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.callUsesReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.multiplier": (),
-    "sample.Reference.objId": (),
-    "sample.Reference.returnMyFirstArg": ('sample.Reference',),
-    "sample.Reference.returnMySecondArg": ('int', 'sample.Reference'),
-    "sample.Reference.setObjId": ('int',),
-    "sample.Reference.show": (),
-    "sample.Reference.usesConstReference": ('sample.Reference',),
-    "sample.Reference.usesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.usesReference": ('sample.Reference',),
-    "sample.Reference.usesReferenceVirtual": ('sample.Reference', 'int'),
-# class sample.ReferentModelIndex:
-    "sample.ReferentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.ReferentModelIndex',)],
-    "sample.ReferentModelIndex.__copy__": (),
-    "sample.ReferentModelIndex.setValue": ('int',),
-    "sample.ReferentModelIndex.value": (),
-# class sample.RemovedNamespace1_Enum:
-# class sample.RemovedNamespace2_Enum:
-# class sample.SampleNamespace:
-# class sample.SampleNamespace.DerivedFromNamespace:
-    "sample.SampleNamespace.DerivedFromNamespace.__init__": (),
-    "sample.SampleNamespace.DerivedFromNamespace.methodReturningTypeFromParentScope": (),
-    "sample.SampleNamespace.DerivedFromNamespace.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.InValue:
-# class sample.SampleNamespace.Option:
-# class sample.SampleNamespace.OutValue:
-# class sample.SampleNamespace.SomeClass:
-# class sample.SampleNamespace.SomeClass.ProtectedEnum:
-# class sample.SampleNamespace.SomeClass.PublicScopedEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnumClass:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.__init__": (),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass',),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__copy__": (),
-# class sample.SampleNamespace.SomeClass.SomeOtherInnerClass:
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeOtherInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.__init__": [(), ('sample.SampleNamespace.SomeClass',)],
-    "sample.SampleNamespace.SomeClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.protectedMethodReturningPublicScopedEnum": (),
-    "sample.SampleNamespace.ImInsideANamespace": ('int', 'int'),
-    "sample.SampleNamespace.doSomethingWithArray": ('str', 'int', 'str'),
-    "sample.SampleNamespace.enumArgumentWithDefaultValue": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.enumInEnumOut": ('sample.SampleNamespace.InValue',),
-    "sample.SampleNamespace.enumItemAsDefaultValueToIntArgument": ('int',),
-    "sample.SampleNamespace.forceDecisorSideA": [('object',), ('typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.forceDecisorSideB": [('int', 'object'), ('int', 'typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.getNumber": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.passReferenceToObjectType": [('object',), ('object', 'int')],
-    "sample.SampleNamespace.passReferenceToValueType": [('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'float')],
-    "sample.SampleNamespace.powerOfTwo": ('float',),
-# class sample.SbkDate:
-    "sample.SbkDate.__init__": [('int', 'int', 'int'), ('sample.SbkDate',)],
-    "sample.SbkDate.__copy__": (),
-    "sample.SbkDate.day": (),
-    "sample.SbkDate.month": (),
-    "sample.SbkDate.toPython": (),
-    "sample.SbkDate.year": (),
-# class sample.SimpleFile:
-    "sample.SimpleFile.__init__": [('sample.SimpleFile',), ('str',)],
-    "sample.SimpleFile.__copy__": (),
-    "sample.SimpleFile.close": (),
-    "sample.SimpleFile.exists": [(), ('str',)],
-    "sample.SimpleFile.filename": (),
-    "sample.SimpleFile.open": (),
-    "sample.SimpleFile.size": (),
-# class sample.Size:
-    "sample.Size.__init__": [('float', 'float'), ('sample.Size',), ('str',)],
-    "sample.Size.__add__": ('sample.Size',),
-    "sample.Size.__copy__": (),
-    "sample.Size.__iadd__": ('sample.Size',),
-    "sample.Size.__imul__": ('float',),
-    "sample.Size.__isub__": ('sample.Size',),
-    "sample.Size.__mul__": ('float',),
-    "sample.Size.__sub__": ('sample.Size',),
-    "sample.Size.calculateArea": (),
-    "sample.Size.height": (),
-    "sample.Size.setHeight": ('float',),
-    "sample.Size.setWidth": ('float',),
-    "sample.Size.show": (),
-    "sample.Size.width": (),
-# class sample.SizeF:
-    "sample.SizeF.__init__": [('float', 'float'), ('sample.SizeF',)],
-    "sample.SizeF.__copy__": (),
-    "sample.SizeF.height": (),
-    "sample.SizeF.passTypedefOfUnsignedShort": ('int',),
-    "sample.SizeF.width": (),
-# class sample.SonOfMDerived1:
-    "sample.SonOfMDerived1.__init__": (),
-    "sample.SonOfMDerived1.castToMDerived1": (),
-    "sample.SonOfMDerived1.sonOfMDerived1Method": (),
-# class sample.SortedOverload:
-    "sample.SortedOverload.__init__": [(), ('sample.SortedOverload',)],
-    "sample.SortedOverload.__copy__": (),
-    "sample.SortedOverload.implicit_overload": ('sample.ImplicitBase',),
-    "sample.SortedOverload.overload": [('float',), ('int',), ('object',), ('sample.ImplicitBase',), ('sample.ImplicitTarget',), ('typing.List[sample.ImplicitBase]',)],
-    "sample.SortedOverload.overloadDeep": [('int', 'object'), ('int', 'sample.ImplicitBase')],
-    "sample.SortedOverload.pyObjOverload": [('int', 'int'), ('str', 'int')],
-# class sample.Str:
-    "sample.Str.__init__": [('int',), ('sample.Str',), ('str',)],
-    "sample.Str.__add__": ('int',),
-    "sample.Str.__copy__": (),
-    "sample.Str.__str__": (),
-    "sample.Str.append": ('sample.Str',),
-    "sample.Str.arg": ('sample.Str',),
-    "sample.Str.cstring": (),
-    "sample.Str.get_char": ('int',),
-    "sample.Str.prepend": ('sample.Str',),
-    "sample.Str.set_char": ('int', 'int'),
-    "sample.Str.show": (),
-    "sample.Str.size": (),
-    "sample.Str.toInt": ('int',),
-# class sample.StrList:
-# class sample.StrList.CtorEnum:
-    "sample.StrList.__init__": [(), ('sample.Str',), ('sample.StrList',), ('typing.List[sample.Str]',)],
-    "sample.StrList.__copy__": (),
-    "sample.StrList.append": ('sample.Str',),
-    "sample.StrList.constructorUsed": (),
-    "sample.StrList.join": ('sample.Str',),
-# class sample.TemplatePtr:
-    "sample.TemplatePtr.__init__": (),
-    "sample.TemplatePtr.dummy_method": ('typing.List[typing.Tuple]',),
-# class sample.Time:
-# class sample.Time.NumArgs:
-    "sample.Time.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Time',)],
-    "sample.Time.__copy__": (),
-    "sample.Time.hour": (),
-    "sample.Time.isNull": (),
-    "sample.Time.minute": (),
-    "sample.Time.msec": (),
-    "sample.Time.second": (),
-    "sample.Time.setTime": [(), ('int', 'int', 'int', 'int')],
-    "sample.Time.somethingCompletelyDifferent": [(), ('int', 'int', 'sample.ImplicitConv', 'object')],
-    "sample.Time.toString": (),
-# class sample.Union:
-    "sample.Union.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Union.__and__": ('sample.Data',),
-    "sample.Union.__copy__": (),
-    "sample.Union.addFilter": ('sample.Filter',),
-    "sample.Union.filters": (),
-# class sample.UnremovedNamespace:
-# class sample.UnremovedNamespace.RemovedNamespace3_Enum:
-# class sample.ValueAndVirtual:
-    "sample.ValueAndVirtual.__init__": [('int',), ('sample.ValueAndVirtual',)],
-    "sample.ValueAndVirtual.__call__": ('int', 'int'),
-    "sample.ValueAndVirtual.__copy__": (),
-    "sample.ValueAndVirtual.id": (),
-# class sample.VirtualDaughter:
-    "sample.VirtualDaughter.__init__": [(), ('sample.Str',), ('sample.VirtualDaughter',)],
-    "sample.VirtualDaughter.__copy__": (),
-# class sample.VirtualDaughter2:
-    "sample.VirtualDaughter2.__init__": (),
-    "sample.VirtualDaughter2.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualDaughter2.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualDtor:
-    "sample.VirtualDtor.__init__": [(), ('sample.VirtualDtor',)],
-    "sample.VirtualDtor.__copy__": (),
-    "sample.VirtualDtor.create": (),
-    "sample.VirtualDtor.dtorCalled": (),
-    "sample.VirtualDtor.resetDtorCounter": (),
-# class sample.VirtualFinalDaughter:
-    "sample.VirtualFinalDaughter.__init__": (),
-    "sample.VirtualFinalDaughter.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualFinalDaughter.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualMethods:
-    "sample.VirtualMethods.__init__": [('sample.Str',), ('sample.VirtualMethods',)],
-    "sample.VirtualMethods.__copy__": (),
-    "sample.VirtualMethods.callCallMe": (),
-    "sample.VirtualMethods.callCreateStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.callGetMargins": (),
-    "sample.VirtualMethods.callMe": (),
-    "sample.VirtualMethods.callName": (),
-    "sample.VirtualMethods.callRecursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.callStrListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.callSum0": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callVirtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-    "sample.VirtualMethods.createStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.getMargins": (),
-    "sample.VirtualMethods.name": (),
-    "sample.VirtualMethods.recursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.setMargins": ('int', 'int', 'int', 'int'),
-    "sample.VirtualMethods.strListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.sum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualMethods.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VoidHolder:
-    "sample.VoidHolder.__init__": [('int',), ('sample.VoidHolder',)],
-    "sample.VoidHolder.__copy__": (),
-    "sample.VoidHolder.gimmeMeSomeVoidPointer": (),
-    "sample.VoidHolder.takeVoidPointer": ('int',),
-    "sample.VoidHolder.voidPointer": (),
-# class sample.sample:
-# class sample.sample.sample:
-    "sample.sample.sample.__init__": [('int',), ('sample.sample.sample',)],
-    "sample.sample.sample.__copy__": (),
-    "sample.sample.sample.value": (),
-    "sample.sample.acceptDouble": ('float',),
-    "sample.sample.acceptInt": ('int',),
-    "sample.sample.acceptIntReference": ('int',),
-    "sample.sample.acceptLong": ('int',),
-    "sample.sample.acceptOddBoolReference": ('bool',),
-    "sample.sample.acceptUInt": ('int',),
-    "sample.sample.acceptULong": ('int',),
-    "sample.sample.applyHomogeneousTransform": ('typing.Tuple[float, float]', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "sample.sample.cacheSize": (),
-    "sample.sample.changePStr": ('str',),
-    "sample.sample.convertIntegersToCppAndThenToPython": ('int', 'int'),
-    "sample.sample.convertListOfIntegersToCppAndThenToPython": ('typing.List[int]',),
-    "sample.sample.convertObjectTypeToCppAndThenToPython": ('object', 'object'),
-    "sample.sample.convertValueTypeToCppAndThenToPython": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.sample.countCharacters": ('str',),
-    "sample.sample.countVarargs": ('int', 'None'),
-    "sample.sample.cppTypeIsObjectType": ('str',),
-    "sample.sample.cppTypeIsValueType": ('str',),
-    "sample.sample.createListOfPStr": ('str', 'str'),
-    "sample.sample.createPStrList": ('str', 'str'),
-    "sample.sample.createProtectedProperty": (),
-    "sample.sample.doubleLongLong": ('int',),
-    "sample.sample.doubleShort": ('int',),
-    "sample.sample.doubleUnsignedInt": ('int',),
-    "sample.sample.doubleUnsignedLongLong": ('int',),
-    "sample.sample.duplicatePStr": (),
-    "sample.sample.getConversionTypeString": ('str',),
-    "sample.sample.getPythonType": ('str',),
-    "sample.sample.gimmeComplexList": (),
-    "sample.sample.gimmeDouble": (),
-    "sample.sample.gimmeInt": (),
-    "sample.sample.makeCString": (),
-    "sample.sample.multiplyPair": ('typing.Tuple[float, float]',),
-    "sample.sample.multiplyString": ('str', 'int'),
-    "sample.sample.overloadedFunc": [('float',), ('int',)],
-    "sample.sample.returnCString": (),
-    "sample.sample.returnNullObjectTypePointer": (),
-    "sample.sample.returnNullPrimitivePointer": (),
-    "sample.sample.returnNullValueTypePointer": (),
-    "sample.sample.sum2d": ('typing.List[typing.List]',),
-    "sample.sample.sumComplexPair": ('typing.Tuple[complex, complex]',),
-    "sample.sample.sumDoubleArray": ('typing.Tuple[float, float, float, float]',),
-    "sample.sample.sumDoubleMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumIntArray": ('typing.Tuple[int, int, int, int]',),
-    "sample.sample.sumIntMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumproduct": ('typing.List[typing.Tuple]',),
-    "sample.sample.transmuteComplexIntoPoint": ('complex',),
-    "sample.sample.transmutePointIntoComplex": ('typing.Tuple[float, float]',),
-    }) if "sample" in sys.modules else None
-# Module other
-sig_dict.update({
-# class other.ExtendsNoImplicitConversion:
-    "other.ExtendsNoImplicitConversion.__init__": [('Missing("other.ExtendsNoImplicitConversion")',), ('int',)],
-    "other.ExtendsNoImplicitConversion.__copy__": (),
-    "other.ExtendsNoImplicitConversion.objId": (),
-# class other.Number:
-    "other.Number.__init__": [('int',), ('numbers.Number',)],
-    "other.Number.__copy__": (),
-    "other.Number.__mul__": ('typing.Tuple[float, float]',),
-    "other.Number.fromComplex": ('complex',),
-    "other.Number.toComplex": (),
-    "other.Number.toStr": (),
-    "other.Number.value": (),
-# class other.OtherDerived:
-    "other.OtherDerived.__init__": ('int',),
-    "other.OtherDerived.className": (),
-    "other.OtherDerived.createObject": (),
-    "other.OtherDerived.getClassName": (),
-    "other.OtherDerived.pureVirtual": (),
-    "other.OtherDerived.pureVirtualReturningVoidPtr": (),
-    "other.OtherDerived.returnAnEnum": (),
-    "other.OtherDerived.unpureVirtual": (),
-    "other.OtherDerived.useEnumTypeFromOtherModule": ('sample.OverloadedFuncEnum',),
-    "other.OtherDerived.useObjectTypeFromOtherModule": ('object',),
-    "other.OtherDerived.useValueTypeFromOtherModule": [('complex',), ('sample.Event',)],
-# class other.OtherMultipleDerived:
-    "other.OtherMultipleDerived.__init__": (),
-    "other.OtherMultipleDerived.createObject": ('str',),
-    "other.OtherMultipleDerived.returnUselessClass": (),
-# class other.OtherObjectType:
-    "other.OtherObjectType.__init__": (),
-    "other.OtherObjectType.__lshift__": ('sample.Collector',),
-    }) if "other" in sys.modules else None
-# Module smart
-sig_dict.update({
-# class smart.Integer:
-    "smart.Integer.__init__": [(), ('smart.Integer',)],
-    "smart.Integer.__copy__": (),
-    "smart.Integer.printInteger": (),
-# class smart.Integer2:
-    "smart.Integer2.__init__": [(), ('int',)],
-    "smart.Integer2.__copy__": (),
-# class smart.Obj:
-    "smart.Obj.__init__": (),
-    "smart.Obj.giveSharedPtrToInteger": (),
-    "smart.Obj.giveSharedPtrToInteger2": (),
-    "smart.Obj.giveSharedPtrToObj": (),
-    "smart.Obj.giveSharedPtrToObjList": ('int',),
-    "smart.Obj.printObj": (),
-    "smart.Obj.takeInteger": ('smart.Integer',),
-    "smart.Obj.takeSharedPtrToInteger": ('smart.SharedPtr',),
-    "smart.Obj.takeSharedPtrToObj": ('smart.SharedPtr',),
-# class smart.Registry:
-    "smart.Registry.__init__": (),
-    "smart.Registry.add": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.countIntegers": (),
-    "smart.Registry.countObjects": (),
-    "smart.Registry.getInstance": (),
-    "smart.Registry.remove": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.setShouldPrint": ('bool',),
-    "smart.Registry.shouldPrint": (),
-# class smart.SharedPtr:
-# class smart.SharedPtr.__next_in_mro__:
-# class smart.SharedPtr<Integer >:
-    "smart.SharedPtr<Integer >.__copy__": (),
-    "smart.SharedPtr<Integer >.data": (),
-    "smart.SharedPtr<Integer >.useCount": (),
-# class smart.SharedPtr<Obj >:
-    "smart.SharedPtr<Obj >.__copy__": (),
-    "smart.SharedPtr<Obj >.data": (),
-    "smart.SharedPtr<Obj >.useCount": (),
-# class smart.SharedPtr<Smart::Integer2 >:
-    "smart.SharedPtr<Smart::Integer2 >.__copy__": (),
-    "smart.SharedPtr<Smart::Integer2 >.data": (),
-    "smart.SharedPtr<Smart::Integer2 >.useCount": (),
-    }) if "smart" in sys.modules else None
-# eof
diff --git a/sources/pyside6/tests/registry/exists_red_hat_enterprise_linux_workstation7_6_5_14_2_ci.py b/sources/pyside6/tests/registry/exists_red_hat_enterprise_linux_workstation7_6_5_14_2_ci.py
deleted file mode 100644
index 9918db03c..000000000
--- a/sources/pyside6/tests/registry/exists_red_hat_enterprise_linux_workstation7_6_5_14_2_ci.py
+++ /dev/null
@@ -1,37719 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-"""
-This file contains the simplified signatures for all functions in PySide
-for module 'exists_red_hat_enterprise_linux_workstation7_6_5_14_2_ci' using
-Python 2.7.5 (default, Sep 26 2019, 13:23:47)  [GCC 4.8.5 20150623 (Red Hat 4.8.5-39)]
-Qt 5.14.2 (x86_64-little_endian-lp64 shared (dynamic) release build; by GCC 5.3.1 20160406 (Red Hat 5.3.1-6))
-There are no default values, no variable names and no self
-parameter. Only types are present after simplification. The
-functions 'next' resp. '__next__' are removed to make the output
-identical for Python 2 and 3. '__div__' is also removed,
-since it exists in Python 2, only.
-"""
-import sys
-sig_dict = {}
-# Module PySide2.QtCore
-sig_dict.update({
-# class PySide2.QtCore.ClassInfo:
-    "PySide2.QtCore.ClassInfo.__init__": ('typing.Dict[str, str]',),
-# class PySide2.QtCore.MetaFunction:
-    "PySide2.QtCore.MetaFunction.__call__": ('typing.Any',),
-# class PySide2.QtCore.MetaSignal:
-    "PySide2.QtCore.MetaSignal.__instancecheck__": ('object',),
-# class PySide2.QtCore.Property:
-    "PySide2.QtCore.Property.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'str', 'typing.Callable', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool'),
-    "PySide2.QtCore.Property.getter": ('typing.Callable',),
-    "PySide2.QtCore.Property.read": ('typing.Callable',),
-    "PySide2.QtCore.Property.setter": ('typing.Callable',),
-    "PySide2.QtCore.Property.write": ('typing.Callable',),
-# class PySide2.QtCore.QAbstractAnimation:
-# class PySide2.QtCore.QAbstractAnimation.DeletionPolicy:
-# class PySide2.QtCore.QAbstractAnimation.Direction:
-# class PySide2.QtCore.QAbstractAnimation.State:
-    "PySide2.QtCore.QAbstractAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractAnimation.currentLoop": (),
-    "PySide2.QtCore.QAbstractAnimation.currentLoopTime": (),
-    "PySide2.QtCore.QAbstractAnimation.currentTime": (),
-    "PySide2.QtCore.QAbstractAnimation.direction": (),
-    "PySide2.QtCore.QAbstractAnimation.duration": (),
-    "PySide2.QtCore.QAbstractAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractAnimation.group": (),
-    "PySide2.QtCore.QAbstractAnimation.loopCount": (),
-    "PySide2.QtCore.QAbstractAnimation.pause": (),
-    "PySide2.QtCore.QAbstractAnimation.resume": (),
-    "PySide2.QtCore.QAbstractAnimation.setCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.setLoopCount": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setPaused": ('bool',),
-    "PySide2.QtCore.QAbstractAnimation.start": ('PySide2.QtCore.QAbstractAnimation.DeletionPolicy',),
-    "PySide2.QtCore.QAbstractAnimation.state": (),
-    "PySide2.QtCore.QAbstractAnimation.stop": (),
-    "PySide2.QtCore.QAbstractAnimation.totalDuration": (),
-    "PySide2.QtCore.QAbstractAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QAbstractEventDispatcher:
-# class PySide2.QtCore.QAbstractEventDispatcher.TimerInfo:
-    "PySide2.QtCore.QAbstractEventDispatcher.TimerInfo.__init__": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QAbstractEventDispatcher.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.closingDown": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.filterNativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QAbstractEventDispatcher.flush": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.hasPendingEvents": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.instance": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QAbstractEventDispatcher.interrupt": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.processEvents": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerTimer": [('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject'), ('int', 'int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QAbstractEventDispatcher.registeredTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.remainingTime": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.startingUp": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimer": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.wakeUp": (),
-# class PySide2.QtCore.QAbstractItemModel:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOption:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOptions:
-# class PySide2.QtCore.QAbstractItemModel.LayoutChangeHint:
-    "PySide2.QtCore.QAbstractItemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndexList": ('typing.List[int]', 'typing.List[int]'),
-    "PySide2.QtCore.QAbstractItemModel.checkIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QAbstractItemModel.CheckIndexOptions'),
-    "PySide2.QtCore.QAbstractItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object')],
-    "PySide2.QtCore.QAbstractItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.decodeData": ('int', 'int', 'PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.encodeData": ('typing.List[int]', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.endInsertColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endInsertRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasIndex": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QAbstractItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractItemModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractItemModel.moveColumn": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRow": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractItemModel.persistentIndexList": (),
-    "PySide2.QtCore.QAbstractItemModel.removeColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractItemModel.revert": (),
-    "PySide2.QtCore.QAbstractItemModel.roleNames": (),
-    "PySide2.QtCore.QAbstractItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractItemModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.submit": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractListModel:
-    "PySide2.QtCore.QAbstractListModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractListModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractNativeEventFilter:
-    "PySide2.QtCore.QAbstractNativeEventFilter.__init__": (),
-    "PySide2.QtCore.QAbstractNativeEventFilter.nativeEventFilter": ('PySide2.QtCore.QByteArray', 'int'),
-# class PySide2.QtCore.QAbstractProxyModel:
-    "PySide2.QtCore.QAbstractProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractProxyModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractProxyModel.revert": (),
-    "PySide2.QtCore.QAbstractProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QAbstractProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractProxyModel.sourceModel": (),
-    "PySide2.QtCore.QAbstractProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.submit": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractState:
-    "PySide2.QtCore.QAbstractState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractState.active": (),
-    "PySide2.QtCore.QAbstractState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.machine": (),
-    "PySide2.QtCore.QAbstractState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.parentState": (),
-# class PySide2.QtCore.QAbstractTableModel:
-    "PySide2.QtCore.QAbstractTableModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractTableModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractTableModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractTransition:
-# class PySide2.QtCore.QAbstractTransition.TransitionType:
-    "PySide2.QtCore.QAbstractTransition.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractTransition.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.animations": (),
-    "PySide2.QtCore.QAbstractTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.machine": (),
-    "PySide2.QtCore.QAbstractTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.setTargetState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QAbstractTransition.setTargetStates": ('typing.Sequence[PySide2.QtCore.QAbstractState]',),
-    "PySide2.QtCore.QAbstractTransition.setTransitionType": ('PySide2.QtCore.QAbstractTransition.TransitionType',),
-    "PySide2.QtCore.QAbstractTransition.sourceState": (),
-    "PySide2.QtCore.QAbstractTransition.targetState": (),
-    "PySide2.QtCore.QAbstractTransition.targetStates": (),
-    "PySide2.QtCore.QAbstractTransition.transitionType": (),
-# class PySide2.QtCore.QAnimationGroup:
-    "PySide2.QtCore.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAnimationGroup.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.animationAt": ('int',),
-    "PySide2.QtCore.QAnimationGroup.animationCount": (),
-    "PySide2.QtCore.QAnimationGroup.clear": (),
-    "PySide2.QtCore.QAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAnimationGroup.indexOfAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.insertAnimation": ('int', 'PySide2.QtCore.QAbstractAnimation'),
-    "PySide2.QtCore.QAnimationGroup.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.takeAnimation": ('int',),
-# class PySide2.QtCore.QBasicMutex:
-    "PySide2.QtCore.QBasicMutex.__init__": (),
-    "PySide2.QtCore.QBasicMutex.isRecursive": (),
-    "PySide2.QtCore.QBasicMutex.lock": (),
-    "PySide2.QtCore.QBasicMutex.tryLock": (),
-    "PySide2.QtCore.QBasicMutex.try_lock": (),
-    "PySide2.QtCore.QBasicMutex.unlock": (),
-# class PySide2.QtCore.QBasicTimer:
-    "PySide2.QtCore.QBasicTimer.__init__": [(), ('PySide2.QtCore.QBasicTimer',)],
-    "PySide2.QtCore.QBasicTimer.__copy__": (),
-    "PySide2.QtCore.QBasicTimer.isActive": (),
-    "PySide2.QtCore.QBasicTimer.start": [('int', 'PySide2.QtCore.QObject'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QBasicTimer.stop": (),
-    "PySide2.QtCore.QBasicTimer.swap": ('PySide2.QtCore.QBasicTimer',),
-    "PySide2.QtCore.QBasicTimer.timerId": (),
-# class PySide2.QtCore.QBitArray:
-    "PySide2.QtCore.QBitArray.__init__": [(), ('PySide2.QtCore.QBitArray',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.__and__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__copy__": (),
-    "PySide2.QtCore.QBitArray.__iand__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__invert__": (),
-    "PySide2.QtCore.QBitArray.__ior__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__ixor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__or__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__xor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.at": ('int',),
-    "PySide2.QtCore.QBitArray.bits": (),
-    "PySide2.QtCore.QBitArray.clear": (),
-    "PySide2.QtCore.QBitArray.clearBit": ('int',),
-    "PySide2.QtCore.QBitArray.count": [(), ('bool',)],
-    "PySide2.QtCore.QBitArray.fill": [('bool', 'int'), ('bool', 'int', 'int')],
-    "PySide2.QtCore.QBitArray.fromBits": ('str', 'int'),
-    "PySide2.QtCore.QBitArray.isEmpty": (),
-    "PySide2.QtCore.QBitArray.isNull": (),
-    "PySide2.QtCore.QBitArray.resize": ('int',),
-    "PySide2.QtCore.QBitArray.setBit": [('int',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.size": (),
-    "PySide2.QtCore.QBitArray.swap": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.testBit": ('int',),
-    "PySide2.QtCore.QBitArray.toggleBit": ('int',),
-    "PySide2.QtCore.QBitArray.truncate": ('int',),
-# class PySide2.QtCore.QBuffer:
-    "PySide2.QtCore.QBuffer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QBuffer.atEnd": (),
-    "PySide2.QtCore.QBuffer.buffer": (),
-    "PySide2.QtCore.QBuffer.canReadLine": (),
-    "PySide2.QtCore.QBuffer.close": (),
-    "PySide2.QtCore.QBuffer.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.data": (),
-    "PySide2.QtCore.QBuffer.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QBuffer.pos": (),
-    "PySide2.QtCore.QBuffer.readData": ('str', 'int'),
-    "PySide2.QtCore.QBuffer.seek": ('int',),
-    "PySide2.QtCore.QBuffer.setBuffer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.size": (),
-    "PySide2.QtCore.QBuffer.writeData": ('str', 'int'),
-# class PySide2.QtCore.QByteArray:
-# class PySide2.QtCore.QByteArray.Base64Option:
-# class PySide2.QtCore.QByteArray.Base64Options:
-    "PySide2.QtCore.QByteArray.__init__": [(), ('PySide2.QtCore.QByteArray',), ('bytearray',), ('int', 'int'), ('str',)],
-    "PySide2.QtCore.QByteArray.__add__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',), ('str',)],
-    "PySide2.QtCore.QByteArray.__copy__": (),
-    "PySide2.QtCore.QByteArray.__iadd__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',)],
-    "PySide2.QtCore.QByteArray.__reduce__": (),
-    "PySide2.QtCore.QByteArray.__repr__": (),
-    "PySide2.QtCore.QByteArray.__str__": (),
-    "PySide2.QtCore.QByteArray.append": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.at": ('int',),
-    "PySide2.QtCore.QByteArray.back": (),
-    "PySide2.QtCore.QByteArray.capacity": (),
-    "PySide2.QtCore.QByteArray.cbegin": (),
-    "PySide2.QtCore.QByteArray.cend": (),
-    "PySide2.QtCore.QByteArray.chop": ('int',),
-    "PySide2.QtCore.QByteArray.chopped": ('int',),
-    "PySide2.QtCore.QByteArray.clear": (),
-    "PySide2.QtCore.QByteArray.compare": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.Qt.CaseSensitivity'), ('str', 'PySide2.QtCore.Qt.CaseSensitivity')],
-    "PySide2.QtCore.QByteArray.contains": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.count": [(), ('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.data": (),
-    "PySide2.QtCore.QByteArray.endsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.fill": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.fromBase64": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray.Base64Options')],
-    "PySide2.QtCore.QByteArray.fromHex": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.fromPercentEncoding": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.fromRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.front": (),
-    "PySide2.QtCore.QByteArray.indexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.insert": [('int', 'PySide2.QtCore.QByteArray'), ('int', 'int', 'int')],
-    "PySide2.QtCore.QByteArray.isEmpty": (),
-    "PySide2.QtCore.QByteArray.isLower": (),
-    "PySide2.QtCore.QByteArray.isNull": (),
-    "PySide2.QtCore.QByteArray.isSharedWith": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.isUpper": (),
-    "PySide2.QtCore.QByteArray.lastIndexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.left": ('int',),
-    "PySide2.QtCore.QByteArray.leftJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.length": (),
-    "PySide2.QtCore.QByteArray.mid": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.number": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.prepend": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.remove": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.repeated": ('int',),
-    "PySide2.QtCore.QByteArray.replace": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('int', 'PySide2.QtCore.QByteArray'), ('int', 'int'), ('int', 'int', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtCore.QByteArray.reserve": ('int',),
-    "PySide2.QtCore.QByteArray.resize": ('int',),
-    "PySide2.QtCore.QByteArray.right": ('int',),
-    "PySide2.QtCore.QByteArray.rightJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.setNum": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.setRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.shrink_to_fit": (),
-    "PySide2.QtCore.QByteArray.simplified": (),
-    "PySide2.QtCore.QByteArray.size": (),
-    "PySide2.QtCore.QByteArray.split": ('int',),
-    "PySide2.QtCore.QByteArray.squeeze": (),
-    "PySide2.QtCore.QByteArray.startsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.swap": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.toBase64": [(), ('PySide2.QtCore.QByteArray.Base64Options',)],
-    "PySide2.QtCore.QByteArray.toDouble": (),
-    "PySide2.QtCore.QByteArray.toFloat": (),
-    "PySide2.QtCore.QByteArray.toHex": [(), ('int',)],
-    "PySide2.QtCore.QByteArray.toInt": ('int',),
-    "PySide2.QtCore.QByteArray.toLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLower": (),
-    "PySide2.QtCore.QByteArray.toPercentEncoding": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.toShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUInt": ('int',),
-    "PySide2.QtCore.QByteArray.toULong": ('int',),
-    "PySide2.QtCore.QByteArray.toULongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toUShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUpper": (),
-    "PySide2.QtCore.QByteArray.trimmed": (),
-    "PySide2.QtCore.QByteArray.truncate": ('int',),
-# class PySide2.QtCore.QByteArrayMatcher:
-    "PySide2.QtCore.QByteArrayMatcher.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArrayMatcher',), ('str', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.__copy__": (),
-    "PySide2.QtCore.QByteArrayMatcher.indexIn": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.pattern": (),
-    "PySide2.QtCore.QByteArrayMatcher.setPattern": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QCalendar:
-# class PySide2.QtCore.QCalendar.System:
-# class PySide2.QtCore.QCalendar.YearMonthDay:
-    "PySide2.QtCore.QCalendar.YearMonthDay.__init__": [(), ('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.YearMonthDay.__copy__": (),
-    "PySide2.QtCore.QCalendar.YearMonthDay.isValid": (),
-    "PySide2.QtCore.QCalendar.__init__": [(), ('PySide2.QtCore.QCalendar.System',)],
-    "PySide2.QtCore.QCalendar.__copy__": (),
-    "PySide2.QtCore.QCalendar.availableCalendars": (),
-    "PySide2.QtCore.QCalendar.dateFromParts": [('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.dayOfWeek": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.daysInMonth": ('int', 'int'),
-    "PySide2.QtCore.QCalendar.daysInYear": ('int',),
-    "PySide2.QtCore.QCalendar.hasYearZero": (),
-    "PySide2.QtCore.QCalendar.isDateValid": ('int', 'int', 'int'),
-    "PySide2.QtCore.QCalendar.isGregorian": (),
-    "PySide2.QtCore.QCalendar.isLeapYear": ('int',),
-    "PySide2.QtCore.QCalendar.isLunar": (),
-    "PySide2.QtCore.QCalendar.isLuniSolar": (),
-    "PySide2.QtCore.QCalendar.isProleptic": (),
-    "PySide2.QtCore.QCalendar.isSolar": (),
-    "PySide2.QtCore.QCalendar.isValid": (),
-    "PySide2.QtCore.QCalendar.maximumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.maximumMonthsInYear": (),
-    "PySide2.QtCore.QCalendar.minimumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.monthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.monthsInYear": ('int',),
-    "PySide2.QtCore.QCalendar.name": (),
-    "PySide2.QtCore.QCalendar.partsFromDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.standaloneMonthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.standaloneWeekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.weekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-# class PySide2.QtCore.QCborArray:
-    "PySide2.QtCore.QCborArray.__init__": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborArray.__add__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__copy__": (),
-    "PySide2.QtCore.QCborArray.__iadd__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__lshift__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.append": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.at": ('int',),
-    "PySide2.QtCore.QCborArray.clear": (),
-    "PySide2.QtCore.QCborArray.compare": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.contains": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.empty": (),
-    "PySide2.QtCore.QCborArray.first": (),
-    "PySide2.QtCore.QCborArray.fromJsonArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QCborArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCborArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QCborArray.insert": ('int', 'PySide2.QtCore.QCborValue'),
-    "PySide2.QtCore.QCborArray.isEmpty": (),
-    "PySide2.QtCore.QCborArray.last": (),
-    "PySide2.QtCore.QCborArray.pop_back": (),
-    "PySide2.QtCore.QCborArray.pop_front": (),
-    "PySide2.QtCore.QCborArray.prepend": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_back": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_front": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.removeAt": ('int',),
-    "PySide2.QtCore.QCborArray.removeFirst": (),
-    "PySide2.QtCore.QCborArray.removeLast": (),
-    "PySide2.QtCore.QCborArray.size": (),
-    "PySide2.QtCore.QCborArray.swap": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.takeAt": ('int',),
-    "PySide2.QtCore.QCborArray.takeFirst": (),
-    "PySide2.QtCore.QCborArray.takeLast": (),
-    "PySide2.QtCore.QCborArray.toCborValue": (),
-    "PySide2.QtCore.QCborArray.toJsonArray": (),
-    "PySide2.QtCore.QCborArray.toVariantList": (),
-# class PySide2.QtCore.QCborError:
-# class PySide2.QtCore.QCborError.Code:
-    "PySide2.QtCore.QCborError.__init__": [(), ('PySide2.QtCore.QCborError',)],
-    "PySide2.QtCore.QCborError.__copy__": (),
-    "PySide2.QtCore.QCborError.toString": (),
-# class PySide2.QtCore.QCborKnownTags:
-# class PySide2.QtCore.QCborMap:
-    "PySide2.QtCore.QCborMap.__init__": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborMap.__copy__": (),
-    "PySide2.QtCore.QCborMap.clear": (),
-    "PySide2.QtCore.QCborMap.compare": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.contains": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.empty": (),
-    "PySide2.QtCore.QCborMap.fromJsonObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QCborMap.fromVariantHash": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.fromVariantMap": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.isEmpty": (),
-    "PySide2.QtCore.QCborMap.keys": (),
-    "PySide2.QtCore.QCborMap.remove": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.size": (),
-    "PySide2.QtCore.QCborMap.swap": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.take": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.toCborValue": (),
-    "PySide2.QtCore.QCborMap.toJsonObject": (),
-    "PySide2.QtCore.QCborMap.toVariantHash": (),
-    "PySide2.QtCore.QCborMap.toVariantMap": (),
-    "PySide2.QtCore.QCborMap.value": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-# class PySide2.QtCore.QCborParserError:
-    "PySide2.QtCore.QCborParserError.__init__": [(), ('PySide2.QtCore.QCborParserError',)],
-    "PySide2.QtCore.QCborParserError.__copy__": (),
-    "PySide2.QtCore.QCborParserError.errorString": (),
-# class PySide2.QtCore.QCborSimpleType:
-# class PySide2.QtCore.QCborStreamReader:
-# class PySide2.QtCore.QCborStreamReader.StringResultCode:
-# class PySide2.QtCore.QCborStreamReader.Type:
-    "PySide2.QtCore.QCborStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.clear": (),
-    "PySide2.QtCore.QCborStreamReader.containerDepth": (),
-    "PySide2.QtCore.QCborStreamReader.currentOffset": (),
-    "PySide2.QtCore.QCborStreamReader.currentStringChunkSize": (),
-    "PySide2.QtCore.QCborStreamReader.device": (),
-    "PySide2.QtCore.QCborStreamReader.enterContainer": (),
-    "PySide2.QtCore.QCborStreamReader.hasNext": (),
-    "PySide2.QtCore.QCborStreamReader.isArray": (),
-    "PySide2.QtCore.QCborStreamReader.isBool": (),
-    "PySide2.QtCore.QCborStreamReader.isByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.isContainer": (),
-    "PySide2.QtCore.QCborStreamReader.isDouble": (),
-    "PySide2.QtCore.QCborStreamReader.isFalse": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat16": (),
-    "PySide2.QtCore.QCborStreamReader.isInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isInvalid": (),
-    "PySide2.QtCore.QCborStreamReader.isLengthKnown": (),
-    "PySide2.QtCore.QCborStreamReader.isMap": (),
-    "PySide2.QtCore.QCborStreamReader.isNegativeInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isNull": (),
-    "PySide2.QtCore.QCborStreamReader.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborStreamReader.isString": (),
-    "PySide2.QtCore.QCborStreamReader.isTag": (),
-    "PySide2.QtCore.QCborStreamReader.isTrue": (),
-    "PySide2.QtCore.QCborStreamReader.isUndefined": (),
-    "PySide2.QtCore.QCborStreamReader.isUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isValid": (),
-    "PySide2.QtCore.QCborStreamReader.lastError": (),
-    "PySide2.QtCore.QCborStreamReader.leaveContainer": (),
-    "PySide2.QtCore.QCborStreamReader.length": (),
-    "PySide2.QtCore.QCborStreamReader.parentContainerType": (),
-    "PySide2.QtCore.QCborStreamReader.readByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.readString": (),
-    "PySide2.QtCore.QCborStreamReader.reparse": (),
-    "PySide2.QtCore.QCborStreamReader.reset": (),
-    "PySide2.QtCore.QCborStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamReader.toBool": (),
-    "PySide2.QtCore.QCborStreamReader.toDouble": (),
-    "PySide2.QtCore.QCborStreamReader.toFloat": (),
-    "PySide2.QtCore.QCborStreamReader.toInteger": (),
-    "PySide2.QtCore.QCborStreamReader.toSimpleType": (),
-    "PySide2.QtCore.QCborStreamReader.toUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.type": (),
-# class PySide2.QtCore.QCborStreamWriter:
-    "PySide2.QtCore.QCborStreamWriter.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QCborStreamWriter.append": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborKnownTags',), ('PySide2.QtCore.QCborSimpleType',), ('bool',), ('float',), ('int',), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamWriter.appendByteString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendNull": (),
-    "PySide2.QtCore.QCborStreamWriter.appendTextString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendUndefined": (),
-    "PySide2.QtCore.QCborStreamWriter.device": (),
-    "PySide2.QtCore.QCborStreamWriter.endArray": (),
-    "PySide2.QtCore.QCborStreamWriter.endMap": (),
-    "PySide2.QtCore.QCborStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamWriter.startArray": [(), ('int',)],
-    "PySide2.QtCore.QCborStreamWriter.startMap": [(), ('int',)],
-# class PySide2.QtCore.QCborStringResultByteArray:
-    "PySide2.QtCore.QCborStringResultByteArray.__init__": [(), ('PySide2.QtCore.QCborStringResultByteArray',)],
-    "PySide2.QtCore.QCborStringResultByteArray.__copy__": (),
-# class PySide2.QtCore.QCborStringResultString:
-    "PySide2.QtCore.QCborStringResultString.__init__": [(), ('PySide2.QtCore.QCborStringResultString',)],
-    "PySide2.QtCore.QCborStringResultString.__copy__": (),
-# class PySide2.QtCore.QCborValue:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOption:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOptions:
-# class PySide2.QtCore.QCborValue.EncodingOption:
-# class PySide2.QtCore.QCborValue.EncodingOptions:
-# class PySide2.QtCore.QCborValue.Type:
-    "PySide2.QtCore.QCborValue.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborKnownTags', 'PySide2.QtCore.QCborValue'), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborSimpleType',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QCborValue.Type',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborValue.__copy__": (),
-    "PySide2.QtCore.QCborValue.compare": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.fromCbor": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCborParserError'), ('PySide2.QtCore.QCborStreamReader',), ('bytearray', 'int', 'PySide2.QtCore.QCborParserError'), ('str', 'int', 'PySide2.QtCore.QCborParserError')],
-    "PySide2.QtCore.QCborValue.fromJsonValue": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QCborValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QCborValue.isArray": (),
-    "PySide2.QtCore.QCborValue.isBool": (),
-    "PySide2.QtCore.QCborValue.isByteArray": (),
-    "PySide2.QtCore.QCborValue.isContainer": (),
-    "PySide2.QtCore.QCborValue.isDateTime": (),
-    "PySide2.QtCore.QCborValue.isDouble": (),
-    "PySide2.QtCore.QCborValue.isFalse": (),
-    "PySide2.QtCore.QCborValue.isInteger": (),
-    "PySide2.QtCore.QCborValue.isInvalid": (),
-    "PySide2.QtCore.QCborValue.isMap": (),
-    "PySide2.QtCore.QCborValue.isNull": (),
-    "PySide2.QtCore.QCborValue.isRegularExpression": (),
-    "PySide2.QtCore.QCborValue.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborValue.isString": (),
-    "PySide2.QtCore.QCborValue.isTag": (),
-    "PySide2.QtCore.QCborValue.isTrue": (),
-    "PySide2.QtCore.QCborValue.isUndefined": (),
-    "PySide2.QtCore.QCborValue.isUrl": (),
-    "PySide2.QtCore.QCborValue.isUuid": (),
-    "PySide2.QtCore.QCborValue.swap": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.taggedValue": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.toArray": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborValue.toBool": ('bool',),
-    "PySide2.QtCore.QCborValue.toByteArray": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QCborValue.toCbor": [('PySide2.QtCore.QCborStreamWriter', 'PySide2.QtCore.QCborValue.EncodingOptions'), ('PySide2.QtCore.QCborValue.EncodingOptions',)],
-    "PySide2.QtCore.QCborValue.toDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QCborValue.toDiagnosticNotation": ('PySide2.QtCore.QCborValue.DiagnosticNotationOptions',),
-    "PySide2.QtCore.QCborValue.toDouble": ('float',),
-    "PySide2.QtCore.QCborValue.toInteger": ('int',),
-    "PySide2.QtCore.QCborValue.toJsonValue": (),
-    "PySide2.QtCore.QCborValue.toMap": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborValue.toRegularExpression": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QCborValue.toSimpleType": ('PySide2.QtCore.QCborSimpleType',),
-    "PySide2.QtCore.QCborValue.toString": ('str',),
-    "PySide2.QtCore.QCborValue.toUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QCborValue.toUuid": ('PySide2.QtCore.QUuid',),
-    "PySide2.QtCore.QCborValue.toVariant": (),
-    "PySide2.QtCore.QCborValue.type": (),
-# class PySide2.QtCore.QChildEvent:
-    "PySide2.QtCore.QChildEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QChildEvent.added": (),
-    "PySide2.QtCore.QChildEvent.child": (),
-    "PySide2.QtCore.QChildEvent.polished": (),
-    "PySide2.QtCore.QChildEvent.removed": (),
-# class PySide2.QtCore.QCollator:
-    "PySide2.QtCore.QCollator.__init__": [(), ('PySide2.QtCore.QCollator',), ('PySide2.QtCore.QLocale',)],
-    "PySide2.QtCore.QCollator.__call__": ('str', 'str'),
-    "PySide2.QtCore.QCollator.caseSensitivity": (),
-    "PySide2.QtCore.QCollator.compare": [('str', 'int', 'str', 'int'), ('str', 'str')],
-    "PySide2.QtCore.QCollator.ignorePunctuation": (),
-    "PySide2.QtCore.QCollator.locale": (),
-    "PySide2.QtCore.QCollator.numericMode": (),
-    "PySide2.QtCore.QCollator.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QCollator.setIgnorePunctuation": ('bool',),
-    "PySide2.QtCore.QCollator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QCollator.setNumericMode": ('bool',),
-    "PySide2.QtCore.QCollator.sortKey": ('str',),
-    "PySide2.QtCore.QCollator.swap": ('PySide2.QtCore.QCollator',),
-# class PySide2.QtCore.QCollatorSortKey:
-    "PySide2.QtCore.QCollatorSortKey.__init__": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.compare": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.swap": ('PySide2.QtCore.QCollatorSortKey',),
-# class PySide2.QtCore.QCommandLineOption:
-# class PySide2.QtCore.QCommandLineOption.Flag:
-# class PySide2.QtCore.QCommandLineOption.Flags:
-    "PySide2.QtCore.QCommandLineOption.__init__": [('PySide2.QtCore.QCommandLineOption',), ('str',), ('str', 'str', 'str', 'str'), ('typing.Sequence[str]',), ('typing.Sequence[str]', 'str', 'str', 'str')],
-    "PySide2.QtCore.QCommandLineOption.defaultValues": (),
-    "PySide2.QtCore.QCommandLineOption.description": (),
-    "PySide2.QtCore.QCommandLineOption.flags": (),
-    "PySide2.QtCore.QCommandLineOption.isHidden": (),
-    "PySide2.QtCore.QCommandLineOption.names": (),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValue": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValues": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineOption.setDescription": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setFlags": ('PySide2.QtCore.QCommandLineOption.Flags',),
-    "PySide2.QtCore.QCommandLineOption.setHidden": ('bool',),
-    "PySide2.QtCore.QCommandLineOption.setValueName": ('str',),
-    "PySide2.QtCore.QCommandLineOption.swap": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineOption.valueName": (),
-# class PySide2.QtCore.QCommandLineParser:
-# class PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode:
-# class PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode:
-    "PySide2.QtCore.QCommandLineParser.__init__": (),
-    "PySide2.QtCore.QCommandLineParser.addHelpOption": (),
-    "PySide2.QtCore.QCommandLineParser.addOption": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineParser.addOptions": ('typing.Sequence[PySide2.QtCore.QCommandLineOption]',),
-    "PySide2.QtCore.QCommandLineParser.addPositionalArgument": ('str', 'str', 'str'),
-    "PySide2.QtCore.QCommandLineParser.addVersionOption": (),
-    "PySide2.QtCore.QCommandLineParser.applicationDescription": (),
-    "PySide2.QtCore.QCommandLineParser.clearPositionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.errorText": (),
-    "PySide2.QtCore.QCommandLineParser.helpText": (),
-    "PySide2.QtCore.QCommandLineParser.isSet": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.optionNames": (),
-    "PySide2.QtCore.QCommandLineParser.parse": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineParser.positionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.process": [('PySide2.QtCore.QCoreApplication',), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCommandLineParser.setApplicationDescription": ('str',),
-    "PySide2.QtCore.QCommandLineParser.setOptionsAfterPositionalArgumentsMode": ('PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode',),
-    "PySide2.QtCore.QCommandLineParser.setSingleDashWordOptionMode": ('PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode',),
-    "PySide2.QtCore.QCommandLineParser.showHelp": ('int',),
-    "PySide2.QtCore.QCommandLineParser.showVersion": (),
-    "PySide2.QtCore.QCommandLineParser.unknownOptionNames": (),
-    "PySide2.QtCore.QCommandLineParser.value": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.values": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-# class PySide2.QtCore.QConcatenateTablesProxyModel:
-    "PySide2.QtCore.QConcatenateTablesProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.addSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QConcatenateTablesProxyModel.removeSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QCoreApplication:
-    "PySide2.QtCore.QCoreApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCoreApplication.addLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.applicationDirPath": (),
-    "PySide2.QtCore.QCoreApplication.applicationFilePath": (),
-    "PySide2.QtCore.QCoreApplication.applicationName": (),
-    "PySide2.QtCore.QCoreApplication.applicationPid": (),
-    "PySide2.QtCore.QCoreApplication.applicationVersion": (),
-    "PySide2.QtCore.QCoreApplication.arguments": (),
-    "PySide2.QtCore.QCoreApplication.closingDown": (),
-    "PySide2.QtCore.QCoreApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QCoreApplication.eventDispatcher": (),
-    "PySide2.QtCore.QCoreApplication.exec_": (),
-    "PySide2.QtCore.QCoreApplication.exit": ('int',),
-    "PySide2.QtCore.QCoreApplication.flush": (),
-    "PySide2.QtCore.QCoreApplication.hasPendingEvents": (),
-    "PySide2.QtCore.QCoreApplication.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.installTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.instance": (),
-    "PySide2.QtCore.QCoreApplication.isQuitLockEnabled": (),
-    "PySide2.QtCore.QCoreApplication.isSetuidAllowed": (),
-    "PySide2.QtCore.QCoreApplication.libraryPaths": (),
-    "PySide2.QtCore.QCoreApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.organizationDomain": (),
-    "PySide2.QtCore.QCoreApplication.organizationName": (),
-    "PySide2.QtCore.QCoreApplication.postEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QCoreApplication.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QCoreApplication.quit": (),
-    "PySide2.QtCore.QCoreApplication.removeLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.removePostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.removeTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.sendEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.sendPostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.setApplicationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setApplicationVersion": ('str',),
-    "PySide2.QtCore.QCoreApplication.setAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute', 'bool'),
-    "PySide2.QtCore.QCoreApplication.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QCoreApplication.setLibraryPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationDomain": ('str',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setQuitLockEnabled": ('bool',),
-    "PySide2.QtCore.QCoreApplication.setSetuidAllowed": ('bool',),
-    "PySide2.QtCore.QCoreApplication.shutdown": (),
-    "PySide2.QtCore.QCoreApplication.startingUp": (),
-    "PySide2.QtCore.QCoreApplication.testAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute',),
-    "PySide2.QtCore.QCoreApplication.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QCryptographicHash:
-# class PySide2.QtCore.QCryptographicHash.Algorithm:
-    "PySide2.QtCore.QCryptographicHash.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QCryptographicHash.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QCryptographicHash.hashLength": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.reset": (),
-    "PySide2.QtCore.QCryptographicHash.result": (),
-# class PySide2.QtCore.QDataStream:
-# class PySide2.QtCore.QDataStream.ByteOrder:
-# class PySide2.QtCore.QDataStream.FloatingPointPrecision:
-# class PySide2.QtCore.QDataStream.Status:
-# class PySide2.QtCore.QDataStream.Version:
-    "PySide2.QtCore.QDataStream.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QDataStream.__lshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',), ('str',)],
-    "PySide2.QtCore.QDataStream.__rshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',)],
-    "PySide2.QtCore.QDataStream.abortTransaction": (),
-    "PySide2.QtCore.QDataStream.atEnd": (),
-    "PySide2.QtCore.QDataStream.byteOrder": (),
-    "PySide2.QtCore.QDataStream.commitTransaction": (),
-    "PySide2.QtCore.QDataStream.device": (),
-    "PySide2.QtCore.QDataStream.floatingPointPrecision": (),
-    "PySide2.QtCore.QDataStream.readBool": (),
-    "PySide2.QtCore.QDataStream.readDouble": (),
-    "PySide2.QtCore.QDataStream.readFloat": (),
-    "PySide2.QtCore.QDataStream.readInt16": (),
-    "PySide2.QtCore.QDataStream.readInt32": (),
-    "PySide2.QtCore.QDataStream.readInt64": (),
-    "PySide2.QtCore.QDataStream.readInt8": (),
-    "PySide2.QtCore.QDataStream.readQChar": (),
-    "PySide2.QtCore.QDataStream.readQString": (),
-    "PySide2.QtCore.QDataStream.readQStringList": (),
-    "PySide2.QtCore.QDataStream.readQVariant": (),
-    "PySide2.QtCore.QDataStream.readRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.readString": (),
-    "PySide2.QtCore.QDataStream.readUInt16": (),
-    "PySide2.QtCore.QDataStream.readUInt32": (),
-    "PySide2.QtCore.QDataStream.readUInt64": (),
-    "PySide2.QtCore.QDataStream.readUInt8": (),
-    "PySide2.QtCore.QDataStream.resetStatus": (),
-    "PySide2.QtCore.QDataStream.rollbackTransaction": (),
-    "PySide2.QtCore.QDataStream.setByteOrder": ('PySide2.QtCore.QDataStream.ByteOrder',),
-    "PySide2.QtCore.QDataStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QDataStream.setFloatingPointPrecision": ('PySide2.QtCore.QDataStream.FloatingPointPrecision',),
-    "PySide2.QtCore.QDataStream.setStatus": ('PySide2.QtCore.QDataStream.Status',),
-    "PySide2.QtCore.QDataStream.setVersion": ('int',),
-    "PySide2.QtCore.QDataStream.skipRawData": ('int',),
-    "PySide2.QtCore.QDataStream.startTransaction": (),
-    "PySide2.QtCore.QDataStream.status": (),
-    "PySide2.QtCore.QDataStream.unsetDevice": (),
-    "PySide2.QtCore.QDataStream.version": (),
-    "PySide2.QtCore.QDataStream.writeBool": ('bool',),
-    "PySide2.QtCore.QDataStream.writeDouble": ('float',),
-    "PySide2.QtCore.QDataStream.writeFloat": ('float',),
-    "PySide2.QtCore.QDataStream.writeInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt8": ('int',),
-    "PySide2.QtCore.QDataStream.writeQChar": ('str',),
-    "PySide2.QtCore.QDataStream.writeQString": ('str',),
-    "PySide2.QtCore.QDataStream.writeQStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDataStream.writeQVariant": ('typing.Any',),
-    "PySide2.QtCore.QDataStream.writeRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.writeString": ('str',),
-    "PySide2.QtCore.QDataStream.writeUInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt8": ('int',),
-# class PySide2.QtCore.QDate:
-# class PySide2.QtCore.QDate.MonthNameType:
-    "PySide2.QtCore.QDate.__init__": [(), ('PySide2.QtCore.QDate',), ('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.__copy__": (),
-    "PySide2.QtCore.QDate.__reduce__": (),
-    "PySide2.QtCore.QDate.__repr__": (),
-    "PySide2.QtCore.QDate.addDays": ('int',),
-    "PySide2.QtCore.QDate.addMonths": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.addYears": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.currentDate": (),
-    "PySide2.QtCore.QDate.day": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfWeek": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInMonth": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysTo": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDate.endOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.fromJulianDay": ('int',),
-    "PySide2.QtCore.QDate.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.getDate": (),
-    "PySide2.QtCore.QDate.isLeapYear": ('int',),
-    "PySide2.QtCore.QDate.isNull": (),
-    "PySide2.QtCore.QDate.isValid": [(), ('int', 'int', 'int')],
-    "PySide2.QtCore.QDate.longDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.longMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.month": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.setDate": [('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.shortDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.shortMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.startOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.toJulianDay": (),
-    "PySide2.QtCore.QDate.toPython": (),
-    "PySide2.QtCore.QDate.toString": [('PySide2.QtCore.Qt.DateFormat',), ('PySide2.QtCore.Qt.DateFormat', 'PySide2.QtCore.QCalendar'), ('str',), ('str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.weekNumber": (),
-    "PySide2.QtCore.QDate.year": [(), ('PySide2.QtCore.QCalendar',)],
-# class PySide2.QtCore.QDateTime:
-# class PySide2.QtCore.QDateTime.YearRange:
-    "PySide2.QtCore.QDateTime.__init__": [(), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.QTimeZone'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec', 'int'), ('PySide2.QtCore.QDateTime',), ('int', 'int', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QDateTime.__copy__": (),
-    "PySide2.QtCore.QDateTime.__reduce__": (),
-    "PySide2.QtCore.QDateTime.__repr__": (),
-    "PySide2.QtCore.QDateTime.addDays": ('int',),
-    "PySide2.QtCore.QDateTime.addMSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addMonths": ('int',),
-    "PySide2.QtCore.QDateTime.addSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addYears": ('int',),
-    "PySide2.QtCore.QDateTime.currentDateTime": (),
-    "PySide2.QtCore.QDateTime.currentDateTimeUtc": (),
-    "PySide2.QtCore.QDateTime.currentMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.currentSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.date": (),
-    "PySide2.QtCore.QDateTime.daysTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.fromMSecsSinceEpoch": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromSecsSinceEpoch": [('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDateTime.fromTime_t": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.isDaylightTime": (),
-    "PySide2.QtCore.QDateTime.isNull": (),
-    "PySide2.QtCore.QDateTime.isValid": (),
-    "PySide2.QtCore.QDateTime.msecsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.offsetFromUtc": (),
-    "PySide2.QtCore.QDateTime.secsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDateTime.setMSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.setSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QDateTime.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.setTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.setTime_t": ('int',),
-    "PySide2.QtCore.QDateTime.setUtcOffset": ('int',),
-    "PySide2.QtCore.QDateTime.swap": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.time": (),
-    "PySide2.QtCore.QDateTime.timeSpec": (),
-    "PySide2.QtCore.QDateTime.timeZone": (),
-    "PySide2.QtCore.QDateTime.timeZoneAbbreviation": (),
-    "PySide2.QtCore.QDateTime.toLocalTime": (),
-    "PySide2.QtCore.QDateTime.toMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.toPython": (),
-    "PySide2.QtCore.QDateTime.toSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-    "PySide2.QtCore.QDateTime.toTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.toTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.toTime_t": (),
-    "PySide2.QtCore.QDateTime.toUTC": (),
-    "PySide2.QtCore.QDateTime.utcOffset": (),
-# class PySide2.QtCore.QDeadlineTimer:
-# class PySide2.QtCore.QDeadlineTimer.ForeverConstant:
-    "PySide2.QtCore.QDeadlineTimer.__init__": [('PySide2.QtCore.QDeadlineTimer',), ('PySide2.QtCore.QDeadlineTimer.ForeverConstant', 'PySide2.QtCore.Qt.TimerType'), ('PySide2.QtCore.Qt.TimerType',), ('int', 'PySide2.QtCore.Qt.TimerType')],
-    "PySide2.QtCore.QDeadlineTimer.__copy__": (),
-    "PySide2.QtCore.QDeadlineTimer.__iadd__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer.__isub__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer._q_data": (),
-    "PySide2.QtCore.QDeadlineTimer.addNSecs": ('PySide2.QtCore.QDeadlineTimer', 'int'),
-    "PySide2.QtCore.QDeadlineTimer.current": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.deadline": (),
-    "PySide2.QtCore.QDeadlineTimer.deadlineNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.hasExpired": (),
-    "PySide2.QtCore.QDeadlineTimer.isForever": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTime": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTimeNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.setDeadline": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseDeadline": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseRemainingTime": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setRemainingTime": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.swap": ('PySide2.QtCore.QDeadlineTimer',),
-    "PySide2.QtCore.QDeadlineTimer.timerType": (),
-# class PySide2.QtCore.QDir:
-# class PySide2.QtCore.QDir.Filter:
-# class PySide2.QtCore.QDir.Filters:
-# class PySide2.QtCore.QDir.SortFlag:
-# class PySide2.QtCore.QDir.SortFlags:
-    "PySide2.QtCore.QDir.__init__": [('PySide2.QtCore.QDir',), ('str',), ('str', 'str', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QDir.Filters')],
-    "PySide2.QtCore.QDir.__copy__": (),
-    "PySide2.QtCore.QDir.__reduce__": (),
-    "PySide2.QtCore.QDir.absoluteFilePath": ('str',),
-    "PySide2.QtCore.QDir.absolutePath": (),
-    "PySide2.QtCore.QDir.addResourceSearchPath": ('str',),
-    "PySide2.QtCore.QDir.addSearchPath": ('str', 'str'),
-    "PySide2.QtCore.QDir.canonicalPath": (),
-    "PySide2.QtCore.QDir.cd": ('str',),
-    "PySide2.QtCore.QDir.cdUp": (),
-    "PySide2.QtCore.QDir.cleanPath": ('str',),
-    "PySide2.QtCore.QDir.count": (),
-    "PySide2.QtCore.QDir.current": (),
-    "PySide2.QtCore.QDir.currentPath": (),
-    "PySide2.QtCore.QDir.dirName": (),
-    "PySide2.QtCore.QDir.drives": (),
-    "PySide2.QtCore.QDir.entryInfoList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.entryList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.exists": [(), ('str',)],
-    "PySide2.QtCore.QDir.filePath": ('str',),
-    "PySide2.QtCore.QDir.filter": (),
-    "PySide2.QtCore.QDir.fromNativeSeparators": ('str',),
-    "PySide2.QtCore.QDir.home": (),
-    "PySide2.QtCore.QDir.homePath": (),
-    "PySide2.QtCore.QDir.isAbsolute": (),
-    "PySide2.QtCore.QDir.isAbsolutePath": ('str',),
-    "PySide2.QtCore.QDir.isEmpty": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.isReadable": (),
-    "PySide2.QtCore.QDir.isRelative": (),
-    "PySide2.QtCore.QDir.isRelativePath": ('str',),
-    "PySide2.QtCore.QDir.isRoot": (),
-    "PySide2.QtCore.QDir.listSeparator": (),
-    "PySide2.QtCore.QDir.makeAbsolute": (),
-    "PySide2.QtCore.QDir.match": [('str', 'str'), ('typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QDir.mkdir": ('str',),
-    "PySide2.QtCore.QDir.mkpath": ('str',),
-    "PySide2.QtCore.QDir.nameFilters": (),
-    "PySide2.QtCore.QDir.nameFiltersFromString": ('str',),
-    "PySide2.QtCore.QDir.path": (),
-    "PySide2.QtCore.QDir.refresh": (),
-    "PySide2.QtCore.QDir.relativeFilePath": ('str',),
-    "PySide2.QtCore.QDir.remove": ('str',),
-    "PySide2.QtCore.QDir.removeRecursively": (),
-    "PySide2.QtCore.QDir.rename": ('str', 'str'),
-    "PySide2.QtCore.QDir.rmdir": ('str',),
-    "PySide2.QtCore.QDir.rmpath": ('str',),
-    "PySide2.QtCore.QDir.root": (),
-    "PySide2.QtCore.QDir.rootPath": (),
-    "PySide2.QtCore.QDir.searchPaths": ('str',),
-    "PySide2.QtCore.QDir.separator": (),
-    "PySide2.QtCore.QDir.setCurrent": ('str',),
-    "PySide2.QtCore.QDir.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDir.setPath": ('str',),
-    "PySide2.QtCore.QDir.setSearchPaths": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QDir.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtCore.QDir.sorting": (),
-    "PySide2.QtCore.QDir.swap": ('PySide2.QtCore.QDir',),
-    "PySide2.QtCore.QDir.temp": (),
-    "PySide2.QtCore.QDir.tempPath": (),
-    "PySide2.QtCore.QDir.toNativeSeparators": ('str',),
-# class PySide2.QtCore.QDirIterator:
-# class PySide2.QtCore.QDirIterator.IteratorFlag:
-# class PySide2.QtCore.QDirIterator.IteratorFlags:
-    "PySide2.QtCore.QDirIterator.__init__": [('PySide2.QtCore.QDir', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags')],
-    "PySide2.QtCore.QDirIterator.fileInfo": (),
-    "PySide2.QtCore.QDirIterator.fileName": (),
-    "PySide2.QtCore.QDirIterator.filePath": (),
-    "PySide2.QtCore.QDirIterator.hasNext": (),
-    "PySide2.QtCore.QDirIterator.path": (),
-# class PySide2.QtCore.QDynamicPropertyChangeEvent:
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.__init__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.propertyName": (),
-# class PySide2.QtCore.QEasingCurve:
-# class PySide2.QtCore.QEasingCurve.Type:
-    "PySide2.QtCore.QEasingCurve.__init__": [('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QEasingCurve.Type',)],
-    "PySide2.QtCore.QEasingCurve.__copy__": (),
-    "PySide2.QtCore.QEasingCurve.addCubicBezierSegment": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QEasingCurve.addTCBSegment": ('PySide2.QtCore.QPointF', 'float', 'float', 'float'),
-    "PySide2.QtCore.QEasingCurve.amplitude": (),
-    "PySide2.QtCore.QEasingCurve.customType": (),
-    "PySide2.QtCore.QEasingCurve.overshoot": (),
-    "PySide2.QtCore.QEasingCurve.period": (),
-    "PySide2.QtCore.QEasingCurve.setAmplitude": ('float',),
-    "PySide2.QtCore.QEasingCurve.setCustomType": ('object',),
-    "PySide2.QtCore.QEasingCurve.setOvershoot": ('float',),
-    "PySide2.QtCore.QEasingCurve.setPeriod": ('float',),
-    "PySide2.QtCore.QEasingCurve.setType": ('PySide2.QtCore.QEasingCurve.Type',),
-    "PySide2.QtCore.QEasingCurve.swap": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QEasingCurve.toCubicSpline": (),
-    "PySide2.QtCore.QEasingCurve.type": (),
-    "PySide2.QtCore.QEasingCurve.valueForProgress": ('float',),
-# class PySide2.QtCore.QElapsedTimer:
-# class PySide2.QtCore.QElapsedTimer.ClockType:
-    "PySide2.QtCore.QElapsedTimer.__init__": [(), ('PySide2.QtCore.QElapsedTimer',)],
-    "PySide2.QtCore.QElapsedTimer.__copy__": (),
-    "PySide2.QtCore.QElapsedTimer.clockType": (),
-    "PySide2.QtCore.QElapsedTimer.elapsed": (),
-    "PySide2.QtCore.QElapsedTimer.hasExpired": ('int',),
-    "PySide2.QtCore.QElapsedTimer.invalidate": (),
-    "PySide2.QtCore.QElapsedTimer.isMonotonic": (),
-    "PySide2.QtCore.QElapsedTimer.isValid": (),
-    "PySide2.QtCore.QElapsedTimer.msecsSinceReference": (),
-    "PySide2.QtCore.QElapsedTimer.msecsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.nsecsElapsed": (),
-    "PySide2.QtCore.QElapsedTimer.restart": (),
-    "PySide2.QtCore.QElapsedTimer.secsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.start": (),
-# class PySide2.QtCore.QEvent:
-# class PySide2.QtCore.QEvent.Type:
-    "PySide2.QtCore.QEvent.__init__": [('PySide2.QtCore.QEvent',), ('PySide2.QtCore.QEvent.Type',)],
-    "PySide2.QtCore.QEvent.accept": (),
-    "PySide2.QtCore.QEvent.ignore": (),
-    "PySide2.QtCore.QEvent.isAccepted": (),
-    "PySide2.QtCore.QEvent.registerEventType": ('int',),
-    "PySide2.QtCore.QEvent.setAccepted": ('bool',),
-    "PySide2.QtCore.QEvent.spontaneous": (),
-    "PySide2.QtCore.QEvent.type": (),
-# class PySide2.QtCore.QEventLoop:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlag:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlags:
-    "PySide2.QtCore.QEventLoop.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventLoop.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventLoop.exec_": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QEventLoop.exit": ('int',),
-    "PySide2.QtCore.QEventLoop.isRunning": (),
-    "PySide2.QtCore.QEventLoop.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QEventLoop.quit": (),
-    "PySide2.QtCore.QEventLoop.wakeUp": (),
-# class PySide2.QtCore.QEventTransition:
-    "PySide2.QtCore.QEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QEventTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventSource": (),
-    "PySide2.QtCore.QEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventType": (),
-    "PySide2.QtCore.QEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.setEventSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventTransition.setEventType": ('PySide2.QtCore.QEvent.Type',),
-# class PySide2.QtCore.QFactoryInterface:
-    "PySide2.QtCore.QFactoryInterface.__init__": (),
-    "PySide2.QtCore.QFactoryInterface.keys": (),
-# class PySide2.QtCore.QFile:
-    "PySide2.QtCore.QFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFile.copy": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.decodeName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QFile.encodeName": ('str',),
-    "PySide2.QtCore.QFile.exists": [(), ('str',)],
-    "PySide2.QtCore.QFile.fileName": (),
-    "PySide2.QtCore.QFile.link": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.open": [('PySide2.QtCore.QIODevice.OpenMode',), ('int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtCore.QFileDevice.FileHandleFlags')],
-    "PySide2.QtCore.QFile.permissions": [(), ('str',)],
-    "PySide2.QtCore.QFile.readLink": [(), ('str',)],
-    "PySide2.QtCore.QFile.remove": [(), ('str',)],
-    "PySide2.QtCore.QFile.rename": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.resize": [('int',), ('str', 'int')],
-    "PySide2.QtCore.QFile.setFileName": ('str',),
-    "PySide2.QtCore.QFile.setPermissions": [('PySide2.QtCore.QFileDevice.Permissions',), ('str', 'PySide2.QtCore.QFileDevice.Permissions')],
-    "PySide2.QtCore.QFile.size": (),
-    "PySide2.QtCore.QFile.symLinkTarget": [(), ('str',)],
-# class PySide2.QtCore.QFileDevice:
-# class PySide2.QtCore.QFileDevice.FileError:
-# class PySide2.QtCore.QFileDevice.FileHandleFlag:
-# class PySide2.QtCore.QFileDevice.FileHandleFlags:
-# class PySide2.QtCore.QFileDevice.FileTime:
-# class PySide2.QtCore.QFileDevice.MemoryMapFlags:
-# class PySide2.QtCore.QFileDevice.Permission:
-# class PySide2.QtCore.QFileDevice.Permissions:
-    "PySide2.QtCore.QFileDevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QFileDevice.atEnd": (),
-    "PySide2.QtCore.QFileDevice.close": (),
-    "PySide2.QtCore.QFileDevice.error": (),
-    "PySide2.QtCore.QFileDevice.fileName": (),
-    "PySide2.QtCore.QFileDevice.fileTime": ('PySide2.QtCore.QFileDevice.FileTime',),
-    "PySide2.QtCore.QFileDevice.flush": (),
-    "PySide2.QtCore.QFileDevice.handle": (),
-    "PySide2.QtCore.QFileDevice.isSequential": (),
-    "PySide2.QtCore.QFileDevice.map": ('int', 'int', 'PySide2.QtCore.QFileDevice.MemoryMapFlags'),
-    "PySide2.QtCore.QFileDevice.permissions": (),
-    "PySide2.QtCore.QFileDevice.pos": (),
-    "PySide2.QtCore.QFileDevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.resize": ('int',),
-    "PySide2.QtCore.QFileDevice.seek": ('int',),
-    "PySide2.QtCore.QFileDevice.setFileTime": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QFileDevice.FileTime'),
-    "PySide2.QtCore.QFileDevice.setPermissions": ('PySide2.QtCore.QFileDevice.Permissions',),
-    "PySide2.QtCore.QFileDevice.size": (),
-    "PySide2.QtCore.QFileDevice.unmap": ('str',),
-    "PySide2.QtCore.QFileDevice.unsetError": (),
-    "PySide2.QtCore.QFileDevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QFileInfo:
-    "PySide2.QtCore.QFileInfo.__init__": [(), ('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('PySide2.QtCore.QFileInfo',), ('str',)],
-    "PySide2.QtCore.QFileInfo.__copy__": (),
-    "PySide2.QtCore.QFileInfo.__reduce__": (),
-    "PySide2.QtCore.QFileInfo.absoluteDir": (),
-    "PySide2.QtCore.QFileInfo.absoluteFilePath": (),
-    "PySide2.QtCore.QFileInfo.absolutePath": (),
-    "PySide2.QtCore.QFileInfo.baseName": (),
-    "PySide2.QtCore.QFileInfo.birthTime": (),
-    "PySide2.QtCore.QFileInfo.bundleName": (),
-    "PySide2.QtCore.QFileInfo.caching": (),
-    "PySide2.QtCore.QFileInfo.canonicalFilePath": (),
-    "PySide2.QtCore.QFileInfo.canonicalPath": (),
-    "PySide2.QtCore.QFileInfo.completeBaseName": (),
-    "PySide2.QtCore.QFileInfo.completeSuffix": (),
-    "PySide2.QtCore.QFileInfo.created": (),
-    "PySide2.QtCore.QFileInfo.dir": (),
-    "PySide2.QtCore.QFileInfo.exists": [(), ('str',)],
-    "PySide2.QtCore.QFileInfo.fileName": (),
-    "PySide2.QtCore.QFileInfo.filePath": (),
-    "PySide2.QtCore.QFileInfo.group": (),
-    "PySide2.QtCore.QFileInfo.groupId": (),
-    "PySide2.QtCore.QFileInfo.isAbsolute": (),
-    "PySide2.QtCore.QFileInfo.isBundle": (),
-    "PySide2.QtCore.QFileInfo.isDir": (),
-    "PySide2.QtCore.QFileInfo.isExecutable": (),
-    "PySide2.QtCore.QFileInfo.isFile": (),
-    "PySide2.QtCore.QFileInfo.isHidden": (),
-    "PySide2.QtCore.QFileInfo.isNativePath": (),
-    "PySide2.QtCore.QFileInfo.isReadable": (),
-    "PySide2.QtCore.QFileInfo.isRelative": (),
-    "PySide2.QtCore.QFileInfo.isRoot": (),
-    "PySide2.QtCore.QFileInfo.isShortcut": (),
-    "PySide2.QtCore.QFileInfo.isSymLink": (),
-    "PySide2.QtCore.QFileInfo.isSymbolicLink": (),
-    "PySide2.QtCore.QFileInfo.isWritable": (),
-    "PySide2.QtCore.QFileInfo.lastModified": (),
-    "PySide2.QtCore.QFileInfo.lastRead": (),
-    "PySide2.QtCore.QFileInfo.makeAbsolute": (),
-    "PySide2.QtCore.QFileInfo.metadataChangeTime": (),
-    "PySide2.QtCore.QFileInfo.owner": (),
-    "PySide2.QtCore.QFileInfo.ownerId": (),
-    "PySide2.QtCore.QFileInfo.path": (),
-    "PySide2.QtCore.QFileInfo.readLink": (),
-    "PySide2.QtCore.QFileInfo.refresh": (),
-    "PySide2.QtCore.QFileInfo.setCaching": ('bool',),
-    "PySide2.QtCore.QFileInfo.setFile": [('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QFileInfo.size": (),
-    "PySide2.QtCore.QFileInfo.suffix": (),
-    "PySide2.QtCore.QFileInfo.swap": ('PySide2.QtCore.QFileInfo',),
-    "PySide2.QtCore.QFileInfo.symLinkTarget": (),
-# class PySide2.QtCore.QFileSelector:
-    "PySide2.QtCore.QFileSelector.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QFileSelector.allSelectors": (),
-    "PySide2.QtCore.QFileSelector.extraSelectors": (),
-    "PySide2.QtCore.QFileSelector.select": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtCore.QFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFileSystemWatcher:
-    "PySide2.QtCore.QFileSystemWatcher.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFileSystemWatcher.addPath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.addPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QFileSystemWatcher.directories": (),
-    "PySide2.QtCore.QFileSystemWatcher.files": (),
-    "PySide2.QtCore.QFileSystemWatcher.removePath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.removePaths": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFinalState:
-    "PySide2.QtCore.QFinalState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QFinalState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onExit": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtCore.QGenericArgument:
-    "PySide2.QtCore.QGenericArgument.__init__": [('PySide2.QtCore.QGenericArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericArgument.__copy__": (),
-    "PySide2.QtCore.QGenericArgument.data": (),
-    "PySide2.QtCore.QGenericArgument.name": (),
-# class PySide2.QtCore.QGenericReturnArgument:
-    "PySide2.QtCore.QGenericReturnArgument.__init__": [('PySide2.QtCore.QGenericReturnArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericReturnArgument.__copy__": (),
-# class PySide2.QtCore.QHistoryState:
-# class PySide2.QtCore.QHistoryState.HistoryType:
-    "PySide2.QtCore.QHistoryState.__init__": [('PySide2.QtCore.QHistoryState.HistoryType', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QHistoryState.defaultState": (),
-    "PySide2.QtCore.QHistoryState.defaultTransition": (),
-    "PySide2.QtCore.QHistoryState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.historyType": (),
-    "PySide2.QtCore.QHistoryState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.setDefaultState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QHistoryState.setDefaultTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QHistoryState.setHistoryType": ('PySide2.QtCore.QHistoryState.HistoryType',),
-# class PySide2.QtCore.QIODevice:
-# class PySide2.QtCore.QIODevice.OpenMode:
-# class PySide2.QtCore.QIODevice.OpenModeFlag:
-    "PySide2.QtCore.QIODevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QIODevice.atEnd": (),
-    "PySide2.QtCore.QIODevice.bytesAvailable": (),
-    "PySide2.QtCore.QIODevice.bytesToWrite": (),
-    "PySide2.QtCore.QIODevice.canReadLine": (),
-    "PySide2.QtCore.QIODevice.close": (),
-    "PySide2.QtCore.QIODevice.commitTransaction": (),
-    "PySide2.QtCore.QIODevice.currentReadChannel": (),
-    "PySide2.QtCore.QIODevice.currentWriteChannel": (),
-    "PySide2.QtCore.QIODevice.errorString": (),
-    "PySide2.QtCore.QIODevice.getChar": ('str',),
-    "PySide2.QtCore.QIODevice.isOpen": (),
-    "PySide2.QtCore.QIODevice.isReadable": (),
-    "PySide2.QtCore.QIODevice.isSequential": (),
-    "PySide2.QtCore.QIODevice.isTextModeEnabled": (),
-    "PySide2.QtCore.QIODevice.isTransactionStarted": (),
-    "PySide2.QtCore.QIODevice.isWritable": (),
-    "PySide2.QtCore.QIODevice.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.openMode": (),
-    "PySide2.QtCore.QIODevice.peek": ('int',),
-    "PySide2.QtCore.QIODevice.pos": (),
-    "PySide2.QtCore.QIODevice.putChar": ('int',),
-    "PySide2.QtCore.QIODevice.read": ('int',),
-    "PySide2.QtCore.QIODevice.readAll": (),
-    "PySide2.QtCore.QIODevice.readChannelCount": (),
-    "PySide2.QtCore.QIODevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.readLine": ('int',),
-    "PySide2.QtCore.QIODevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.reset": (),
-    "PySide2.QtCore.QIODevice.rollbackTransaction": (),
-    "PySide2.QtCore.QIODevice.seek": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentReadChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentWriteChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setErrorString": ('str',),
-    "PySide2.QtCore.QIODevice.setOpenMode": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.setTextModeEnabled": ('bool',),
-    "PySide2.QtCore.QIODevice.size": (),
-    "PySide2.QtCore.QIODevice.skip": ('int',),
-    "PySide2.QtCore.QIODevice.startTransaction": (),
-    "PySide2.QtCore.QIODevice.ungetChar": ('int',),
-    "PySide2.QtCore.QIODevice.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QIODevice.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QIODevice.write": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QIODevice.writeChannelCount": (),
-    "PySide2.QtCore.QIODevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QIdentityProxyModel:
-    "PySide2.QtCore.QIdentityProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QIdentityProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QIdentityProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QIdentityProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QIdentityProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QIdentityProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QItemSelection:
-    "PySide2.QtCore.QItemSelection.__init__": [(), ('PySide2.QtCore.QItemSelection',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelection.__add__": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.__copy__": (),
-    "PySide2.QtCore.QItemSelection.__iadd__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.__lshift__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.append": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.at": ('int',),
-    "PySide2.QtCore.QItemSelection.back": (),
-    "PySide2.QtCore.QItemSelection.clear": (),
-    "PySide2.QtCore.QItemSelection.constFirst": (),
-    "PySide2.QtCore.QItemSelection.constLast": (),
-    "PySide2.QtCore.QItemSelection.contains": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelection.count": [(), ('PySide2.QtCore.QItemSelectionRange',)],
-    "PySide2.QtCore.QItemSelection.detachShared": (),
-    "PySide2.QtCore.QItemSelection.empty": (),
-    "PySide2.QtCore.QItemSelection.endsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.first": (),
-    "PySide2.QtCore.QItemSelection.fromSet": ('typing.Set[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.fromVector": ('typing.List[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.front": (),
-    "PySide2.QtCore.QItemSelection.indexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.indexes": (),
-    "PySide2.QtCore.QItemSelection.insert": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.isEmpty": (),
-    "PySide2.QtCore.QItemSelection.isSharedWith": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.last": (),
-    "PySide2.QtCore.QItemSelection.lastIndexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.length": (),
-    "PySide2.QtCore.QItemSelection.merge": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelection.mid": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.move": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.pop_back": (),
-    "PySide2.QtCore.QItemSelection.pop_front": (),
-    "PySide2.QtCore.QItemSelection.prepend": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_back": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_front": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAll": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.removeFirst": (),
-    "PySide2.QtCore.QItemSelection.removeLast": (),
-    "PySide2.QtCore.QItemSelection.removeOne": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.replace": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.reserve": ('int',),
-    "PySide2.QtCore.QItemSelection.select": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelection.setSharable": ('bool',),
-    "PySide2.QtCore.QItemSelection.size": (),
-    "PySide2.QtCore.QItemSelection.split": ('PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelection.startsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.swap": [('int', 'int'), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.takeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.takeFirst": (),
-    "PySide2.QtCore.QItemSelection.takeLast": (),
-    "PySide2.QtCore.QItemSelection.toSet": (),
-    "PySide2.QtCore.QItemSelection.toVector": (),
-    "PySide2.QtCore.QItemSelection.value": [('int',), ('int', 'PySide2.QtCore.QItemSelectionRange')],
-# class PySide2.QtCore.QItemSelectionModel:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlag:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlags:
-    "PySide2.QtCore.QItemSelectionModel.__init__": [('PySide2.QtCore.QAbstractItemModel',), ('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QItemSelectionModel.clear": (),
-    "PySide2.QtCore.QItemSelectionModel.clearCurrentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.clearSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.columnIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.currentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.emitSelectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelectionModel.hasSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.isColumnSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isRowSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isSelected": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelectionModel.model": (),
-    "PySide2.QtCore.QItemSelectionModel.reset": (),
-    "PySide2.QtCore.QItemSelectionModel.rowIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.select": [('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtCore.QItemSelectionModel.selectedColumns": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selectedIndexes": (),
-    "PySide2.QtCore.QItemSelectionModel.selectedRows": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selection": (),
-    "PySide2.QtCore.QItemSelectionModel.setCurrentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelectionModel.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-# class PySide2.QtCore.QItemSelectionRange:
-    "PySide2.QtCore.QItemSelectionRange.__init__": [(), ('PySide2.QtCore.QItemSelectionRange',), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.__copy__": (),
-    "PySide2.QtCore.QItemSelectionRange.bottom": (),
-    "PySide2.QtCore.QItemSelectionRange.bottomRight": (),
-    "PySide2.QtCore.QItemSelectionRange.contains": [('PySide2.QtCore.QModelIndex',), ('int', 'int', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.height": (),
-    "PySide2.QtCore.QItemSelectionRange.indexes": (),
-    "PySide2.QtCore.QItemSelectionRange.intersected": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.intersects": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.isEmpty": (),
-    "PySide2.QtCore.QItemSelectionRange.isValid": (),
-    "PySide2.QtCore.QItemSelectionRange.left": (),
-    "PySide2.QtCore.QItemSelectionRange.model": (),
-    "PySide2.QtCore.QItemSelectionRange.parent": (),
-    "PySide2.QtCore.QItemSelectionRange.right": (),
-    "PySide2.QtCore.QItemSelectionRange.swap": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.top": (),
-    "PySide2.QtCore.QItemSelectionRange.topLeft": (),
-    "PySide2.QtCore.QItemSelectionRange.width": (),
-# class PySide2.QtCore.QJsonArray:
-    "PySide2.QtCore.QJsonArray.__init__": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonArray.__add__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__copy__": (),
-    "PySide2.QtCore.QJsonArray.__iadd__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__lshift__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.append": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.at": ('int',),
-    "PySide2.QtCore.QJsonArray.contains": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.count": (),
-    "PySide2.QtCore.QJsonArray.empty": (),
-    "PySide2.QtCore.QJsonArray.first": (),
-    "PySide2.QtCore.QJsonArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QJsonArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QJsonArray.insert": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.isEmpty": (),
-    "PySide2.QtCore.QJsonArray.last": (),
-    "PySide2.QtCore.QJsonArray.pop_back": (),
-    "PySide2.QtCore.QJsonArray.pop_front": (),
-    "PySide2.QtCore.QJsonArray.prepend": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_back": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_front": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.removeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.removeFirst": (),
-    "PySide2.QtCore.QJsonArray.removeLast": (),
-    "PySide2.QtCore.QJsonArray.replace": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.size": (),
-    "PySide2.QtCore.QJsonArray.swap": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonArray.takeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.toVariantList": (),
-# class PySide2.QtCore.QJsonDocument:
-# class PySide2.QtCore.QJsonDocument.DataValidation:
-# class PySide2.QtCore.QJsonDocument.JsonFormat:
-    "PySide2.QtCore.QJsonDocument.__init__": [(), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonDocument.__copy__": (),
-    "PySide2.QtCore.QJsonDocument.array": (),
-    "PySide2.QtCore.QJsonDocument.fromBinaryData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromJson": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonParseError'),
-    "PySide2.QtCore.QJsonDocument.fromRawData": ('str', 'int', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonDocument.isArray": (),
-    "PySide2.QtCore.QJsonDocument.isEmpty": (),
-    "PySide2.QtCore.QJsonDocument.isNull": (),
-    "PySide2.QtCore.QJsonDocument.isObject": (),
-    "PySide2.QtCore.QJsonDocument.object": (),
-    "PySide2.QtCore.QJsonDocument.rawData": (),
-    "PySide2.QtCore.QJsonDocument.setArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonDocument.setObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QJsonDocument.swap": ('PySide2.QtCore.QJsonDocument',),
-    "PySide2.QtCore.QJsonDocument.toBinaryData": (),
-    "PySide2.QtCore.QJsonDocument.toJson": [(), ('PySide2.QtCore.QJsonDocument.JsonFormat',)],
-    "PySide2.QtCore.QJsonDocument.toVariant": (),
-# class PySide2.QtCore.QJsonParseError:
-# class PySide2.QtCore.QJsonParseError.ParseError:
-    "PySide2.QtCore.QJsonParseError.__init__": [(), ('PySide2.QtCore.QJsonParseError',)],
-    "PySide2.QtCore.QJsonParseError.__copy__": (),
-    "PySide2.QtCore.QJsonParseError.errorString": (),
-# class PySide2.QtCore.QJsonValue:
-# class PySide2.QtCore.QJsonValue.Type:
-    "PySide2.QtCore.QJsonValue.__init__": [('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QJsonValue.Type',), ('bool',), ('float',), ('int',), ('str',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.__copy__": (),
-    "PySide2.QtCore.QJsonValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonValue.isArray": (),
-    "PySide2.QtCore.QJsonValue.isBool": (),
-    "PySide2.QtCore.QJsonValue.isDouble": (),
-    "PySide2.QtCore.QJsonValue.isNull": (),
-    "PySide2.QtCore.QJsonValue.isObject": (),
-    "PySide2.QtCore.QJsonValue.isString": (),
-    "PySide2.QtCore.QJsonValue.isUndefined": (),
-    "PySide2.QtCore.QJsonValue.swap": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonValue.toArray": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonValue.toBool": ('bool',),
-    "PySide2.QtCore.QJsonValue.toDouble": ('float',),
-    "PySide2.QtCore.QJsonValue.toInt": ('int',),
-    "PySide2.QtCore.QJsonValue.toObject": [(), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.toString": [(), ('str',)],
-    "PySide2.QtCore.QJsonValue.toVariant": (),
-    "PySide2.QtCore.QJsonValue.type": (),
-# class PySide2.QtCore.QLibraryInfo:
-# class PySide2.QtCore.QLibraryInfo.LibraryLocation:
-    "PySide2.QtCore.QLibraryInfo.build": (),
-    "PySide2.QtCore.QLibraryInfo.buildDate": (),
-    "PySide2.QtCore.QLibraryInfo.isDebugBuild": (),
-    "PySide2.QtCore.QLibraryInfo.licensedProducts": (),
-    "PySide2.QtCore.QLibraryInfo.licensee": (),
-    "PySide2.QtCore.QLibraryInfo.location": ('PySide2.QtCore.QLibraryInfo.LibraryLocation',),
-    "PySide2.QtCore.QLibraryInfo.platformPluginArguments": ('str',),
-    "PySide2.QtCore.QLibraryInfo.version": (),
-# class PySide2.QtCore.QLine:
-    "PySide2.QtCore.QLine.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QLine.__copy__": (),
-    "PySide2.QtCore.QLine.__reduce__": (),
-    "PySide2.QtCore.QLine.__repr__": (),
-    "PySide2.QtCore.QLine.center": (),
-    "PySide2.QtCore.QLine.dx": (),
-    "PySide2.QtCore.QLine.dy": (),
-    "PySide2.QtCore.QLine.isNull": (),
-    "PySide2.QtCore.QLine.p1": (),
-    "PySide2.QtCore.QLine.p2": (),
-    "PySide2.QtCore.QLine.setLine": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QLine.setP1": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setP2": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setPoints": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QLine.toTuple": (),
-    "PySide2.QtCore.QLine.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.x1": (),
-    "PySide2.QtCore.QLine.x2": (),
-    "PySide2.QtCore.QLine.y1": (),
-    "PySide2.QtCore.QLine.y2": (),
-# class PySide2.QtCore.QLineF:
-# class PySide2.QtCore.QLineF.IntersectType:
-    "PySide2.QtCore.QLineF.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QLineF.__copy__": (),
-    "PySide2.QtCore.QLineF.__reduce__": (),
-    "PySide2.QtCore.QLineF.__repr__": (),
-    "PySide2.QtCore.QLineF.angle": [(), ('PySide2.QtCore.QLineF',)],
-    "PySide2.QtCore.QLineF.angleTo": ('PySide2.QtCore.QLineF',),
-    "PySide2.QtCore.QLineF.center": (),
-    "PySide2.QtCore.QLineF.dx": (),
-    "PySide2.QtCore.QLineF.dy": (),
-    "PySide2.QtCore.QLineF.fromPolar": ('float', 'float'),
-    "PySide2.QtCore.QLineF.intersect": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.intersects": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.isNull": (),
-    "PySide2.QtCore.QLineF.length": (),
-    "PySide2.QtCore.QLineF.normalVector": (),
-    "PySide2.QtCore.QLineF.p1": (),
-    "PySide2.QtCore.QLineF.p2": (),
-    "PySide2.QtCore.QLineF.pointAt": ('float',),
-    "PySide2.QtCore.QLineF.setAngle": ('float',),
-    "PySide2.QtCore.QLineF.setLength": ('float',),
-    "PySide2.QtCore.QLineF.setLine": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QLineF.setP1": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setP2": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setPoints": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.toLine": (),
-    "PySide2.QtCore.QLineF.toTuple": (),
-    "PySide2.QtCore.QLineF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.unitVector": (),
-    "PySide2.QtCore.QLineF.x1": (),
-    "PySide2.QtCore.QLineF.x2": (),
-    "PySide2.QtCore.QLineF.y1": (),
-    "PySide2.QtCore.QLineF.y2": (),
-# class PySide2.QtCore.QLocale:
-# class PySide2.QtCore.QLocale.Country:
-# class PySide2.QtCore.QLocale.CurrencySymbolFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormats:
-# class PySide2.QtCore.QLocale.FloatingPointPrecisionOption:
-# class PySide2.QtCore.QLocale.FormatType:
-# class PySide2.QtCore.QLocale.Language:
-# class PySide2.QtCore.QLocale.MeasurementSystem:
-# class PySide2.QtCore.QLocale.NumberOption:
-# class PySide2.QtCore.QLocale.NumberOptions:
-# class PySide2.QtCore.QLocale.QuotationStyle:
-# class PySide2.QtCore.QLocale.Script:
-    "PySide2.QtCore.QLocale.__init__": [(), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Country'), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'), ('str',)],
-    "PySide2.QtCore.QLocale.__copy__": (),
-    "PySide2.QtCore.QLocale.amText": (),
-    "PySide2.QtCore.QLocale.bcp47Name": (),
-    "PySide2.QtCore.QLocale.c": (),
-    "PySide2.QtCore.QLocale.collation": (),
-    "PySide2.QtCore.QLocale.countriesForLanguage": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.country": (),
-    "PySide2.QtCore.QLocale.countryToString": ('PySide2.QtCore.QLocale.Country',),
-    "PySide2.QtCore.QLocale.createSeparatedList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QLocale.currencySymbol": ('PySide2.QtCore.QLocale.CurrencySymbolFormat',),
-    "PySide2.QtCore.QLocale.dateFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dateTimeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.decimalPoint": (),
-    "PySide2.QtCore.QLocale.exponential": (),
-    "PySide2.QtCore.QLocale.firstDayOfWeek": (),
-    "PySide2.QtCore.QLocale.formattedDataSize": ('int', 'int', 'PySide2.QtCore.QLocale.DataSizeFormats'),
-    "PySide2.QtCore.QLocale.groupSeparator": (),
-    "PySide2.QtCore.QLocale.language": (),
-    "PySide2.QtCore.QLocale.languageToString": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.matchingLocales": ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'),
-    "PySide2.QtCore.QLocale.measurementSystem": (),
-    "PySide2.QtCore.QLocale.monthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.name": (),
-    "PySide2.QtCore.QLocale.nativeCountryName": (),
-    "PySide2.QtCore.QLocale.nativeLanguageName": (),
-    "PySide2.QtCore.QLocale.negativeSign": (),
-    "PySide2.QtCore.QLocale.numberOptions": (),
-    "PySide2.QtCore.QLocale.percent": (),
-    "PySide2.QtCore.QLocale.pmText": (),
-    "PySide2.QtCore.QLocale.positiveSign": (),
-    "PySide2.QtCore.QLocale.quoteString": ('str', 'PySide2.QtCore.QLocale.QuotationStyle'),
-    "PySide2.QtCore.QLocale.script": (),
-    "PySide2.QtCore.QLocale.scriptToString": ('PySide2.QtCore.QLocale.Script',),
-    "PySide2.QtCore.QLocale.setDefault": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.setNumberOptions": ('PySide2.QtCore.QLocale.NumberOptions',),
-    "PySide2.QtCore.QLocale.standaloneDayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.standaloneMonthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.swap": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.system": (),
-    "PySide2.QtCore.QLocale.textDirection": (),
-    "PySide2.QtCore.QLocale.timeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.toCurrencyString": [('float', 'str'), ('float', 'str', 'int'), ('int', 'str')],
-    "PySide2.QtCore.QLocale.toDate": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDateTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDouble": ('str',),
-    "PySide2.QtCore.QLocale.toFloat": ('str',),
-    "PySide2.QtCore.QLocale.toInt": ('str',),
-    "PySide2.QtCore.QLocale.toLong": ('str',),
-    "PySide2.QtCore.QLocale.toLongLong": ('str',),
-    "PySide2.QtCore.QLocale.toLower": ('str',),
-    "PySide2.QtCore.QLocale.toShort": ('str',),
-    "PySide2.QtCore.QLocale.toString": [('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDate', 'str'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDateTime', 'str'), ('PySide2.QtCore.QTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QTime', 'str'), ('float', 'int', 'int'), ('int',)],
-    "PySide2.QtCore.QLocale.toTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toUInt": ('str',),
-    "PySide2.QtCore.QLocale.toULong": ('str',),
-    "PySide2.QtCore.QLocale.toULongLong": ('str',),
-    "PySide2.QtCore.QLocale.toUShort": ('str',),
-    "PySide2.QtCore.QLocale.toUpper": ('str',),
-    "PySide2.QtCore.QLocale.uiLanguages": (),
-    "PySide2.QtCore.QLocale.weekdays": (),
-    "PySide2.QtCore.QLocale.zeroDigit": (),
-# class PySide2.QtCore.QLockFile:
-# class PySide2.QtCore.QLockFile.LockError:
-    "PySide2.QtCore.QLockFile.__init__": ('str',),
-    "PySide2.QtCore.QLockFile.error": (),
-    "PySide2.QtCore.QLockFile.getLockInfo": (),
-    "PySide2.QtCore.QLockFile.isLocked": (),
-    "PySide2.QtCore.QLockFile.lock": (),
-    "PySide2.QtCore.QLockFile.removeStaleLockFile": (),
-    "PySide2.QtCore.QLockFile.setStaleLockTime": ('int',),
-    "PySide2.QtCore.QLockFile.staleLockTime": (),
-    "PySide2.QtCore.QLockFile.tryLock": ('int',),
-    "PySide2.QtCore.QLockFile.unlock": (),
-# class PySide2.QtCore.QMargins:
-    "PySide2.QtCore.QMargins.__init__": [(), ('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QMargins.__add__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__copy__": (),
-    "PySide2.QtCore.QMargins.__iadd__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__isub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__neg__": (),
-    "PySide2.QtCore.QMargins.__pos__": (),
-    "PySide2.QtCore.QMargins.__sub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.bottom": (),
-    "PySide2.QtCore.QMargins.isNull": (),
-    "PySide2.QtCore.QMargins.left": (),
-    "PySide2.QtCore.QMargins.right": (),
-    "PySide2.QtCore.QMargins.setBottom": ('int',),
-    "PySide2.QtCore.QMargins.setLeft": ('int',),
-    "PySide2.QtCore.QMargins.setRight": ('int',),
-    "PySide2.QtCore.QMargins.setTop": ('int',),
-    "PySide2.QtCore.QMargins.top": (),
-# class PySide2.QtCore.QMarginsF:
-    "PySide2.QtCore.QMarginsF.__init__": [(), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QMarginsF.__add__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__copy__": (),
-    "PySide2.QtCore.QMarginsF.__iadd__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__imul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__isub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__mul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__neg__": (),
-    "PySide2.QtCore.QMarginsF.__pos__": (),
-    "PySide2.QtCore.QMarginsF.__sub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.bottom": (),
-    "PySide2.QtCore.QMarginsF.isNull": (),
-    "PySide2.QtCore.QMarginsF.left": (),
-    "PySide2.QtCore.QMarginsF.right": (),
-    "PySide2.QtCore.QMarginsF.setBottom": ('float',),
-    "PySide2.QtCore.QMarginsF.setLeft": ('float',),
-    "PySide2.QtCore.QMarginsF.setRight": ('float',),
-    "PySide2.QtCore.QMarginsF.setTop": ('float',),
-    "PySide2.QtCore.QMarginsF.toMargins": (),
-    "PySide2.QtCore.QMarginsF.top": (),
-# class PySide2.QtCore.QMessageAuthenticationCode:
-    "PySide2.QtCore.QMessageAuthenticationCode.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMessageAuthenticationCode.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QMessageAuthenticationCode.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QMessageAuthenticationCode.reset": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.result": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.setKey": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QMessageLogContext:
-    "PySide2.QtCore.QMessageLogContext.__init__": [(), ('str', 'int', 'str', 'str')],
-# class PySide2.QtCore.QMetaClassInfo:
-    "PySide2.QtCore.QMetaClassInfo.__init__": [(), ('PySide2.QtCore.QMetaClassInfo',)],
-    "PySide2.QtCore.QMetaClassInfo.__copy__": (),
-    "PySide2.QtCore.QMetaClassInfo.name": (),
-    "PySide2.QtCore.QMetaClassInfo.value": (),
-# class PySide2.QtCore.QMetaEnum:
-    "PySide2.QtCore.QMetaEnum.__init__": [(), ('PySide2.QtCore.QMetaEnum',)],
-    "PySide2.QtCore.QMetaEnum.__copy__": (),
-    "PySide2.QtCore.QMetaEnum.enumName": (),
-    "PySide2.QtCore.QMetaEnum.isFlag": (),
-    "PySide2.QtCore.QMetaEnum.isScoped": (),
-    "PySide2.QtCore.QMetaEnum.isValid": (),
-    "PySide2.QtCore.QMetaEnum.key": ('int',),
-    "PySide2.QtCore.QMetaEnum.keyCount": (),
-    "PySide2.QtCore.QMetaEnum.keyToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.keysToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.name": (),
-    "PySide2.QtCore.QMetaEnum.scope": (),
-    "PySide2.QtCore.QMetaEnum.value": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKey": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKeys": ('int',),
-# class PySide2.QtCore.QMetaMethod:
-# class PySide2.QtCore.QMetaMethod.Access:
-# class PySide2.QtCore.QMetaMethod.MethodType:
-    "PySide2.QtCore.QMetaMethod.__init__": [(), ('PySide2.QtCore.QMetaMethod',)],
-    "PySide2.QtCore.QMetaMethod.__copy__": (),
-    "PySide2.QtCore.QMetaMethod.access": (),
-    "PySide2.QtCore.QMetaMethod.enclosingMetaObject": (),
-    "PySide2.QtCore.QMetaMethod.invoke": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.invokeOnGadget": [('int', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('int', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.isValid": (),
-    "PySide2.QtCore.QMetaMethod.methodIndex": (),
-    "PySide2.QtCore.QMetaMethod.methodSignature": (),
-    "PySide2.QtCore.QMetaMethod.methodType": (),
-    "PySide2.QtCore.QMetaMethod.name": (),
-    "PySide2.QtCore.QMetaMethod.parameterCount": (),
-    "PySide2.QtCore.QMetaMethod.parameterNames": (),
-    "PySide2.QtCore.QMetaMethod.parameterType": ('int',),
-    "PySide2.QtCore.QMetaMethod.parameterTypes": (),
-    "PySide2.QtCore.QMetaMethod.returnType": (),
-    "PySide2.QtCore.QMetaMethod.revision": (),
-    "PySide2.QtCore.QMetaMethod.tag": (),
-    "PySide2.QtCore.QMetaMethod.typeName": (),
-# class PySide2.QtCore.QMetaObject:
-# class PySide2.QtCore.QMetaObject.Call:
-# class PySide2.QtCore.QMetaObject.Connection:
-    "PySide2.QtCore.QMetaObject.Connection.__init__": [(), ('PySide2.QtCore.QMetaObject.Connection',)],
-    "PySide2.QtCore.QMetaObject.__init__": (),
-    "PySide2.QtCore.QMetaObject.cast": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.checkConnectArgs": [('PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QMetaMethod'), ('str', 'str')],
-    "PySide2.QtCore.QMetaObject.classInfo": ('int',),
-    "PySide2.QtCore.QMetaObject.classInfoCount": (),
-    "PySide2.QtCore.QMetaObject.classInfoOffset": (),
-    "PySide2.QtCore.QMetaObject.className": (),
-    "PySide2.QtCore.QMetaObject.connectSlotsByName": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.constructor": ('int',),
-    "PySide2.QtCore.QMetaObject.constructorCount": (),
-    "PySide2.QtCore.QMetaObject.disconnect": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.disconnectOne": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.enumerator": ('int',),
-    "PySide2.QtCore.QMetaObject.enumeratorCount": (),
-    "PySide2.QtCore.QMetaObject.enumeratorOffset": (),
-    "PySide2.QtCore.QMetaObject.indexOfClassInfo": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfConstructor": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfEnumerator": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfMethod": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfProperty": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSignal": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSlot": ('str',),
-    "PySide2.QtCore.QMetaObject.inherits": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtCore.QMetaObject.invokeMethod": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaObject.method": ('int',),
-    "PySide2.QtCore.QMetaObject.methodCount": (),
-    "PySide2.QtCore.QMetaObject.methodOffset": (),
-    "PySide2.QtCore.QMetaObject.newInstance": ('PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'),
-    "PySide2.QtCore.QMetaObject.normalizedSignature": ('str',),
-    "PySide2.QtCore.QMetaObject.normalizedType": ('str',),
-    "PySide2.QtCore.QMetaObject.property": ('int',),
-    "PySide2.QtCore.QMetaObject.propertyCount": (),
-    "PySide2.QtCore.QMetaObject.propertyOffset": (),
-    "PySide2.QtCore.QMetaObject.superClass": (),
-    "PySide2.QtCore.QMetaObject.userProperty": (),
-# class PySide2.QtCore.QMetaProperty:
-    "PySide2.QtCore.QMetaProperty.__init__": [(), ('PySide2.QtCore.QMetaProperty',)],
-    "PySide2.QtCore.QMetaProperty.__copy__": (),
-    "PySide2.QtCore.QMetaProperty.enumerator": (),
-    "PySide2.QtCore.QMetaProperty.hasNotifySignal": (),
-    "PySide2.QtCore.QMetaProperty.hasStdCppSet": (),
-    "PySide2.QtCore.QMetaProperty.isConstant": (),
-    "PySide2.QtCore.QMetaProperty.isDesignable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEditable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEnumType": (),
-    "PySide2.QtCore.QMetaProperty.isFinal": (),
-    "PySide2.QtCore.QMetaProperty.isFlagType": (),
-    "PySide2.QtCore.QMetaProperty.isReadable": (),
-    "PySide2.QtCore.QMetaProperty.isResettable": (),
-    "PySide2.QtCore.QMetaProperty.isScriptable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isStored": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isUser": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isValid": (),
-    "PySide2.QtCore.QMetaProperty.isWritable": (),
-    "PySide2.QtCore.QMetaProperty.name": (),
-    "PySide2.QtCore.QMetaProperty.notifySignal": (),
-    "PySide2.QtCore.QMetaProperty.notifySignalIndex": (),
-    "PySide2.QtCore.QMetaProperty.propertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.read": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.readOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.relativePropertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.reset": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.resetOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.revision": (),
-    "PySide2.QtCore.QMetaProperty.type": (),
-    "PySide2.QtCore.QMetaProperty.typeName": (),
-    "PySide2.QtCore.QMetaProperty.userType": (),
-    "PySide2.QtCore.QMetaProperty.write": ('PySide2.QtCore.QObject', 'typing.Any'),
-    "PySide2.QtCore.QMetaProperty.writeOnGadget": ('int', 'typing.Any'),
-# class PySide2.QtCore.QMimeData:
-    "PySide2.QtCore.QMimeData.__init__": (),
-    "PySide2.QtCore.QMimeData.clear": (),
-    "PySide2.QtCore.QMimeData.colorData": (),
-    "PySide2.QtCore.QMimeData.data": ('str',),
-    "PySide2.QtCore.QMimeData.formats": (),
-    "PySide2.QtCore.QMimeData.hasColor": (),
-    "PySide2.QtCore.QMimeData.hasFormat": ('str',),
-    "PySide2.QtCore.QMimeData.hasHtml": (),
-    "PySide2.QtCore.QMimeData.hasImage": (),
-    "PySide2.QtCore.QMimeData.hasText": (),
-    "PySide2.QtCore.QMimeData.hasUrls": (),
-    "PySide2.QtCore.QMimeData.html": (),
-    "PySide2.QtCore.QMimeData.imageData": (),
-    "PySide2.QtCore.QMimeData.removeFormat": ('str',),
-    "PySide2.QtCore.QMimeData.retrieveData": ('str', 'type'),
-    "PySide2.QtCore.QMimeData.setColorData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setData": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMimeData.setHtml": ('str',),
-    "PySide2.QtCore.QMimeData.setImageData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setText": ('str',),
-    "PySide2.QtCore.QMimeData.setUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtCore.QMimeData.text": (),
-    "PySide2.QtCore.QMimeData.urls": (),
-# class PySide2.QtCore.QMimeDatabase:
-# class PySide2.QtCore.QMimeDatabase.MatchMode:
-    "PySide2.QtCore.QMimeDatabase.__init__": (),
-    "PySide2.QtCore.QMimeDatabase.allMimeTypes": (),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFile": [('PySide2.QtCore.QFileInfo', 'PySide2.QtCore.QMimeDatabase.MatchMode'), ('str', 'PySide2.QtCore.QMimeDatabase.MatchMode')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFileNameAndData": [('str', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QIODevice')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypesForFileName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.suffixForFileName": ('str',),
-# class PySide2.QtCore.QMimeType:
-    "PySide2.QtCore.QMimeType.__init__": [(), ('PySide2.QtCore.QMimeType',)],
-    "PySide2.QtCore.QMimeType.__copy__": (),
-    "PySide2.QtCore.QMimeType.aliases": (),
-    "PySide2.QtCore.QMimeType.allAncestors": (),
-    "PySide2.QtCore.QMimeType.comment": (),
-    "PySide2.QtCore.QMimeType.filterString": (),
-    "PySide2.QtCore.QMimeType.genericIconName": (),
-    "PySide2.QtCore.QMimeType.globPatterns": (),
-    "PySide2.QtCore.QMimeType.iconName": (),
-    "PySide2.QtCore.QMimeType.inherits": ('str',),
-    "PySide2.QtCore.QMimeType.isDefault": (),
-    "PySide2.QtCore.QMimeType.isValid": (),
-    "PySide2.QtCore.QMimeType.name": (),
-    "PySide2.QtCore.QMimeType.parentMimeTypes": (),
-    "PySide2.QtCore.QMimeType.preferredSuffix": (),
-    "PySide2.QtCore.QMimeType.suffixes": (),
-    "PySide2.QtCore.QMimeType.swap": ('PySide2.QtCore.QMimeType',),
-# class PySide2.QtCore.QModelIndex:
-    "PySide2.QtCore.QModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QModelIndex.__copy__": (),
-    "PySide2.QtCore.QModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.column": (),
-    "PySide2.QtCore.QModelIndex.data": ('int',),
-    "PySide2.QtCore.QModelIndex.flags": (),
-    "PySide2.QtCore.QModelIndex.internalId": (),
-    "PySide2.QtCore.QModelIndex.internalPointer": (),
-    "PySide2.QtCore.QModelIndex.isValid": (),
-    "PySide2.QtCore.QModelIndex.model": (),
-    "PySide2.QtCore.QModelIndex.parent": (),
-    "PySide2.QtCore.QModelIndex.row": (),
-    "PySide2.QtCore.QModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.siblingAtColumn": ('int',),
-    "PySide2.QtCore.QModelIndex.siblingAtRow": ('int',),
-# class PySide2.QtCore.QMutex:
-# class PySide2.QtCore.QMutex.RecursionMode:
-    "PySide2.QtCore.QMutex.__init__": [(), ('PySide2.QtCore.QMutex.RecursionMode',)],
-    "PySide2.QtCore.QMutex.isRecursive": (),
-    "PySide2.QtCore.QMutex.lock": (),
-    "PySide2.QtCore.QMutex.tryLock": [(), ('int',)],
-    "PySide2.QtCore.QMutex.try_lock": (),
-    "PySide2.QtCore.QMutex.unlock": (),
-# class PySide2.QtCore.QMutexLocker:
-    "PySide2.QtCore.QMutexLocker.__init__": [('PySide2.QtCore.QBasicMutex',), ('PySide2.QtCore.QRecursiveMutex',)],
-    "PySide2.QtCore.QMutexLocker.__enter__": (),
-    "PySide2.QtCore.QMutexLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QMutexLocker.mutex": (),
-    "PySide2.QtCore.QMutexLocker.relock": (),
-    "PySide2.QtCore.QMutexLocker.unlock": (),
-# class PySide2.QtCore.QObject:
-    "PySide2.QtCore.QObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.blockSignals": ('bool',),
-    "PySide2.QtCore.QObject.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtCore.QObject.children": (),
-    "PySide2.QtCore.QObject.connect": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType')],
-    "PySide2.QtCore.QObject.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.customEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.deleteLater": (),
-    "PySide2.QtCore.QObject.disconnect": [('PySide2.QtCore.QMetaObject.Connection',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable'), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'typing.Callable')],
-    "PySide2.QtCore.QObject.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.dumpObjectInfo": (),
-    "PySide2.QtCore.QObject.dumpObjectTree": (),
-    "PySide2.QtCore.QObject.dynamicPropertyNames": (),
-    "PySide2.QtCore.QObject.emit": ('str', 'None'),
-    "PySide2.QtCore.QObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QObject.findChild": ('type', 'str'),
-    "PySide2.QtCore.QObject.findChildren": [('type', 'PySide2.QtCore.QRegExp'), ('type', 'str')],
-    "PySide2.QtCore.QObject.inherits": ('str',),
-    "PySide2.QtCore.QObject.installEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.isSignalConnected": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.isWidgetType": (),
-    "PySide2.QtCore.QObject.isWindowType": (),
-    "PySide2.QtCore.QObject.killTimer": ('int',),
-    "PySide2.QtCore.QObject.metaObject": (),
-    "PySide2.QtCore.QObject.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QObject.objectName": (),
-    "PySide2.QtCore.QObject.parent": (),
-    "PySide2.QtCore.QObject.property": ('str',),
-    "PySide2.QtCore.QObject.receivers": ('str',),
-    "PySide2.QtCore.QObject.registerUserData": (),
-    "PySide2.QtCore.QObject.removeEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.sender": (),
-    "PySide2.QtCore.QObject.senderSignalIndex": (),
-    "PySide2.QtCore.QObject.setObjectName": ('str',),
-    "PySide2.QtCore.QObject.setParent": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtCore.QObject.signalsBlocked": (),
-    "PySide2.QtCore.QObject.startTimer": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QObject.thread": (),
-    "PySide2.QtCore.QObject.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QObject.tr": ('str', 'str', 'int'),
-# class PySide2.QtCore.QOperatingSystemVersion:
-# class PySide2.QtCore.QOperatingSystemVersion.OSType:
-    "PySide2.QtCore.QOperatingSystemVersion.__init__": [('PySide2.QtCore.QOperatingSystemVersion',), ('PySide2.QtCore.QOperatingSystemVersion.OSType', 'int', 'int', 'int')],
-    "PySide2.QtCore.QOperatingSystemVersion.__copy__": (),
-    "PySide2.QtCore.QOperatingSystemVersion.current": (),
-    "PySide2.QtCore.QOperatingSystemVersion.currentType": (),
-    "PySide2.QtCore.QOperatingSystemVersion.majorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.microVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.minorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.name": (),
-    "PySide2.QtCore.QOperatingSystemVersion.segmentCount": (),
-    "PySide2.QtCore.QOperatingSystemVersion.type": (),
-# class PySide2.QtCore.QParallelAnimationGroup:
-    "PySide2.QtCore.QParallelAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QParallelAnimationGroup.duration": (),
-    "PySide2.QtCore.QParallelAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QPauseAnimation:
-    "PySide2.QtCore.QPauseAnimation.__init__": [('PySide2.QtCore.QObject',), ('int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPauseAnimation.duration": (),
-    "PySide2.QtCore.QPauseAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPauseAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QPauseAnimation.updateCurrentTime": ('int',),
-# class PySide2.QtCore.QPersistentModelIndex:
-    "PySide2.QtCore.QPersistentModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QPersistentModelIndex',)],
-    "PySide2.QtCore.QPersistentModelIndex.__copy__": (),
-    "PySide2.QtCore.QPersistentModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.column": (),
-    "PySide2.QtCore.QPersistentModelIndex.data": ('int',),
-    "PySide2.QtCore.QPersistentModelIndex.flags": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalId": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalPointer": (),
-    "PySide2.QtCore.QPersistentModelIndex.isValid": (),
-    "PySide2.QtCore.QPersistentModelIndex.model": (),
-    "PySide2.QtCore.QPersistentModelIndex.parent": (),
-    "PySide2.QtCore.QPersistentModelIndex.row": (),
-    "PySide2.QtCore.QPersistentModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.swap": ('PySide2.QtCore.QPersistentModelIndex',),
-# class PySide2.QtCore.QPluginLoader:
-    "PySide2.QtCore.QPluginLoader.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPluginLoader.errorString": (),
-    "PySide2.QtCore.QPluginLoader.fileName": (),
-    "PySide2.QtCore.QPluginLoader.instance": (),
-    "PySide2.QtCore.QPluginLoader.isLoaded": (),
-    "PySide2.QtCore.QPluginLoader.load": (),
-    "PySide2.QtCore.QPluginLoader.metaData": (),
-    "PySide2.QtCore.QPluginLoader.setFileName": ('str',),
-    "PySide2.QtCore.QPluginLoader.staticInstances": (),
-    "PySide2.QtCore.QPluginLoader.unload": (),
-# class PySide2.QtCore.QPoint:
-    "PySide2.QtCore.QPoint.__init__": [(), ('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QPoint.__add__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__copy__": (),
-    "PySide2.QtCore.QPoint.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__isub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__neg__": (),
-    "PySide2.QtCore.QPoint.__pos__": (),
-    "PySide2.QtCore.QPoint.__reduce__": (),
-    "PySide2.QtCore.QPoint.__repr__": (),
-    "PySide2.QtCore.QPoint.__sub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.dotProduct": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QPoint.isNull": (),
-    "PySide2.QtCore.QPoint.manhattanLength": (),
-    "PySide2.QtCore.QPoint.setX": ('int',),
-    "PySide2.QtCore.QPoint.setY": ('int',),
-    "PySide2.QtCore.QPoint.toTuple": (),
-    "PySide2.QtCore.QPoint.transposed": (),
-    "PySide2.QtCore.QPoint.x": (),
-    "PySide2.QtCore.QPoint.y": (),
-# class PySide2.QtCore.QPointF:
-    "PySide2.QtCore.QPointF.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QPointF.__add__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__copy__": (),
-    "PySide2.QtCore.QPointF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__imul__": ('float',),
-    "PySide2.QtCore.QPointF.__isub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__mul__": ('float',),
-    "PySide2.QtCore.QPointF.__neg__": (),
-    "PySide2.QtCore.QPointF.__pos__": (),
-    "PySide2.QtCore.QPointF.__reduce__": (),
-    "PySide2.QtCore.QPointF.__repr__": (),
-    "PySide2.QtCore.QPointF.__sub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.dotProduct": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QPointF.isNull": (),
-    "PySide2.QtCore.QPointF.manhattanLength": (),
-    "PySide2.QtCore.QPointF.setX": ('float',),
-    "PySide2.QtCore.QPointF.setY": ('float',),
-    "PySide2.QtCore.QPointF.toPoint": (),
-    "PySide2.QtCore.QPointF.toTuple": (),
-    "PySide2.QtCore.QPointF.transposed": (),
-    "PySide2.QtCore.QPointF.x": (),
-    "PySide2.QtCore.QPointF.y": (),
-# class PySide2.QtCore.QProcess:
-# class PySide2.QtCore.QProcess.ExitStatus:
-# class PySide2.QtCore.QProcess.InputChannelMode:
-# class PySide2.QtCore.QProcess.ProcessChannel:
-# class PySide2.QtCore.QProcess.ProcessChannelMode:
-# class PySide2.QtCore.QProcess.ProcessError:
-# class PySide2.QtCore.QProcess.ProcessState:
-    "PySide2.QtCore.QProcess.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QProcess.arguments": (),
-    "PySide2.QtCore.QProcess.atEnd": (),
-    "PySide2.QtCore.QProcess.bytesAvailable": (),
-    "PySide2.QtCore.QProcess.bytesToWrite": (),
-    "PySide2.QtCore.QProcess.canReadLine": (),
-    "PySide2.QtCore.QProcess.close": (),
-    "PySide2.QtCore.QProcess.closeReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.closeWriteChannel": (),
-    "PySide2.QtCore.QProcess.environment": (),
-    "PySide2.QtCore.QProcess.error": (),
-    "PySide2.QtCore.QProcess.execute": [('str',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtCore.QProcess.exitCode": (),
-    "PySide2.QtCore.QProcess.exitStatus": (),
-    "PySide2.QtCore.QProcess.inputChannelMode": (),
-    "PySide2.QtCore.QProcess.isSequential": (),
-    "PySide2.QtCore.QProcess.kill": (),
-    "PySide2.QtCore.QProcess.nullDevice": (),
-    "PySide2.QtCore.QProcess.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QProcess.pid": (),
-    "PySide2.QtCore.QProcess.processChannelMode": (),
-    "PySide2.QtCore.QProcess.processEnvironment": (),
-    "PySide2.QtCore.QProcess.processId": (),
-    "PySide2.QtCore.QProcess.program": (),
-    "PySide2.QtCore.QProcess.readAllStandardError": (),
-    "PySide2.QtCore.QProcess.readAllStandardOutput": (),
-    "PySide2.QtCore.QProcess.readChannel": (),
-    "PySide2.QtCore.QProcess.readData": ('str', 'int'),
-    "PySide2.QtCore.QProcess.setArguments": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setEnvironment": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setInputChannelMode": ('PySide2.QtCore.QProcess.InputChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessChannelMode": ('PySide2.QtCore.QProcess.ProcessChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessEnvironment": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcess.setProcessState": ('PySide2.QtCore.QProcess.ProcessState',),
-    "PySide2.QtCore.QProcess.setProgram": ('str',),
-    "PySide2.QtCore.QProcess.setReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.setStandardErrorFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardInputFile": ('str',),
-    "PySide2.QtCore.QProcess.setStandardOutputFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardOutputProcess": ('PySide2.QtCore.QProcess',),
-    "PySide2.QtCore.QProcess.setWorkingDirectory": ('str',),
-    "PySide2.QtCore.QProcess.setupChildProcess": (),
-    "PySide2.QtCore.QProcess.start": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtCore.QProcess.startDetached": [(), ('str',), ('str', 'typing.Sequence[str]'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QProcess.state": (),
-    "PySide2.QtCore.QProcess.systemEnvironment": (),
-    "PySide2.QtCore.QProcess.terminate": (),
-    "PySide2.QtCore.QProcess.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QProcess.waitForFinished": ('int',),
-    "PySide2.QtCore.QProcess.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QProcess.waitForStarted": ('int',),
-    "PySide2.QtCore.QProcess.workingDirectory": (),
-    "PySide2.QtCore.QProcess.writeData": ('str', 'int'),
-# class PySide2.QtCore.QProcessEnvironment:
-    "PySide2.QtCore.QProcessEnvironment.__init__": [(), ('PySide2.QtCore.QProcessEnvironment',)],
-    "PySide2.QtCore.QProcessEnvironment.__copy__": (),
-    "PySide2.QtCore.QProcessEnvironment.clear": (),
-    "PySide2.QtCore.QProcessEnvironment.contains": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.insert": [('PySide2.QtCore.QProcessEnvironment',), ('str', 'str')],
-    "PySide2.QtCore.QProcessEnvironment.isEmpty": (),
-    "PySide2.QtCore.QProcessEnvironment.keys": (),
-    "PySide2.QtCore.QProcessEnvironment.remove": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.swap": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcessEnvironment.systemEnvironment": (),
-    "PySide2.QtCore.QProcessEnvironment.toStringList": (),
-    "PySide2.QtCore.QProcessEnvironment.value": ('str', 'str'),
-# class PySide2.QtCore.QPropertyAnimation:
-    "PySide2.QtCore.QPropertyAnimation.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPropertyAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPropertyAnimation.propertyName": (),
-    "PySide2.QtCore.QPropertyAnimation.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QPropertyAnimation.setTargetObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QPropertyAnimation.targetObject": (),
-    "PySide2.QtCore.QPropertyAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QPropertyAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QRandomGenerator:
-    "PySide2.QtCore.QRandomGenerator.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.bounded": [('float',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator.generate": (),
-    "PySide2.QtCore.QRandomGenerator.generate64": (),
-    "PySide2.QtCore.QRandomGenerator.generateDouble": (),
-    "PySide2.QtCore.QRandomGenerator.global_": (),
-    "PySide2.QtCore.QRandomGenerator.max": (),
-    "PySide2.QtCore.QRandomGenerator.min": (),
-    "PySide2.QtCore.QRandomGenerator.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator.seed": ('int',),
-    "PySide2.QtCore.QRandomGenerator.system": (),
-# class PySide2.QtCore.QRandomGenerator64:
-    "PySide2.QtCore.QRandomGenerator64.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator64.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator64.generate": (),
-    "PySide2.QtCore.QRandomGenerator64.global_": (),
-    "PySide2.QtCore.QRandomGenerator64.max": (),
-    "PySide2.QtCore.QRandomGenerator64.min": (),
-    "PySide2.QtCore.QRandomGenerator64.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator64.system": (),
-# class PySide2.QtCore.QReadLocker:
-    "PySide2.QtCore.QReadLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QReadLocker.__enter__": (),
-    "PySide2.QtCore.QReadLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QReadLocker.readWriteLock": (),
-    "PySide2.QtCore.QReadLocker.relock": (),
-    "PySide2.QtCore.QReadLocker.unlock": (),
-# class PySide2.QtCore.QReadWriteLock:
-# class PySide2.QtCore.QReadWriteLock.RecursionMode:
-    "PySide2.QtCore.QReadWriteLock.__init__": ('PySide2.QtCore.QReadWriteLock.RecursionMode',),
-    "PySide2.QtCore.QReadWriteLock.lockForRead": (),
-    "PySide2.QtCore.QReadWriteLock.lockForWrite": (),
-    "PySide2.QtCore.QReadWriteLock.tryLockForRead": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.tryLockForWrite": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.unlock": (),
-# class PySide2.QtCore.QRect:
-    "PySide2.QtCore.QRect.__init__": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QSize'), ('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QRect.__add__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__and__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__copy__": (),
-    "PySide2.QtCore.QRect.__iadd__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__iand__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__ior__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__isub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__or__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__reduce__": (),
-    "PySide2.QtCore.QRect.__repr__": (),
-    "PySide2.QtCore.QRect.__sub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.adjust": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.adjusted": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.bottom": (),
-    "PySide2.QtCore.QRect.bottomLeft": (),
-    "PySide2.QtCore.QRect.bottomRight": (),
-    "PySide2.QtCore.QRect.center": (),
-    "PySide2.QtCore.QRect.contains": [('PySide2.QtCore.QPoint', 'bool'), ('PySide2.QtCore.QRect', 'bool'), ('int', 'int'), ('int', 'int', 'bool')],
-    "PySide2.QtCore.QRect.getCoords": (),
-    "PySide2.QtCore.QRect.getRect": (),
-    "PySide2.QtCore.QRect.height": (),
-    "PySide2.QtCore.QRect.intersected": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.intersects": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.isEmpty": (),
-    "PySide2.QtCore.QRect.isNull": (),
-    "PySide2.QtCore.QRect.isValid": (),
-    "PySide2.QtCore.QRect.left": (),
-    "PySide2.QtCore.QRect.marginsAdded": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.marginsRemoved": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.moveBottom": ('int',),
-    "PySide2.QtCore.QRect.moveBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveCenter": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveLeft": ('int',),
-    "PySide2.QtCore.QRect.moveRight": ('int',),
-    "PySide2.QtCore.QRect.moveTo": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.moveTop": ('int',),
-    "PySide2.QtCore.QRect.moveTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.normalized": (),
-    "PySide2.QtCore.QRect.right": (),
-    "PySide2.QtCore.QRect.setBottom": ('int',),
-    "PySide2.QtCore.QRect.setBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setCoords": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setHeight": ('int',),
-    "PySide2.QtCore.QRect.setLeft": ('int',),
-    "PySide2.QtCore.QRect.setRect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setRight": ('int',),
-    "PySide2.QtCore.QRect.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QRect.setTop": ('int',),
-    "PySide2.QtCore.QRect.setTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setWidth": ('int',),
-    "PySide2.QtCore.QRect.setX": ('int',),
-    "PySide2.QtCore.QRect.setY": ('int',),
-    "PySide2.QtCore.QRect.size": (),
-    "PySide2.QtCore.QRect.top": (),
-    "PySide2.QtCore.QRect.topLeft": (),
-    "PySide2.QtCore.QRect.topRight": (),
-    "PySide2.QtCore.QRect.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.transposed": (),
-    "PySide2.QtCore.QRect.united": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.width": (),
-    "PySide2.QtCore.QRect.x": (),
-    "PySide2.QtCore.QRect.y": (),
-# class PySide2.QtCore.QRectF:
-    "PySide2.QtCore.QRectF.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QSizeF'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QRectF.__add__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__and__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__copy__": (),
-    "PySide2.QtCore.QRectF.__iadd__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__iand__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__ior__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__isub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__or__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__reduce__": (),
-    "PySide2.QtCore.QRectF.__repr__": (),
-    "PySide2.QtCore.QRectF.__sub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.adjust": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.adjusted": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.bottom": (),
-    "PySide2.QtCore.QRectF.bottomLeft": (),
-    "PySide2.QtCore.QRectF.bottomRight": (),
-    "PySide2.QtCore.QRectF.center": (),
-    "PySide2.QtCore.QRectF.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.getCoords": (),
-    "PySide2.QtCore.QRectF.getRect": (),
-    "PySide2.QtCore.QRectF.height": (),
-    "PySide2.QtCore.QRectF.intersected": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.intersects": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.isEmpty": (),
-    "PySide2.QtCore.QRectF.isNull": (),
-    "PySide2.QtCore.QRectF.isValid": (),
-    "PySide2.QtCore.QRectF.left": (),
-    "PySide2.QtCore.QRectF.marginsAdded": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.marginsRemoved": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.moveBottom": ('float',),
-    "PySide2.QtCore.QRectF.moveBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveCenter": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveLeft": ('float',),
-    "PySide2.QtCore.QRectF.moveRight": ('float',),
-    "PySide2.QtCore.QRectF.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.moveTop": ('float',),
-    "PySide2.QtCore.QRectF.moveTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.normalized": (),
-    "PySide2.QtCore.QRectF.right": (),
-    "PySide2.QtCore.QRectF.setBottom": ('float',),
-    "PySide2.QtCore.QRectF.setBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setCoords": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setHeight": ('float',),
-    "PySide2.QtCore.QRectF.setLeft": ('float',),
-    "PySide2.QtCore.QRectF.setRect": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setRight": ('float',),
-    "PySide2.QtCore.QRectF.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QRectF.setTop": ('float',),
-    "PySide2.QtCore.QRectF.setTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setWidth": ('float',),
-    "PySide2.QtCore.QRectF.setX": ('float',),
-    "PySide2.QtCore.QRectF.setY": ('float',),
-    "PySide2.QtCore.QRectF.size": (),
-    "PySide2.QtCore.QRectF.toAlignedRect": (),
-    "PySide2.QtCore.QRectF.toRect": (),
-    "PySide2.QtCore.QRectF.top": (),
-    "PySide2.QtCore.QRectF.topLeft": (),
-    "PySide2.QtCore.QRectF.topRight": (),
-    "PySide2.QtCore.QRectF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.transposed": (),
-    "PySide2.QtCore.QRectF.united": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.width": (),
-    "PySide2.QtCore.QRectF.x": (),
-    "PySide2.QtCore.QRectF.y": (),
-# class PySide2.QtCore.QRecursiveMutex:
-    "PySide2.QtCore.QRecursiveMutex.__init__": (),
-# class PySide2.QtCore.QRegExp:
-# class PySide2.QtCore.QRegExp.CaretMode:
-# class PySide2.QtCore.QRegExp.PatternSyntax:
-    "PySide2.QtCore.QRegExp.__init__": [(), ('PySide2.QtCore.QRegExp',), ('str', 'PySide2.QtCore.Qt.CaseSensitivity', 'PySide2.QtCore.QRegExp.PatternSyntax')],
-    "PySide2.QtCore.QRegExp.__copy__": (),
-    "PySide2.QtCore.QRegExp.__reduce__": (),
-    "PySide2.QtCore.QRegExp.__repr__": (),
-    "PySide2.QtCore.QRegExp.cap": ('int',),
-    "PySide2.QtCore.QRegExp.captureCount": (),
-    "PySide2.QtCore.QRegExp.capturedTexts": (),
-    "PySide2.QtCore.QRegExp.caseSensitivity": (),
-    "PySide2.QtCore.QRegExp.errorString": (),
-    "PySide2.QtCore.QRegExp.escape": ('str',),
-    "PySide2.QtCore.QRegExp.exactMatch": ('str',),
-    "PySide2.QtCore.QRegExp.indexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.isEmpty": (),
-    "PySide2.QtCore.QRegExp.isMinimal": (),
-    "PySide2.QtCore.QRegExp.isValid": (),
-    "PySide2.QtCore.QRegExp.lastIndexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.matchedLength": (),
-    "PySide2.QtCore.QRegExp.pattern": (),
-    "PySide2.QtCore.QRegExp.patternSyntax": (),
-    "PySide2.QtCore.QRegExp.pos": ('int',),
-    "PySide2.QtCore.QRegExp.replace": ('str', 'str'),
-    "PySide2.QtCore.QRegExp.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QRegExp.setMinimal": ('bool',),
-    "PySide2.QtCore.QRegExp.setPattern": ('str',),
-    "PySide2.QtCore.QRegExp.setPatternSyntax": ('PySide2.QtCore.QRegExp.PatternSyntax',),
-    "PySide2.QtCore.QRegExp.swap": ('PySide2.QtCore.QRegExp',),
-# class PySide2.QtCore.QRegularExpression:
-# class PySide2.QtCore.QRegularExpression.MatchOption:
-# class PySide2.QtCore.QRegularExpression.MatchOptions:
-# class PySide2.QtCore.QRegularExpression.MatchType:
-# class PySide2.QtCore.QRegularExpression.PatternOption:
-# class PySide2.QtCore.QRegularExpression.PatternOptions:
-    "PySide2.QtCore.QRegularExpression.__init__": [(), ('PySide2.QtCore.QRegularExpression',), ('str', 'PySide2.QtCore.QRegularExpression.PatternOptions')],
-    "PySide2.QtCore.QRegularExpression.__copy__": (),
-    "PySide2.QtCore.QRegularExpression.anchoredPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.captureCount": (),
-    "PySide2.QtCore.QRegularExpression.errorString": (),
-    "PySide2.QtCore.QRegularExpression.escape": ('str',),
-    "PySide2.QtCore.QRegularExpression.globalMatch": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.isValid": (),
-    "PySide2.QtCore.QRegularExpression.match": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.namedCaptureGroups": (),
-    "PySide2.QtCore.QRegularExpression.optimize": (),
-    "PySide2.QtCore.QRegularExpression.pattern": (),
-    "PySide2.QtCore.QRegularExpression.patternErrorOffset": (),
-    "PySide2.QtCore.QRegularExpression.patternOptions": (),
-    "PySide2.QtCore.QRegularExpression.setPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.setPatternOptions": ('PySide2.QtCore.QRegularExpression.PatternOptions',),
-    "PySide2.QtCore.QRegularExpression.swap": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QRegularExpression.wildcardToRegularExpression": ('str',),
-# class PySide2.QtCore.QRegularExpressionMatch:
-    "PySide2.QtCore.QRegularExpressionMatch.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatch',)],
-    "PySide2.QtCore.QRegularExpressionMatch.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatch.captured": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedEnd": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedLength": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedRef": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedStart": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedTexts": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasPartialMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatch.lastCapturedIndex": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatch.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatch.swap": ('PySide2.QtCore.QRegularExpressionMatch',),
-# class PySide2.QtCore.QRegularExpressionMatchIterator:
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatchIterator',)],
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.hasNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.peekNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.swap": ('PySide2.QtCore.QRegularExpressionMatchIterator',),
-# class PySide2.QtCore.QResource:
-# class PySide2.QtCore.QResource.Compression:
-    "PySide2.QtCore.QResource.__init__": ('str', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtCore.QResource.absoluteFilePath": (),
-    "PySide2.QtCore.QResource.addSearchPath": ('str',),
-    "PySide2.QtCore.QResource.children": (),
-    "PySide2.QtCore.QResource.compressionAlgorithm": (),
-    "PySide2.QtCore.QResource.data": (),
-    "PySide2.QtCore.QResource.fileName": (),
-    "PySide2.QtCore.QResource.isCompressed": (),
-    "PySide2.QtCore.QResource.isDir": (),
-    "PySide2.QtCore.QResource.isFile": (),
-    "PySide2.QtCore.QResource.isValid": (),
-    "PySide2.QtCore.QResource.lastModified": (),
-    "PySide2.QtCore.QResource.locale": (),
-    "PySide2.QtCore.QResource.registerResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.registerResourceData": ('str', 'str'),
-    "PySide2.QtCore.QResource.searchPaths": (),
-    "PySide2.QtCore.QResource.setFileName": ('str',),
-    "PySide2.QtCore.QResource.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QResource.size": (),
-    "PySide2.QtCore.QResource.unregisterResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.unregisterResourceData": ('str', 'str'),
-# class PySide2.QtCore.QRunnable:
-    "PySide2.QtCore.QRunnable.__init__": (),
-    "PySide2.QtCore.QRunnable.autoDelete": (),
-    "PySide2.QtCore.QRunnable.run": (),
-    "PySide2.QtCore.QRunnable.setAutoDelete": ('bool',),
-# class PySide2.QtCore.QSaveFile:
-    "PySide2.QtCore.QSaveFile.__init__": [('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSaveFile.cancelWriting": (),
-    "PySide2.QtCore.QSaveFile.close": (),
-    "PySide2.QtCore.QSaveFile.commit": (),
-    "PySide2.QtCore.QSaveFile.directWriteFallback": (),
-    "PySide2.QtCore.QSaveFile.fileName": (),
-    "PySide2.QtCore.QSaveFile.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QSaveFile.setDirectWriteFallback": ('bool',),
-    "PySide2.QtCore.QSaveFile.setFileName": ('str',),
-    "PySide2.QtCore.QSaveFile.writeData": ('str', 'int'),
-# class PySide2.QtCore.QSemaphore:
-    "PySide2.QtCore.QSemaphore.__init__": ('int',),
-    "PySide2.QtCore.QSemaphore.acquire": ('int',),
-    "PySide2.QtCore.QSemaphore.available": (),
-    "PySide2.QtCore.QSemaphore.release": ('int',),
-    "PySide2.QtCore.QSemaphore.tryAcquire": [('int',), ('int', 'int')],
-# class PySide2.QtCore.QSemaphoreReleaser:
-    "PySide2.QtCore.QSemaphoreReleaser.__init__": [(), ('PySide2.QtCore.QSemaphore', 'int')],
-    "PySide2.QtCore.QSemaphoreReleaser.cancel": (),
-    "PySide2.QtCore.QSemaphoreReleaser.semaphore": (),
-    "PySide2.QtCore.QSemaphoreReleaser.swap": ('PySide2.QtCore.QSemaphoreReleaser',),
-# class PySide2.QtCore.QSequentialAnimationGroup:
-    "PySide2.QtCore.QSequentialAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSequentialAnimationGroup.addPause": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.currentAnimation": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.duration": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSequentialAnimationGroup.insertPause": ('int', 'int'),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QSettings:
-# class PySide2.QtCore.QSettings.Format:
-# class PySide2.QtCore.QSettings.Scope:
-# class PySide2.QtCore.QSettings.Status:
-    "PySide2.QtCore.QSettings.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QObject'), ('str', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSettings.allKeys": (),
-    "PySide2.QtCore.QSettings.applicationName": (),
-    "PySide2.QtCore.QSettings.beginGroup": ('str',),
-    "PySide2.QtCore.QSettings.beginReadArray": ('str',),
-    "PySide2.QtCore.QSettings.beginWriteArray": ('str', 'int'),
-    "PySide2.QtCore.QSettings.childGroups": (),
-    "PySide2.QtCore.QSettings.childKeys": (),
-    "PySide2.QtCore.QSettings.clear": (),
-    "PySide2.QtCore.QSettings.contains": ('str',),
-    "PySide2.QtCore.QSettings.defaultFormat": (),
-    "PySide2.QtCore.QSettings.endArray": (),
-    "PySide2.QtCore.QSettings.endGroup": (),
-    "PySide2.QtCore.QSettings.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSettings.fallbacksEnabled": (),
-    "PySide2.QtCore.QSettings.fileName": (),
-    "PySide2.QtCore.QSettings.format": (),
-    "PySide2.QtCore.QSettings.group": (),
-    "PySide2.QtCore.QSettings.iniCodec": (),
-    "PySide2.QtCore.QSettings.isAtomicSyncRequired": (),
-    "PySide2.QtCore.QSettings.isWritable": (),
-    "PySide2.QtCore.QSettings.organizationName": (),
-    "PySide2.QtCore.QSettings.remove": ('str',),
-    "PySide2.QtCore.QSettings.scope": (),
-    "PySide2.QtCore.QSettings.setArrayIndex": ('int',),
-    "PySide2.QtCore.QSettings.setAtomicSyncRequired": ('bool',),
-    "PySide2.QtCore.QSettings.setDefaultFormat": ('PySide2.QtCore.QSettings.Format',),
-    "PySide2.QtCore.QSettings.setFallbacksEnabled": ('bool',),
-    "PySide2.QtCore.QSettings.setIniCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QSettings.setPath": ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str'),
-    "PySide2.QtCore.QSettings.setValue": ('str', 'typing.Any'),
-    "PySide2.QtCore.QSettings.status": (),
-    "PySide2.QtCore.QSettings.sync": (),
-    "PySide2.QtCore.QSettings.value": ('str', 'typing.Any', 'object'),
-# class PySide2.QtCore.QSignalBlocker:
-    "PySide2.QtCore.QSignalBlocker.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalBlocker.reblock": (),
-    "PySide2.QtCore.QSignalBlocker.unblock": (),
-# class PySide2.QtCore.QSignalMapper:
-    "PySide2.QtCore.QSignalMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.map": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QSignalMapper.mapping": [('PySide2.QtCore.QObject',), ('int',), ('str',)],
-    "PySide2.QtCore.QSignalMapper.removeMappings": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.setMapping": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-# class PySide2.QtCore.QSignalTransition:
-    "PySide2.QtCore.QSignalTransition.__init__": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',), ('object', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QSignalTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.senderObject": (),
-    "PySide2.QtCore.QSignalTransition.setSenderObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalTransition.setSignal": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QSignalTransition.signal": (),
-# class PySide2.QtCore.QSize:
-    "PySide2.QtCore.QSize.__init__": [(), ('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtCore.QSize.__add__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__copy__": (),
-    "PySide2.QtCore.QSize.__iadd__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__imul__": ('float',),
-    "PySide2.QtCore.QSize.__isub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__mul__": ('float',),
-    "PySide2.QtCore.QSize.__reduce__": (),
-    "PySide2.QtCore.QSize.__repr__": (),
-    "PySide2.QtCore.QSize.__sub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.boundedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.expandedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.grownBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.height": (),
-    "PySide2.QtCore.QSize.isEmpty": (),
-    "PySide2.QtCore.QSize.isNull": (),
-    "PySide2.QtCore.QSize.isValid": (),
-    "PySide2.QtCore.QSize.scale": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.setHeight": ('int',),
-    "PySide2.QtCore.QSize.setWidth": ('int',),
-    "PySide2.QtCore.QSize.shrunkBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.toTuple": (),
-    "PySide2.QtCore.QSize.transpose": (),
-    "PySide2.QtCore.QSize.transposed": (),
-    "PySide2.QtCore.QSize.width": (),
-# class PySide2.QtCore.QSizeF:
-    "PySide2.QtCore.QSizeF.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtCore.QSizeF.__add__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__copy__": (),
-    "PySide2.QtCore.QSizeF.__iadd__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__imul__": ('float',),
-    "PySide2.QtCore.QSizeF.__isub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__mul__": ('float',),
-    "PySide2.QtCore.QSizeF.__reduce__": (),
-    "PySide2.QtCore.QSizeF.__repr__": (),
-    "PySide2.QtCore.QSizeF.__sub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.boundedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.expandedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.grownBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.height": (),
-    "PySide2.QtCore.QSizeF.isEmpty": (),
-    "PySide2.QtCore.QSizeF.isNull": (),
-    "PySide2.QtCore.QSizeF.isValid": (),
-    "PySide2.QtCore.QSizeF.scale": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.scaled": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.setHeight": ('float',),
-    "PySide2.QtCore.QSizeF.setWidth": ('float',),
-    "PySide2.QtCore.QSizeF.shrunkBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.toSize": (),
-    "PySide2.QtCore.QSizeF.toTuple": (),
-    "PySide2.QtCore.QSizeF.transpose": (),
-    "PySide2.QtCore.QSizeF.transposed": (),
-    "PySide2.QtCore.QSizeF.width": (),
-# class PySide2.QtCore.QSocketNotifier:
-# class PySide2.QtCore.QSocketNotifier.Type:
-    "PySide2.QtCore.QSocketNotifier.__init__": [('int', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject'), ('object', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSocketNotifier.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSocketNotifier.isEnabled": (),
-    "PySide2.QtCore.QSocketNotifier.setEnabled": ('bool',),
-    "PySide2.QtCore.QSocketNotifier.socket": (),
-    "PySide2.QtCore.QSocketNotifier.type": (),
-# class PySide2.QtCore.QSortFilterProxyModel:
-    "PySide2.QtCore.QSortFilterProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSortFilterProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.dynamicSortFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterKeyColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegExp": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegularExpression": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidate": (),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidateFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isRecursiveFilteringEnabled": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isSortLocaleAware": (),
-    "PySide2.QtCore.QSortFilterProxyModel.lessThan": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QSortFilterProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QSortFilterProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setDynamicSortFilter": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterFixedString": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterKeyColumn": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegExp": [('PySide2.QtCore.QRegExp',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegularExpression": [('PySide2.QtCore.QRegularExpression',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterWildcard": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setRecursiveFilteringEnabled": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortLocaleAware": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QSortFilterProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QSortFilterProxyModel.sortCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortOrder": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QStandardPaths:
-# class PySide2.QtCore.QStandardPaths.LocateOption:
-# class PySide2.QtCore.QStandardPaths.LocateOptions:
-# class PySide2.QtCore.QStandardPaths.StandardLocation:
-    "PySide2.QtCore.QStandardPaths.displayName": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.enableTestMode": ('bool',),
-    "PySide2.QtCore.QStandardPaths.findExecutable": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QStandardPaths.isTestModeEnabled": (),
-    "PySide2.QtCore.QStandardPaths.locate": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.locateAll": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.setTestModeEnabled": ('bool',),
-    "PySide2.QtCore.QStandardPaths.standardLocations": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.writableLocation": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-# class PySide2.QtCore.QState:
-# class PySide2.QtCore.QState.ChildMode:
-# class PySide2.QtCore.QState.RestorePolicy:
-    "PySide2.QtCore.QState.__init__": [('PySide2.QtCore.QState',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QState.addTransition": [('PySide2.QtCore.QAbstractState',), ('PySide2.QtCore.QAbstractTransition',), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QAbstractState'), ('object', 'PySide2.QtCore.QAbstractState')],
-    "PySide2.QtCore.QState.assignProperty": ('PySide2.QtCore.QObject', 'str', 'typing.Any'),
-    "PySide2.QtCore.QState.childMode": (),
-    "PySide2.QtCore.QState.errorState": (),
-    "PySide2.QtCore.QState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.initialState": (),
-    "PySide2.QtCore.QState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.removeTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QState.setChildMode": ('PySide2.QtCore.QState.ChildMode',),
-    "PySide2.QtCore.QState.setErrorState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.setInitialState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.transitions": (),
-# class PySide2.QtCore.QStateMachine:
-# class PySide2.QtCore.QStateMachine.Error:
-# class PySide2.QtCore.QStateMachine.EventPriority:
-# class PySide2.QtCore.QStateMachine.SignalEvent:
-    "PySide2.QtCore.QStateMachine.SignalEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'typing.Sequence[typing.Any]'), ('PySide2.QtCore.QStateMachine.SignalEvent',)],
-    "PySide2.QtCore.QStateMachine.SignalEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.arguments": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.sender": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.signalIndex": (),
-# class PySide2.QtCore.QStateMachine.WrappedEvent:
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'), ('PySide2.QtCore.QStateMachine.WrappedEvent',)],
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.event": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.object": (),
-    "PySide2.QtCore.QStateMachine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStateMachine.addDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.addState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.beginMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.beginSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.cancelDelayedEvent": ('int',),
-    "PySide2.QtCore.QStateMachine.clearError": (),
-    "PySide2.QtCore.QStateMachine.configuration": (),
-    "PySide2.QtCore.QStateMachine.defaultAnimations": (),
-    "PySide2.QtCore.QStateMachine.endMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.endSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.error": (),
-    "PySide2.QtCore.QStateMachine.errorString": (),
-    "PySide2.QtCore.QStateMachine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QStateMachine.globalRestorePolicy": (),
-    "PySide2.QtCore.QStateMachine.isAnimated": (),
-    "PySide2.QtCore.QStateMachine.isRunning": (),
-    "PySide2.QtCore.QStateMachine.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.postDelayedEvent": ('PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QStateMachine.postEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QStateMachine.EventPriority'),
-    "PySide2.QtCore.QStateMachine.removeDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.removeState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.setAnimated": ('bool',),
-    "PySide2.QtCore.QStateMachine.setGlobalRestorePolicy": ('PySide2.QtCore.QState.RestorePolicy',),
-    "PySide2.QtCore.QStateMachine.setRunning": ('bool',),
-    "PySide2.QtCore.QStateMachine.start": (),
-    "PySide2.QtCore.QStateMachine.stop": (),
-# class PySide2.QtCore.QStorageInfo:
-    "PySide2.QtCore.QStorageInfo.__init__": [(), ('PySide2.QtCore.QDir',), ('PySide2.QtCore.QStorageInfo',), ('str',)],
-    "PySide2.QtCore.QStorageInfo.__copy__": (),
-    "PySide2.QtCore.QStorageInfo.blockSize": (),
-    "PySide2.QtCore.QStorageInfo.bytesAvailable": (),
-    "PySide2.QtCore.QStorageInfo.bytesFree": (),
-    "PySide2.QtCore.QStorageInfo.bytesTotal": (),
-    "PySide2.QtCore.QStorageInfo.device": (),
-    "PySide2.QtCore.QStorageInfo.displayName": (),
-    "PySide2.QtCore.QStorageInfo.fileSystemType": (),
-    "PySide2.QtCore.QStorageInfo.isReadOnly": (),
-    "PySide2.QtCore.QStorageInfo.isReady": (),
-    "PySide2.QtCore.QStorageInfo.isRoot": (),
-    "PySide2.QtCore.QStorageInfo.isValid": (),
-    "PySide2.QtCore.QStorageInfo.mountedVolumes": (),
-    "PySide2.QtCore.QStorageInfo.name": (),
-    "PySide2.QtCore.QStorageInfo.refresh": (),
-    "PySide2.QtCore.QStorageInfo.root": (),
-    "PySide2.QtCore.QStorageInfo.rootPath": (),
-    "PySide2.QtCore.QStorageInfo.setPath": ('str',),
-    "PySide2.QtCore.QStorageInfo.subvolume": (),
-    "PySide2.QtCore.QStorageInfo.swap": ('PySide2.QtCore.QStorageInfo',),
-# class PySide2.QtCore.QStringListModel:
-    "PySide2.QtCore.QStringListModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStringListModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QStringListModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QStringListModel.setStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QStringListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QStringListModel.stringList": (),
-    "PySide2.QtCore.QStringListModel.supportedDropActions": (),
-# class PySide2.QtCore.QSysInfo:
-# class PySide2.QtCore.QSysInfo.Endian:
-# class PySide2.QtCore.QSysInfo.Sizes:
-    "PySide2.QtCore.QSysInfo.__init__": (),
-    "PySide2.QtCore.QSysInfo.bootUniqueId": (),
-    "PySide2.QtCore.QSysInfo.buildAbi": (),
-    "PySide2.QtCore.QSysInfo.buildCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.currentCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.kernelType": (),
-    "PySide2.QtCore.QSysInfo.kernelVersion": (),
-    "PySide2.QtCore.QSysInfo.machineHostName": (),
-    "PySide2.QtCore.QSysInfo.machineUniqueId": (),
-    "PySide2.QtCore.QSysInfo.prettyProductName": (),
-    "PySide2.QtCore.QSysInfo.productType": (),
-    "PySide2.QtCore.QSysInfo.productVersion": (),
-# class PySide2.QtCore.QSystemSemaphore:
-# class PySide2.QtCore.QSystemSemaphore.AccessMode:
-# class PySide2.QtCore.QSystemSemaphore.SystemSemaphoreError:
-    "PySide2.QtCore.QSystemSemaphore.__init__": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-    "PySide2.QtCore.QSystemSemaphore.acquire": (),
-    "PySide2.QtCore.QSystemSemaphore.error": (),
-    "PySide2.QtCore.QSystemSemaphore.errorString": (),
-    "PySide2.QtCore.QSystemSemaphore.key": (),
-    "PySide2.QtCore.QSystemSemaphore.release": ('int',),
-    "PySide2.QtCore.QSystemSemaphore.setKey": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-# class PySide2.QtCore.QTemporaryDir:
-    "PySide2.QtCore.QTemporaryDir.__init__": [(), ('str',)],
-    "PySide2.QtCore.QTemporaryDir.autoRemove": (),
-    "PySide2.QtCore.QTemporaryDir.errorString": (),
-    "PySide2.QtCore.QTemporaryDir.filePath": ('str',),
-    "PySide2.QtCore.QTemporaryDir.isValid": (),
-    "PySide2.QtCore.QTemporaryDir.path": (),
-    "PySide2.QtCore.QTemporaryDir.remove": (),
-    "PySide2.QtCore.QTemporaryDir.setAutoRemove": ('bool',),
-# class PySide2.QtCore.QTemporaryFile:
-    "PySide2.QtCore.QTemporaryFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QTemporaryFile.autoRemove": (),
-    "PySide2.QtCore.QTemporaryFile.createLocalFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.createNativeFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.fileName": (),
-    "PySide2.QtCore.QTemporaryFile.fileTemplate": (),
-    "PySide2.QtCore.QTemporaryFile.open": [(), ('PySide2.QtCore.QIODevice.OpenMode',)],
-    "PySide2.QtCore.QTemporaryFile.rename": ('str',),
-    "PySide2.QtCore.QTemporaryFile.setAutoRemove": ('bool',),
-    "PySide2.QtCore.QTemporaryFile.setFileTemplate": ('str',),
-# class PySide2.QtCore.QTextBoundaryFinder:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReason:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReasons:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryType:
-    "PySide2.QtCore.QTextBoundaryFinder.__init__": [(), ('PySide2.QtCore.QTextBoundaryFinder',), ('PySide2.QtCore.QTextBoundaryFinder.BoundaryType', 'str')],
-    "PySide2.QtCore.QTextBoundaryFinder.__copy__": (),
-    "PySide2.QtCore.QTextBoundaryFinder.boundaryReasons": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isAtBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isValid": (),
-    "PySide2.QtCore.QTextBoundaryFinder.position": (),
-    "PySide2.QtCore.QTextBoundaryFinder.setPosition": ('int',),
-    "PySide2.QtCore.QTextBoundaryFinder.string": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toEnd": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toNextBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toPreviousBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toStart": (),
-    "PySide2.QtCore.QTextBoundaryFinder.type": (),
-# class PySide2.QtCore.QTextCodec:
-# class PySide2.QtCore.QTextCodec.ConversionFlag:
-# class PySide2.QtCore.QTextCodec.ConversionFlags:
-# class PySide2.QtCore.QTextCodec.ConverterState:
-    "PySide2.QtCore.QTextCodec.ConverterState.__init__": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.__init__": (),
-    "PySide2.QtCore.QTextCodec.aliases": (),
-    "PySide2.QtCore.QTextCodec.availableCodecs": (),
-    "PySide2.QtCore.QTextCodec.availableMibs": (),
-    "PySide2.QtCore.QTextCodec.canEncode": ('str',),
-    "PySide2.QtCore.QTextCodec.codecForHtml": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.codecForLocale": (),
-    "PySide2.QtCore.QTextCodec.codecForMib": ('int',),
-    "PySide2.QtCore.QTextCodec.codecForName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QTextCodec.codecForUtfText": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.convertToUnicode": ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState'),
-    "PySide2.QtCore.QTextCodec.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextCodec.makeDecoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.makeEncoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.mibEnum": (),
-    "PySide2.QtCore.QTextCodec.name": (),
-    "PySide2.QtCore.QTextCodec.setCodecForLocale": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtCore.QTextCodec.toUnicode": [('PySide2.QtCore.QByteArray',), ('str',), ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState')],
-# class PySide2.QtCore.QTextDecoder:
-    "PySide2.QtCore.QTextDecoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextDecoder.hasFailure": (),
-    "PySide2.QtCore.QTextDecoder.needsMoreData": (),
-    "PySide2.QtCore.QTextDecoder.toUnicode": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QTextEncoder:
-    "PySide2.QtCore.QTextEncoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextEncoder.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextEncoder.hasFailure": (),
-# class PySide2.QtCore.QTextStream:
-# class PySide2.QtCore.QTextStream.FieldAlignment:
-# class PySide2.QtCore.QTextStream.NumberFlag:
-# class PySide2.QtCore.QTextStream.NumberFlags:
-# class PySide2.QtCore.QTextStream.RealNumberNotation:
-# class PySide2.QtCore.QTextStream.Status:
-    "PySide2.QtCore.QTextStream.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QTextStream.__lshift__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QTextStreamManipulator',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QTextStream.__rshift__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTextStream.atEnd": (),
-    "PySide2.QtCore.QTextStream.autoDetectUnicode": (),
-    "PySide2.QtCore.QTextStream.codec": (),
-    "PySide2.QtCore.QTextStream.device": (),
-    "PySide2.QtCore.QTextStream.fieldAlignment": (),
-    "PySide2.QtCore.QTextStream.fieldWidth": (),
-    "PySide2.QtCore.QTextStream.flush": (),
-    "PySide2.QtCore.QTextStream.generateByteOrderMark": (),
-    "PySide2.QtCore.QTextStream.integerBase": (),
-    "PySide2.QtCore.QTextStream.locale": (),
-    "PySide2.QtCore.QTextStream.numberFlags": (),
-    "PySide2.QtCore.QTextStream.padChar": (),
-    "PySide2.QtCore.QTextStream.pos": (),
-    "PySide2.QtCore.QTextStream.read": ('int',),
-    "PySide2.QtCore.QTextStream.readAll": (),
-    "PySide2.QtCore.QTextStream.readLine": ('int',),
-    "PySide2.QtCore.QTextStream.realNumberNotation": (),
-    "PySide2.QtCore.QTextStream.realNumberPrecision": (),
-    "PySide2.QtCore.QTextStream.reset": (),
-    "PySide2.QtCore.QTextStream.resetStatus": (),
-    "PySide2.QtCore.QTextStream.seek": ('int',),
-    "PySide2.QtCore.QTextStream.setAutoDetectUnicode": ('bool',),
-    "PySide2.QtCore.QTextStream.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QTextStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QTextStream.setFieldAlignment": ('PySide2.QtCore.QTextStream.FieldAlignment',),
-    "PySide2.QtCore.QTextStream.setFieldWidth": ('int',),
-    "PySide2.QtCore.QTextStream.setGenerateByteOrderMark": ('bool',),
-    "PySide2.QtCore.QTextStream.setIntegerBase": ('int',),
-    "PySide2.QtCore.QTextStream.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QTextStream.setNumberFlags": ('PySide2.QtCore.QTextStream.NumberFlags',),
-    "PySide2.QtCore.QTextStream.setPadChar": ('str',),
-    "PySide2.QtCore.QTextStream.setRealNumberNotation": ('PySide2.QtCore.QTextStream.RealNumberNotation',),
-    "PySide2.QtCore.QTextStream.setRealNumberPrecision": ('int',),
-    "PySide2.QtCore.QTextStream.setStatus": ('PySide2.QtCore.QTextStream.Status',),
-    "PySide2.QtCore.QTextStream.skipWhiteSpace": (),
-    "PySide2.QtCore.QTextStream.status": (),
-    "PySide2.QtCore.QTextStream.string": (),
-# class PySide2.QtCore.QTextStreamManipulator:
-    "PySide2.QtCore.QTextStreamManipulator.__copy__": (),
-    "PySide2.QtCore.QTextStreamManipulator.exec_": ('PySide2.QtCore.QTextStream',),
-# class PySide2.QtCore.QThread:
-# class PySide2.QtCore.QThread.Priority:
-    "PySide2.QtCore.QThread.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThread.currentThread": (),
-    "PySide2.QtCore.QThread.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QThread.eventDispatcher": (),
-    "PySide2.QtCore.QThread.exec_": (),
-    "PySide2.QtCore.QThread.exit": ('int',),
-    "PySide2.QtCore.QThread.idealThreadCount": (),
-    "PySide2.QtCore.QThread.isFinished": (),
-    "PySide2.QtCore.QThread.isInterruptionRequested": (),
-    "PySide2.QtCore.QThread.isRunning": (),
-    "PySide2.QtCore.QThread.loopLevel": (),
-    "PySide2.QtCore.QThread.msleep": ('int',),
-    "PySide2.QtCore.QThread.priority": (),
-    "PySide2.QtCore.QThread.quit": (),
-    "PySide2.QtCore.QThread.requestInterruption": (),
-    "PySide2.QtCore.QThread.run": (),
-    "PySide2.QtCore.QThread.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QThread.setPriority": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.setStackSize": ('int',),
-    "PySide2.QtCore.QThread.setTerminationEnabled": ('bool',),
-    "PySide2.QtCore.QThread.sleep": ('int',),
-    "PySide2.QtCore.QThread.stackSize": (),
-    "PySide2.QtCore.QThread.start": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.terminate": (),
-    "PySide2.QtCore.QThread.usleep": ('int',),
-    "PySide2.QtCore.QThread.wait": ('int',),
-    "PySide2.QtCore.QThread.yieldCurrentThread": (),
-# class PySide2.QtCore.QThreadPool:
-    "PySide2.QtCore.QThreadPool.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThreadPool.activeThreadCount": (),
-    "PySide2.QtCore.QThreadPool.cancel": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.clear": (),
-    "PySide2.QtCore.QThreadPool.expiryTimeout": (),
-    "PySide2.QtCore.QThreadPool.globalInstance": (),
-    "PySide2.QtCore.QThreadPool.maxThreadCount": (),
-    "PySide2.QtCore.QThreadPool.releaseThread": (),
-    "PySide2.QtCore.QThreadPool.reserveThread": (),
-    "PySide2.QtCore.QThreadPool.setExpiryTimeout": ('int',),
-    "PySide2.QtCore.QThreadPool.setMaxThreadCount": ('int',),
-    "PySide2.QtCore.QThreadPool.setStackSize": ('int',),
-    "PySide2.QtCore.QThreadPool.stackSize": (),
-    "PySide2.QtCore.QThreadPool.start": ('PySide2.QtCore.QRunnable', 'int'),
-    "PySide2.QtCore.QThreadPool.tryStart": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.tryTake": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.waitForDone": ('int',),
-# class PySide2.QtCore.QTime:
-    "PySide2.QtCore.QTime.__init__": [(), ('PySide2.QtCore.QTime',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.__copy__": (),
-    "PySide2.QtCore.QTime.__reduce__": (),
-    "PySide2.QtCore.QTime.__repr__": (),
-    "PySide2.QtCore.QTime.addMSecs": ('int',),
-    "PySide2.QtCore.QTime.addSecs": ('int',),
-    "PySide2.QtCore.QTime.currentTime": (),
-    "PySide2.QtCore.QTime.elapsed": (),
-    "PySide2.QtCore.QTime.fromMSecsSinceStartOfDay": ('int',),
-    "PySide2.QtCore.QTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str')],
-    "PySide2.QtCore.QTime.hour": (),
-    "PySide2.QtCore.QTime.isNull": (),
-    "PySide2.QtCore.QTime.isValid": [(), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.minute": (),
-    "PySide2.QtCore.QTime.msec": (),
-    "PySide2.QtCore.QTime.msecsSinceStartOfDay": (),
-    "PySide2.QtCore.QTime.msecsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.restart": (),
-    "PySide2.QtCore.QTime.second": (),
-    "PySide2.QtCore.QTime.secsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.setHMS": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QTime.start": (),
-    "PySide2.QtCore.QTime.toPython": (),
-    "PySide2.QtCore.QTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-# class PySide2.QtCore.QTimeLine:
-# class PySide2.QtCore.QTimeLine.CurveShape:
-# class PySide2.QtCore.QTimeLine.Direction:
-# class PySide2.QtCore.QTimeLine.State:
-    "PySide2.QtCore.QTimeLine.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QTimeLine.currentFrame": (),
-    "PySide2.QtCore.QTimeLine.currentTime": (),
-    "PySide2.QtCore.QTimeLine.currentValue": (),
-    "PySide2.QtCore.QTimeLine.curveShape": (),
-    "PySide2.QtCore.QTimeLine.direction": (),
-    "PySide2.QtCore.QTimeLine.duration": (),
-    "PySide2.QtCore.QTimeLine.easingCurve": (),
-    "PySide2.QtCore.QTimeLine.endFrame": (),
-    "PySide2.QtCore.QTimeLine.frameForTime": ('int',),
-    "PySide2.QtCore.QTimeLine.loopCount": (),
-    "PySide2.QtCore.QTimeLine.resume": (),
-    "PySide2.QtCore.QTimeLine.setCurrentTime": ('int',),
-    "PySide2.QtCore.QTimeLine.setCurveShape": ('PySide2.QtCore.QTimeLine.CurveShape',),
-    "PySide2.QtCore.QTimeLine.setDirection": ('PySide2.QtCore.QTimeLine.Direction',),
-    "PySide2.QtCore.QTimeLine.setDuration": ('int',),
-    "PySide2.QtCore.QTimeLine.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QTimeLine.setEndFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setFrameRange": ('int', 'int'),
-    "PySide2.QtCore.QTimeLine.setLoopCount": ('int',),
-    "PySide2.QtCore.QTimeLine.setPaused": ('bool',),
-    "PySide2.QtCore.QTimeLine.setStartFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setUpdateInterval": ('int',),
-    "PySide2.QtCore.QTimeLine.start": (),
-    "PySide2.QtCore.QTimeLine.startFrame": (),
-    "PySide2.QtCore.QTimeLine.state": (),
-    "PySide2.QtCore.QTimeLine.stop": (),
-    "PySide2.QtCore.QTimeLine.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimeLine.toggleDirection": (),
-    "PySide2.QtCore.QTimeLine.updateInterval": (),
-    "PySide2.QtCore.QTimeLine.valueForTime": ('int',),
-# class PySide2.QtCore.QTimeZone:
-# class PySide2.QtCore.QTimeZone.NameType:
-# class PySide2.QtCore.QTimeZone.OffsetData:
-    "PySide2.QtCore.QTimeZone.OffsetData.__init__": [(), ('PySide2.QtCore.QTimeZone.OffsetData',)],
-    "PySide2.QtCore.QTimeZone.OffsetData.__copy__": (),
-# class PySide2.QtCore.QTimeZone.TimeType:
-    "PySide2.QtCore.QTimeZone.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'int', 'str', 'str', 'PySide2.QtCore.QLocale.Country', 'str'), ('PySide2.QtCore.QTimeZone',), ('int',)],
-    "PySide2.QtCore.QTimeZone.__copy__": (),
-    "PySide2.QtCore.QTimeZone.abbreviation": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.availableTimeZoneIds": [(), ('PySide2.QtCore.QLocale.Country',), ('int',)],
-    "PySide2.QtCore.QTimeZone.comment": (),
-    "PySide2.QtCore.QTimeZone.country": (),
-    "PySide2.QtCore.QTimeZone.daylightTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.displayName": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale'), ('PySide2.QtCore.QTimeZone.TimeType', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale')],
-    "PySide2.QtCore.QTimeZone.hasDaylightTime": (),
-    "PySide2.QtCore.QTimeZone.hasTransitions": (),
-    "PySide2.QtCore.QTimeZone.ianaIdToWindowsId": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.id": (),
-    "PySide2.QtCore.QTimeZone.isDaylightTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.isTimeZoneIdAvailable": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.isValid": (),
-    "PySide2.QtCore.QTimeZone.nextTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetData": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetFromUtc": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.previousTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.standardTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.swap": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QTimeZone.systemTimeZone": (),
-    "PySide2.QtCore.QTimeZone.systemTimeZoneId": (),
-    "PySide2.QtCore.QTimeZone.transitions": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtCore.QTimeZone.utc": (),
-    "PySide2.QtCore.QTimeZone.windowsIdToDefaultIanaId": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-    "PySide2.QtCore.QTimeZone.windowsIdToIanaIds": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-# class PySide2.QtCore.QTimer:
-    "PySide2.QtCore.QTimer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTimer.interval": (),
-    "PySide2.QtCore.QTimer.isActive": (),
-    "PySide2.QtCore.QTimer.isSingleShot": (),
-    "PySide2.QtCore.QTimer.killTimer": ('int',),
-    "PySide2.QtCore.QTimer.remainingTime": (),
-    "PySide2.QtCore.QTimer.setInterval": ('int',),
-    "PySide2.QtCore.QTimer.setSingleShot": ('bool',),
-    "PySide2.QtCore.QTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QTimer.singleShot": [('int', 'PySide2.QtCore.QObject', 'str'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject', 'str'), ('int', 'typing.Callable')],
-    "PySide2.QtCore.QTimer.start": [(), ('int',)],
-    "PySide2.QtCore.QTimer.stop": (),
-    "PySide2.QtCore.QTimer.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimer.timerId": (),
-    "PySide2.QtCore.QTimer.timerType": (),
-# class PySide2.QtCore.QTimerEvent:
-    "PySide2.QtCore.QTimerEvent.__init__": ('int',),
-    "PySide2.QtCore.QTimerEvent.timerId": (),
-# class PySide2.QtCore.QTranslator:
-    "PySide2.QtCore.QTranslator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTranslator.isEmpty": (),
-    "PySide2.QtCore.QTranslator.load": [('PySide2.QtCore.QLocale', 'str', 'str', 'str', 'str'), ('str', 'int', 'str'), ('str', 'str', 'str', 'str')],
-    "PySide2.QtCore.QTranslator.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QTransposeProxyModel:
-    "PySide2.QtCore.QTransposeProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTransposeProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QTransposeProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QTransposeProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QTransposeProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QTransposeProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QUrl:
-# class PySide2.QtCore.QUrl.ComponentFormattingOption:
-# class PySide2.QtCore.QUrl.FormattingOptions:
-# class PySide2.QtCore.QUrl.ParsingMode:
-# class PySide2.QtCore.QUrl.UrlFormattingOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOptions:
-    "PySide2.QtCore.QUrl.__init__": [(), ('PySide2.QtCore.QUrl',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.__copy__": (),
-    "PySide2.QtCore.QUrl.__reduce__": (),
-    "PySide2.QtCore.QUrl.__repr__": (),
-    "PySide2.QtCore.QUrl.adjusted": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.authority": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.clear": (),
-    "PySide2.QtCore.QUrl.errorString": (),
-    "PySide2.QtCore.QUrl.fileName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fragment": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fromAce": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromEncoded": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromLocalFile": ('str',),
-    "PySide2.QtCore.QUrl.fromPercentEncoding": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromStringList": ('typing.Sequence[str]', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromUserInput": [('str',), ('str', 'str', 'PySide2.QtCore.QUrl.UserInputResolutionOptions')],
-    "PySide2.QtCore.QUrl.hasFragment": (),
-    "PySide2.QtCore.QUrl.hasQuery": (),
-    "PySide2.QtCore.QUrl.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.idnWhitelist": (),
-    "PySide2.QtCore.QUrl.isEmpty": (),
-    "PySide2.QtCore.QUrl.isLocalFile": (),
-    "PySide2.QtCore.QUrl.isParentOf": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.isRelative": (),
-    "PySide2.QtCore.QUrl.isValid": (),
-    "PySide2.QtCore.QUrl.matches": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.password": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.path": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.port": ('int',),
-    "PySide2.QtCore.QUrl.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.resolved": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.scheme": (),
-    "PySide2.QtCore.QUrl.setAuthority": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setFragment": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setIdnWhitelist": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QUrl.setPassword": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPath": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPort": ('int',),
-    "PySide2.QtCore.QUrl.setQuery": [('PySide2.QtCore.QUrlQuery',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.setScheme": ('str',),
-    "PySide2.QtCore.QUrl.setUrl": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserInfo": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserName": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.swap": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.toAce": ('str',),
-    "PySide2.QtCore.QUrl.toDisplayString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toEncoded": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toLocalFile": (),
-    "PySide2.QtCore.QUrl.toPercentEncoding": ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QUrl.toString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toStringList": ('typing.Sequence[PySide2.QtCore.QUrl]', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.topLevelDomain": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.url": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.userInfo": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.userName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUrlQuery:
-    "PySide2.QtCore.QUrlQuery.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrlQuery',), ('str',)],
-    "PySide2.QtCore.QUrlQuery.__copy__": (),
-    "PySide2.QtCore.QUrlQuery.addQueryItem": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.allQueryItemValues": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.clear": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.hasQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.isEmpty": (),
-    "PySide2.QtCore.QUrlQuery.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryItemValue": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.queryItems": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.queryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.removeAllQueryItems": ('str',),
-    "PySide2.QtCore.QUrlQuery.removeQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQuery": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQueryDelimiters": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.setQueryItems": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtCore.QUrlQuery.swap": ('PySide2.QtCore.QUrlQuery',),
-    "PySide2.QtCore.QUrlQuery.toString": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUuid:
-# class PySide2.QtCore.QUuid.StringFormat:
-# class PySide2.QtCore.QUuid.Variant:
-# class PySide2.QtCore.QUuid.Version:
-    "PySide2.QtCore.QUuid.__init__": [(), ('PySide2.QtCore.QByteArray',), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'), ('str',)],
-    "PySide2.QtCore.QUuid.__copy__": (),
-    "PySide2.QtCore.QUuid.__reduce__": (),
-    "PySide2.QtCore.QUuid.__repr__": (),
-    "PySide2.QtCore.QUuid.createUuid": (),
-    "PySide2.QtCore.QUuid.createUuidV3": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.createUuidV5": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.fromRfc4122": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUuid.isNull": (),
-    "PySide2.QtCore.QUuid.toByteArray": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.toRfc4122": (),
-    "PySide2.QtCore.QUuid.toString": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.variant": (),
-    "PySide2.QtCore.QUuid.version": (),
-# class PySide2.QtCore.QVariantAnimation:
-    "PySide2.QtCore.QVariantAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QVariantAnimation.currentValue": (),
-    "PySide2.QtCore.QVariantAnimation.duration": (),
-    "PySide2.QtCore.QVariantAnimation.easingCurve": (),
-    "PySide2.QtCore.QVariantAnimation.endValue": (),
-    "PySide2.QtCore.QVariantAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QVariantAnimation.interpolated": ('typing.Any', 'typing.Any', 'float'),
-    "PySide2.QtCore.QVariantAnimation.keyValueAt": ('float',),
-    "PySide2.QtCore.QVariantAnimation.keyValues": (),
-    "PySide2.QtCore.QVariantAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QVariantAnimation.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QVariantAnimation.setEndValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.setKeyValueAt": ('float', 'typing.Any'),
-    "PySide2.QtCore.QVariantAnimation.setKeyValues": ('typing.List[typing.Tuple]',),
-    "PySide2.QtCore.QVariantAnimation.setStartValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.startValue": (),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QVersionNumber:
-    "PySide2.QtCore.QVersionNumber.__init__": [(), ('int',), ('int', 'int'), ('int', 'int', 'int'), ('typing.List[int]',)],
-    "PySide2.QtCore.QVersionNumber.__copy__": (),
-    "PySide2.QtCore.QVersionNumber.commonPrefix": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.compare": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.fromString": ('str',),
-    "PySide2.QtCore.QVersionNumber.isNormalized": (),
-    "PySide2.QtCore.QVersionNumber.isNull": (),
-    "PySide2.QtCore.QVersionNumber.isPrefixOf": ('PySide2.QtCore.QVersionNumber',),
-    "PySide2.QtCore.QVersionNumber.majorVersion": (),
-    "PySide2.QtCore.QVersionNumber.microVersion": (),
-    "PySide2.QtCore.QVersionNumber.minorVersion": (),
-    "PySide2.QtCore.QVersionNumber.normalized": (),
-    "PySide2.QtCore.QVersionNumber.segmentAt": ('int',),
-    "PySide2.QtCore.QVersionNumber.segmentCount": (),
-    "PySide2.QtCore.QVersionNumber.segments": (),
-    "PySide2.QtCore.QVersionNumber.toString": (),
-# class PySide2.QtCore.QWaitCondition:
-    "PySide2.QtCore.QWaitCondition.__init__": (),
-    "PySide2.QtCore.QWaitCondition.notify_all": (),
-    "PySide2.QtCore.QWaitCondition.notify_one": (),
-    "PySide2.QtCore.QWaitCondition.wait": [('PySide2.QtCore.QMutex', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QMutex', 'int'), ('PySide2.QtCore.QReadWriteLock', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QReadWriteLock', 'int')],
-    "PySide2.QtCore.QWaitCondition.wakeAll": (),
-    "PySide2.QtCore.QWaitCondition.wakeOne": (),
-# class PySide2.QtCore.QWriteLocker:
-    "PySide2.QtCore.QWriteLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QWriteLocker.__enter__": (),
-    "PySide2.QtCore.QWriteLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QWriteLocker.readWriteLock": (),
-    "PySide2.QtCore.QWriteLocker.relock": (),
-    "PySide2.QtCore.QWriteLocker.unlock": (),
-# class PySide2.QtCore.QXmlStreamAttribute:
-    "PySide2.QtCore.QXmlStreamAttribute.__init__": [(), ('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttribute.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttribute.isDefault": (),
-    "PySide2.QtCore.QXmlStreamAttribute.name": (),
-    "PySide2.QtCore.QXmlStreamAttribute.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamAttribute.prefix": (),
-    "PySide2.QtCore.QXmlStreamAttribute.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamAttribute.value": (),
-# class PySide2.QtCore.QXmlStreamAttributes:
-    "PySide2.QtCore.QXmlStreamAttributes.__init__": [(), ('PySide2.QtCore.QXmlStreamAttributes',)],
-    "PySide2.QtCore.QXmlStreamAttributes.__add__": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttributes.__iadd__": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.__lshift__": [('PySide2.QtCore.QXmlStreamAttribute',), ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',)],
-    "PySide2.QtCore.QXmlStreamAttributes.append": [('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.at": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.back": (),
-    "PySide2.QtCore.QXmlStreamAttributes.capacity": (),
-    "PySide2.QtCore.QXmlStreamAttributes.clear": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constData": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.contains": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.count": [(), ('PySide2.QtCore.QXmlStreamAttribute',)],
-    "PySide2.QtCore.QXmlStreamAttributes.data": (),
-    "PySide2.QtCore.QXmlStreamAttributes.empty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.endsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.fill": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.first": (),
-    "PySide2.QtCore.QXmlStreamAttributes.front": (),
-    "PySide2.QtCore.QXmlStreamAttributes.hasAttribute": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.indexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.insert": [('int', 'PySide2.QtCore.QXmlStreamAttribute'), ('int', 'int', 'PySide2.QtCore.QXmlStreamAttribute')],
-    "PySide2.QtCore.QXmlStreamAttributes.isEmpty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.isSharedWith": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.last": (),
-    "PySide2.QtCore.QXmlStreamAttributes.lastIndexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.length": (),
-    "PySide2.QtCore.QXmlStreamAttributes.mid": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.move": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.prepend": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.remove": [('int',), ('int', 'int')],
-    "PySide2.QtCore.QXmlStreamAttributes.removeAll": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeOne": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.replace": ('int', 'PySide2.QtCore.QXmlStreamAttribute'),
-    "PySide2.QtCore.QXmlStreamAttributes.reserve": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.resize": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.setSharable": ('bool',),
-    "PySide2.QtCore.QXmlStreamAttributes.shrink_to_fit": (),
-    "PySide2.QtCore.QXmlStreamAttributes.size": (),
-    "PySide2.QtCore.QXmlStreamAttributes.squeeze": (),
-    "PySide2.QtCore.QXmlStreamAttributes.startsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.swap": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.takeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.takeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.takeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.value": [('str',), ('str', 'str')],
-# class PySide2.QtCore.QXmlStreamEntityDeclaration:
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamEntityDeclaration',)],
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.notationName": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.systemId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.value": (),
-# class PySide2.QtCore.QXmlStreamEntityResolver:
-    "PySide2.QtCore.QXmlStreamEntityResolver.__init__": (),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveEntity": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveUndeclaredEntity": ('str',),
-# class PySide2.QtCore.QXmlStreamNamespaceDeclaration:
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.prefix": (),
-# class PySide2.QtCore.QXmlStreamNotationDeclaration:
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNotationDeclaration',)],
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.systemId": (),
-# class PySide2.QtCore.QXmlStreamReader:
-# class PySide2.QtCore.QXmlStreamReader.Error:
-# class PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour:
-# class PySide2.QtCore.QXmlStreamReader.TokenType:
-    "PySide2.QtCore.QXmlStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclaration": ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',),
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclarations": ('typing.List[PySide2.QtCore.QXmlStreamNamespaceDeclaration]',),
-    "PySide2.QtCore.QXmlStreamReader.atEnd": (),
-    "PySide2.QtCore.QXmlStreamReader.attributes": (),
-    "PySide2.QtCore.QXmlStreamReader.characterOffset": (),
-    "PySide2.QtCore.QXmlStreamReader.clear": (),
-    "PySide2.QtCore.QXmlStreamReader.columnNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.device": (),
-    "PySide2.QtCore.QXmlStreamReader.documentEncoding": (),
-    "PySide2.QtCore.QXmlStreamReader.documentVersion": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdName": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdPublicId": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdSystemId": (),
-    "PySide2.QtCore.QXmlStreamReader.entityDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.entityResolver": (),
-    "PySide2.QtCore.QXmlStreamReader.error": (),
-    "PySide2.QtCore.QXmlStreamReader.errorString": (),
-    "PySide2.QtCore.QXmlStreamReader.hasError": (),
-    "PySide2.QtCore.QXmlStreamReader.isCDATA": (),
-    "PySide2.QtCore.QXmlStreamReader.isCharacters": (),
-    "PySide2.QtCore.QXmlStreamReader.isComment": (),
-    "PySide2.QtCore.QXmlStreamReader.isDTD": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isEntityReference": (),
-    "PySide2.QtCore.QXmlStreamReader.isProcessingInstruction": (),
-    "PySide2.QtCore.QXmlStreamReader.isStandaloneDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isWhitespace": (),
-    "PySide2.QtCore.QXmlStreamReader.lineNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.name": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceProcessing": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamReader.notationDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.prefix": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionData": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionTarget": (),
-    "PySide2.QtCore.QXmlStreamReader.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamReader.raiseError": ('str',),
-    "PySide2.QtCore.QXmlStreamReader.readElementText": ('PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour',),
-    "PySide2.QtCore.QXmlStreamReader.readNext": (),
-    "PySide2.QtCore.QXmlStreamReader.readNextStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamReader.setEntityResolver": ('PySide2.QtCore.QXmlStreamEntityResolver',),
-    "PySide2.QtCore.QXmlStreamReader.setNamespaceProcessing": ('bool',),
-    "PySide2.QtCore.QXmlStreamReader.skipCurrentElement": (),
-    "PySide2.QtCore.QXmlStreamReader.text": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenString": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenType": (),
-# class PySide2.QtCore.QXmlStreamWriter:
-    "PySide2.QtCore.QXmlStreamWriter.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QXmlStreamWriter.autoFormatting": (),
-    "PySide2.QtCore.QXmlStreamWriter.autoFormattingIndent": (),
-    "PySide2.QtCore.QXmlStreamWriter.codec": (),
-    "PySide2.QtCore.QXmlStreamWriter.device": (),
-    "PySide2.QtCore.QXmlStreamWriter.hasError": (),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormatting": ('bool',),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormattingIndent": ('int',),
-    "PySide2.QtCore.QXmlStreamWriter.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QXmlStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamWriter.writeAttribute": [('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeAttributes": ('PySide2.QtCore.QXmlStreamAttributes',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCDATA": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCharacters": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeComment": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCurrentToken": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDTD": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDefaultNamespace": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeEmptyElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeEndDocument": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEndElement": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEntityReference": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeNamespace": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeProcessingInstruction": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeStartDocument": [(), ('str',), ('str', 'bool')],
-    "PySide2.QtCore.QXmlStreamWriter.writeStartElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeTextElement": [('str', 'str'), ('str', 'str', 'str')],
-# class PySide2.QtCore.Qt:
-# class PySide2.QtCore.Qt.Alignment:
-# class PySide2.QtCore.Qt.AlignmentFlag:
-# class PySide2.QtCore.Qt.AnchorPoint:
-# class PySide2.QtCore.Qt.ApplicationAttribute:
-# class PySide2.QtCore.Qt.ApplicationState:
-# class PySide2.QtCore.Qt.ApplicationStates:
-# class PySide2.QtCore.Qt.ArrowType:
-# class PySide2.QtCore.Qt.AspectRatioMode:
-# class PySide2.QtCore.Qt.Axis:
-# class PySide2.QtCore.Qt.BGMode:
-# class PySide2.QtCore.Qt.BrushStyle:
-# class PySide2.QtCore.Qt.CaseSensitivity:
-# class PySide2.QtCore.Qt.CheckState:
-# class PySide2.QtCore.Qt.ChecksumType:
-# class PySide2.QtCore.Qt.ClipOperation:
-# class PySide2.QtCore.Qt.ConnectionType:
-# class PySide2.QtCore.Qt.ContextMenuPolicy:
-# class PySide2.QtCore.Qt.CoordinateSystem:
-# class PySide2.QtCore.Qt.Corner:
-# class PySide2.QtCore.Qt.CursorMoveStyle:
-# class PySide2.QtCore.Qt.CursorShape:
-# class PySide2.QtCore.Qt.DateFormat:
-# class PySide2.QtCore.Qt.DayOfWeek:
-# class PySide2.QtCore.Qt.DockWidgetArea:
-# class PySide2.QtCore.Qt.DockWidgetAreaSizes:
-# class PySide2.QtCore.Qt.DockWidgetAreas:
-# class PySide2.QtCore.Qt.DropAction:
-# class PySide2.QtCore.Qt.DropActions:
-# class PySide2.QtCore.Qt.Edge:
-# class PySide2.QtCore.Qt.Edges:
-# class PySide2.QtCore.Qt.EnterKeyType:
-# class PySide2.QtCore.Qt.EventPriority:
-# class PySide2.QtCore.Qt.FillRule:
-# class PySide2.QtCore.Qt.FindChildOption:
-# class PySide2.QtCore.Qt.FindChildOptions:
-# class PySide2.QtCore.Qt.FocusPolicy:
-# class PySide2.QtCore.Qt.FocusReason:
-# class PySide2.QtCore.Qt.GestureFlag:
-# class PySide2.QtCore.Qt.GestureFlags:
-# class PySide2.QtCore.Qt.GestureState:
-# class PySide2.QtCore.Qt.GestureType:
-# class PySide2.QtCore.Qt.GlobalColor:
-# class PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy:
-# class PySide2.QtCore.Qt.HitTestAccuracy:
-# class PySide2.QtCore.Qt.ImageConversionFlag:
-# class PySide2.QtCore.Qt.ImageConversionFlags:
-# class PySide2.QtCore.Qt.InputMethodHint:
-# class PySide2.QtCore.Qt.InputMethodHints:
-# class PySide2.QtCore.Qt.InputMethodQueries:
-# class PySide2.QtCore.Qt.InputMethodQuery:
-# class PySide2.QtCore.Qt.ItemDataRole:
-# class PySide2.QtCore.Qt.ItemFlag:
-# class PySide2.QtCore.Qt.ItemFlags:
-# class PySide2.QtCore.Qt.ItemSelectionMode:
-# class PySide2.QtCore.Qt.ItemSelectionOperation:
-# class PySide2.QtCore.Qt.Key:
-# class PySide2.QtCore.Qt.KeyboardModifier:
-# class PySide2.QtCore.Qt.KeyboardModifiers:
-# class PySide2.QtCore.Qt.LayoutDirection:
-# class PySide2.QtCore.Qt.MaskMode:
-# class PySide2.QtCore.Qt.MatchFlag:
-# class PySide2.QtCore.Qt.MatchFlags:
-# class PySide2.QtCore.Qt.Modifier:
-# class PySide2.QtCore.Qt.MouseButton:
-# class PySide2.QtCore.Qt.MouseButtons:
-# class PySide2.QtCore.Qt.MouseEventFlag:
-# class PySide2.QtCore.Qt.MouseEventFlags:
-# class PySide2.QtCore.Qt.MouseEventSource:
-# class PySide2.QtCore.Qt.NativeGestureType:
-# class PySide2.QtCore.Qt.NavigationMode:
-# class PySide2.QtCore.Qt.Orientation:
-# class PySide2.QtCore.Qt.Orientations:
-# class PySide2.QtCore.Qt.PenCapStyle:
-# class PySide2.QtCore.Qt.PenJoinStyle:
-# class PySide2.QtCore.Qt.PenStyle:
-# class PySide2.QtCore.Qt.ScreenOrientation:
-# class PySide2.QtCore.Qt.ScreenOrientations:
-# class PySide2.QtCore.Qt.ScrollBarPolicy:
-# class PySide2.QtCore.Qt.ScrollPhase:
-# class PySide2.QtCore.Qt.ShortcutContext:
-# class PySide2.QtCore.Qt.SizeHint:
-# class PySide2.QtCore.Qt.SizeMode:
-# class PySide2.QtCore.Qt.SortOrder:
-# class PySide2.QtCore.Qt.SplitBehavior:
-# class PySide2.QtCore.Qt.SplitBehaviorFlags:
-# class PySide2.QtCore.Qt.TabFocusBehavior:
-# class PySide2.QtCore.Qt.TextElideMode:
-# class PySide2.QtCore.Qt.TextFlag:
-# class PySide2.QtCore.Qt.TextFormat:
-# class PySide2.QtCore.Qt.TextInteractionFlag:
-# class PySide2.QtCore.Qt.TextInteractionFlags:
-# class PySide2.QtCore.Qt.TileRule:
-# class PySide2.QtCore.Qt.TimeSpec:
-# class PySide2.QtCore.Qt.TimerType:
-# class PySide2.QtCore.Qt.ToolBarArea:
-# class PySide2.QtCore.Qt.ToolBarAreaSizes:
-# class PySide2.QtCore.Qt.ToolBarAreas:
-# class PySide2.QtCore.Qt.ToolButtonStyle:
-# class PySide2.QtCore.Qt.TouchPointState:
-# class PySide2.QtCore.Qt.TouchPointStates:
-# class PySide2.QtCore.Qt.TransformationMode:
-# class PySide2.QtCore.Qt.UIEffect:
-# class PySide2.QtCore.Qt.WhiteSpaceMode:
-# class PySide2.QtCore.Qt.WidgetAttribute:
-# class PySide2.QtCore.Qt.WindowFlags:
-# class PySide2.QtCore.Qt.WindowFrameSection:
-# class PySide2.QtCore.Qt.WindowModality:
-# class PySide2.QtCore.Qt.WindowState:
-# class PySide2.QtCore.Qt.WindowStates:
-# class PySide2.QtCore.Qt.WindowType:
-# class PySide2.QtCore.QtMsgType:
-# class PySide2.QtCore.Signal:
-    "PySide2.QtCore.Signal.__init__": ('type', 'str', 'str'),
-# class PySide2.QtCore.SignalInstance:
-    "PySide2.QtCore.SignalInstance.connect": ('object', 'type'),
-    "PySide2.QtCore.SignalInstance.disconnect": ('object',),
-    "PySide2.QtCore.SignalInstance.emit": ('typing.Any',),
-# class PySide2.QtCore.Slot:
-    "PySide2.QtCore.Slot.__init__": ('type', 'str', 'str'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP": ('object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP3": ('object', 'object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.SIGNAL": ('str',),
-    "PySide2.QtCore.Slot.SLOT": ('str',),
-    "PySide2.QtCore.Slot.__moduleShutdown": (),
-    "PySide2.QtCore.Slot.qAbs": ('float',),
-    "PySide2.QtCore.Slot.qAcos": ('float',),
-    "PySide2.QtCore.Slot.qAddPostRoutine": ('object',),
-    "PySide2.QtCore.Slot.qAsin": ('float',),
-    "PySide2.QtCore.Slot.qAtan": ('float',),
-    "PySide2.QtCore.Slot.qAtan2": ('float', 'float'),
-    "PySide2.QtCore.Slot.qChecksum": ('str', 'int'),
-    "PySide2.QtCore.Slot.qCompress": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.Slot.qCritical": ('str',),
-    "PySide2.QtCore.Slot.qDebug": ('str',),
-    "PySide2.QtCore.Slot.qExp": ('float',),
-    "PySide2.QtCore.Slot.qFabs": ('float',),
-    "PySide2.QtCore.Slot.qFastCos": ('float',),
-    "PySide2.QtCore.Slot.qFastSin": ('float',),
-    "PySide2.QtCore.Slot.qFatal": ('str',),
-    "PySide2.QtCore.Slot.qFuzzyCompare": ('float', 'float'),
-    "PySide2.QtCore.Slot.qFuzzyIsNull": ('float',),
-    "PySide2.QtCore.Slot.qInstallMessageHandler": ('object',),
-    "PySide2.QtCore.Slot.qIsFinite": ('float',),
-    "PySide2.QtCore.Slot.qIsInf": ('float',),
-    "PySide2.QtCore.Slot.qIsNaN": ('float',),
-    "PySide2.QtCore.Slot.qIsNull": ('float',),
-    "PySide2.QtCore.Slot.qRegisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qTan": ('float',),
-    "PySide2.QtCore.Slot.qUncompress": [('PySide2.QtCore.QByteArray',), ('str', 'int')],
-    "PySide2.QtCore.Slot.qUnregisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qVersion": (),
-    "PySide2.QtCore.Slot.qWarning": ('str',),
-    "PySide2.QtCore.Slot.qrand": (),
-    "PySide2.QtCore.Slot.qsrand": ('int',),
-    "PySide2.QtCore.Slot.qtTrId": ('str', 'int'),
-    }) if "PySide2.QtCore" in sys.modules else None
-# Module PySide2.QtGui
-sig_dict.update({
-# class PySide2.QtGui.QAbstractOpenGLFunctions:
-    "PySide2.QtGui.QAbstractOpenGLFunctions.__init__": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.isInitialized": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.owningContext": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.setOwningContext": ('PySide2.QtGui.QOpenGLContext',),
-# class PySide2.QtGui.QAbstractTextDocumentLayout:
-# class PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__copy__": (),
-# class PySide2.QtGui.QAbstractTextDocumentLayout.Selection:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.Selection',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__copy__": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.anchorAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockWithMarkerAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.document": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentSize": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.drawInlineObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.format": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatIndex": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.handlerForObject": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.imageAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.pageCount": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.paintDevice": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.positionInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.registerHandler": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.resizeInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.setPaintDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.unregisterHandler": ('int', 'PySide2.QtCore.QObject'),
-# class PySide2.QtGui.QAccessible:
-# class PySide2.QtGui.QAccessible.Event:
-# class PySide2.QtGui.QAccessible.InterfaceType:
-# class PySide2.QtGui.QAccessible.Relation:
-# class PySide2.QtGui.QAccessible.RelationFlag:
-# class PySide2.QtGui.QAccessible.Role:
-# class PySide2.QtGui.QAccessible.State:
-    "PySide2.QtGui.QAccessible.State.__init__": [(), ('PySide2.QtGui.QAccessible.State',)],
-    "PySide2.QtGui.QAccessible.State.__copy__": (),
-# class PySide2.QtGui.QAccessible.Text:
-# class PySide2.QtGui.QAccessible.TextBoundaryType:
-    "PySide2.QtGui.QAccessible.__copy__": (),
-    "PySide2.QtGui.QAccessible.accessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.cleanup": (),
-    "PySide2.QtGui.QAccessible.deleteAccessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.isActive": (),
-    "PySide2.QtGui.QAccessible.qAccessibleTextBoundaryHelper": ('PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessible.queryAccessibleInterface": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.registerAccessibleInterface": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.setActive": ('bool',),
-    "PySide2.QtGui.QAccessible.setRootObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.uniqueId": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.updateAccessibility": ('PySide2.QtGui.QAccessibleEvent',),
-# class PySide2.QtGui.QAccessibleEditableTextInterface:
-    "PySide2.QtGui.QAccessibleEditableTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.deleteText": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.insertText": ('int', 'str'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.replaceText": ('int', 'int', 'str'),
-# class PySide2.QtGui.QAccessibleEvent:
-    "PySide2.QtGui.QAccessibleEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.Event'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.Event')],
-    "PySide2.QtGui.QAccessibleEvent.accessibleInterface": (),
-    "PySide2.QtGui.QAccessibleEvent.child": (),
-    "PySide2.QtGui.QAccessibleEvent.object": (),
-    "PySide2.QtGui.QAccessibleEvent.setChild": ('int',),
-    "PySide2.QtGui.QAccessibleEvent.type": (),
-    "PySide2.QtGui.QAccessibleEvent.uniqueId": (),
-# class PySide2.QtGui.QAccessibleInterface:
-    "PySide2.QtGui.QAccessibleInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleInterface.backgroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.child": ('int',),
-    "PySide2.QtGui.QAccessibleInterface.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.childCount": (),
-    "PySide2.QtGui.QAccessibleInterface.editableTextInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.focusChild": (),
-    "PySide2.QtGui.QAccessibleInterface.foregroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessibleInterface.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtGui.QAccessibleInterface.isValid": (),
-    "PySide2.QtGui.QAccessibleInterface.object": (),
-    "PySide2.QtGui.QAccessibleInterface.parent": (),
-    "PySide2.QtGui.QAccessibleInterface.rect": (),
-    "PySide2.QtGui.QAccessibleInterface.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtGui.QAccessibleInterface.role": (),
-    "PySide2.QtGui.QAccessibleInterface.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-    "PySide2.QtGui.QAccessibleInterface.state": (),
-    "PySide2.QtGui.QAccessibleInterface.tableCellInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtGui.QAccessibleInterface.textInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.valueInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.virtual_hook": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.window": (),
-# class PySide2.QtGui.QAccessibleObject:
-    "PySide2.QtGui.QAccessibleObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessibleObject.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleObject.isValid": (),
-    "PySide2.QtGui.QAccessibleObject.object": (),
-    "PySide2.QtGui.QAccessibleObject.rect": (),
-    "PySide2.QtGui.QAccessibleObject.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-# class PySide2.QtGui.QAccessibleStateChangeEvent:
-    "PySide2.QtGui.QAccessibleStateChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.State'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.State')],
-    "PySide2.QtGui.QAccessibleStateChangeEvent.changedStates": (),
-# class PySide2.QtGui.QAccessibleTableCellInterface:
-    "PySide2.QtGui.QAccessibleTableCellInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.isSelected": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.table": (),
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent:
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType:
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType')],
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.modelChangeType": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setModelChangeType": ('PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType',),
-# class PySide2.QtGui.QAccessibleTextCursorEvent:
-    "PySide2.QtGui.QAccessibleTextCursorEvent.__init__": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int')],
-    "PySide2.QtGui.QAccessibleTextCursorEvent.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextCursorEvent.setCursorPosition": ('int',),
-# class PySide2.QtGui.QAccessibleTextInsertEvent:
-    "PySide2.QtGui.QAccessibleTextInsertEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextInsertEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextInsertEvent.textInserted": (),
-# class PySide2.QtGui.QAccessibleTextInterface:
-    "PySide2.QtGui.QAccessibleTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTextInterface.addSelection": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.attributes": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.characterCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.characterRect": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextInterface.offsetAtPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QAccessibleTextInterface.removeSelection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.scrollToSubstring": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.selection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.selectionCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.setCursorPosition": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.setSelection": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.text": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAfterOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAtOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textBeforeOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-# class PySide2.QtGui.QAccessibleTextRemoveEvent:
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleTextSelectionEvent:
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'int')],
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionEnd": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionStart": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.setSelection": ('int', 'int'),
-# class PySide2.QtGui.QAccessibleTextUpdateEvent:
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str', 'str')],
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textInserted": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleValueChangeEvent:
-    "PySide2.QtGui.QAccessibleValueChangeEvent.__init__": [('PySide2.QtCore.QObject', 'typing.Any'), ('PySide2.QtGui.QAccessibleInterface', 'typing.Any')],
-    "PySide2.QtGui.QAccessibleValueChangeEvent.setValue": ('typing.Any',),
-    "PySide2.QtGui.QAccessibleValueChangeEvent.value": (),
-# class PySide2.QtGui.QAccessibleValueInterface:
-    "PySide2.QtGui.QAccessibleValueInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleValueInterface.currentValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.maximumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumStepSize": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.setCurrentValue": ('typing.Any',),
-# class PySide2.QtGui.QActionEvent:
-# class PySide2.QtGui.QBackingStore:
-    "PySide2.QtGui.QBackingStore.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QBackingStore.beginPaint": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.endPaint": (),
-    "PySide2.QtGui.QBackingStore.flush": ('PySide2.QtGui.QRegion', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QBackingStore.hasStaticContents": (),
-    "PySide2.QtGui.QBackingStore.paintDevice": (),
-    "PySide2.QtGui.QBackingStore.resize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QBackingStore.scroll": ('PySide2.QtGui.QRegion', 'int', 'int'),
-    "PySide2.QtGui.QBackingStore.setStaticContents": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.size": (),
-    "PySide2.QtGui.QBackingStore.staticContents": (),
-    "PySide2.QtGui.QBackingStore.window": (),
-# class PySide2.QtGui.QBitmap:
-    "PySide2.QtGui.QBitmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str')],
-    "PySide2.QtGui.QBitmap.__copy__": (),
-    "PySide2.QtGui.QBitmap.clear": (),
-    "PySide2.QtGui.QBitmap.fromData": ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QImage.Format'),
-    "PySide2.QtGui.QBitmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QBitmap.swap": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBitmap.transformed": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform',)],
-# class PySide2.QtGui.QBrush:
-    "PySide2.QtGui.QBrush.__init__": [(), ('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QBrush',), ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBrush.__copy__": (),
-    "PySide2.QtGui.QBrush.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.color": (),
-    "PySide2.QtGui.QBrush.gradient": (),
-    "PySide2.QtGui.QBrush.isOpaque": (),
-    "PySide2.QtGui.QBrush.matrix": (),
-    "PySide2.QtGui.QBrush.setColor": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',)],
-    "PySide2.QtGui.QBrush.setMatrix": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QBrush.setStyle": ('PySide2.QtCore.Qt.BrushStyle',),
-    "PySide2.QtGui.QBrush.setTexture": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QBrush.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QBrush.setTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QBrush.style": (),
-    "PySide2.QtGui.QBrush.swap": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QBrush.texture": (),
-    "PySide2.QtGui.QBrush.textureImage": (),
-    "PySide2.QtGui.QBrush.transform": (),
-# class PySide2.QtGui.QClipboard:
-# class PySide2.QtGui.QClipboard.Mode:
-    "PySide2.QtGui.QClipboard.clear": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.image": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.mimeData": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.ownsClipboard": (),
-    "PySide2.QtGui.QClipboard.ownsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.ownsSelection": (),
-    "PySide2.QtGui.QClipboard.pixmap": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.setImage": ('PySide2.QtGui.QImage', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setText": ('str', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.supportsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.supportsSelection": (),
-    "PySide2.QtGui.QClipboard.text": [('PySide2.QtGui.QClipboard.Mode',), ('str', 'PySide2.QtGui.QClipboard.Mode')],
-# class PySide2.QtGui.QCloseEvent:
-    "PySide2.QtGui.QCloseEvent.__init__": (),
-# class PySide2.QtGui.QColor:
-# class PySide2.QtGui.QColor.NameFormat:
-# class PySide2.QtGui.QColor.Spec:
-    "PySide2.QtGui.QColor.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor.Spec', 'int', 'int', 'int', 'int', 'int'), ('int',), ('int', 'int', 'int', 'int'), ('str',), ('typing.Any',)],
-    "PySide2.QtGui.QColor.__copy__": (),
-    "PySide2.QtGui.QColor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__reduce__": (),
-    "PySide2.QtGui.QColor.__repr__": (),
-    "PySide2.QtGui.QColor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__setstate__": ('object',),
-    "PySide2.QtGui.QColor.__str__": (),
-    "PySide2.QtGui.QColor.alpha": (),
-    "PySide2.QtGui.QColor.alphaF": (),
-    "PySide2.QtGui.QColor.black": (),
-    "PySide2.QtGui.QColor.blackF": (),
-    "PySide2.QtGui.QColor.blue": (),
-    "PySide2.QtGui.QColor.blueF": (),
-    "PySide2.QtGui.QColor.colorNames": (),
-    "PySide2.QtGui.QColor.convertTo": ('PySide2.QtGui.QColor.Spec',),
-    "PySide2.QtGui.QColor.cyan": (),
-    "PySide2.QtGui.QColor.cyanF": (),
-    "PySide2.QtGui.QColor.dark": ('int',),
-    "PySide2.QtGui.QColor.darker": ('int',),
-    "PySide2.QtGui.QColor.fromCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.fromRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgba": ('int',),
-    "PySide2.QtGui.QColor.fromRgba64": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.getCmyk": (),
-    "PySide2.QtGui.QColor.getCmykF": (),
-    "PySide2.QtGui.QColor.getHsl": (),
-    "PySide2.QtGui.QColor.getHslF": (),
-    "PySide2.QtGui.QColor.getHsv": (),
-    "PySide2.QtGui.QColor.getHsvF": (),
-    "PySide2.QtGui.QColor.getRgb": (),
-    "PySide2.QtGui.QColor.getRgbF": (),
-    "PySide2.QtGui.QColor.green": (),
-    "PySide2.QtGui.QColor.greenF": (),
-    "PySide2.QtGui.QColor.hslHue": (),
-    "PySide2.QtGui.QColor.hslHueF": (),
-    "PySide2.QtGui.QColor.hslSaturation": (),
-    "PySide2.QtGui.QColor.hslSaturationF": (),
-    "PySide2.QtGui.QColor.hsvHue": (),
-    "PySide2.QtGui.QColor.hsvHueF": (),
-    "PySide2.QtGui.QColor.hsvSaturation": (),
-    "PySide2.QtGui.QColor.hsvSaturationF": (),
-    "PySide2.QtGui.QColor.hue": (),
-    "PySide2.QtGui.QColor.hueF": (),
-    "PySide2.QtGui.QColor.isValid": (),
-    "PySide2.QtGui.QColor.isValidColor": ('str',),
-    "PySide2.QtGui.QColor.light": ('int',),
-    "PySide2.QtGui.QColor.lighter": ('int',),
-    "PySide2.QtGui.QColor.lightness": (),
-    "PySide2.QtGui.QColor.lightnessF": (),
-    "PySide2.QtGui.QColor.magenta": (),
-    "PySide2.QtGui.QColor.magentaF": (),
-    "PySide2.QtGui.QColor.name": [(), ('PySide2.QtGui.QColor.NameFormat',)],
-    "PySide2.QtGui.QColor.red": (),
-    "PySide2.QtGui.QColor.redF": (),
-    "PySide2.QtGui.QColor.rgb": (),
-    "PySide2.QtGui.QColor.rgba": (),
-    "PySide2.QtGui.QColor.saturation": (),
-    "PySide2.QtGui.QColor.saturationF": (),
-    "PySide2.QtGui.QColor.setAlpha": ('int',),
-    "PySide2.QtGui.QColor.setAlphaF": ('float',),
-    "PySide2.QtGui.QColor.setBlue": ('int',),
-    "PySide2.QtGui.QColor.setBlueF": ('float',),
-    "PySide2.QtGui.QColor.setCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setGreen": ('int',),
-    "PySide2.QtGui.QColor.setGreenF": ('float',),
-    "PySide2.QtGui.QColor.setHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setNamedColor": ('str',),
-    "PySide2.QtGui.QColor.setRed": ('int',),
-    "PySide2.QtGui.QColor.setRedF": ('float',),
-    "PySide2.QtGui.QColor.setRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.setRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setRgba": ('int',),
-    "PySide2.QtGui.QColor.spec": (),
-    "PySide2.QtGui.QColor.toCmyk": (),
-    "PySide2.QtGui.QColor.toExtendedRgb": (),
-    "PySide2.QtGui.QColor.toHsl": (),
-    "PySide2.QtGui.QColor.toHsv": (),
-    "PySide2.QtGui.QColor.toRgb": (),
-    "PySide2.QtGui.QColor.toTuple": (),
-    "PySide2.QtGui.QColor.value": (),
-    "PySide2.QtGui.QColor.valueF": (),
-    "PySide2.QtGui.QColor.yellow": (),
-    "PySide2.QtGui.QColor.yellowF": (),
-# class PySide2.QtGui.QColorSpace:
-# class PySide2.QtGui.QColorSpace.NamedColorSpace:
-# class PySide2.QtGui.QColorSpace.Primaries:
-# class PySide2.QtGui.QColorSpace.TransferFunction:
-    "PySide2.QtGui.QColorSpace.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace',), ('PySide2.QtGui.QColorSpace.NamedColorSpace',), ('PySide2.QtGui.QColorSpace.Primaries', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace.Primaries', 'float')],
-    "PySide2.QtGui.QColorSpace.__copy__": (),
-    "PySide2.QtGui.QColorSpace.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.fromIccProfile": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QColorSpace.gamma": (),
-    "PySide2.QtGui.QColorSpace.iccProfile": (),
-    "PySide2.QtGui.QColorSpace.isValid": (),
-    "PySide2.QtGui.QColorSpace.primaries": (),
-    "PySide2.QtGui.QColorSpace.setPrimaries": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QColorSpace.Primaries',)],
-    "PySide2.QtGui.QColorSpace.setTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-    "PySide2.QtGui.QColorSpace.swap": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QColorSpace.transferFunction": (),
-    "PySide2.QtGui.QColorSpace.withTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-# class PySide2.QtGui.QConicalGradient:
-    "PySide2.QtGui.QConicalGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QConicalGradient',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QConicalGradient.__copy__": (),
-    "PySide2.QtGui.QConicalGradient.angle": (),
-    "PySide2.QtGui.QConicalGradient.center": (),
-    "PySide2.QtGui.QConicalGradient.setAngle": ('float',),
-    "PySide2.QtGui.QConicalGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-# class PySide2.QtGui.QContextMenuEvent:
-# class PySide2.QtGui.QContextMenuEvent.Reason:
-    "PySide2.QtGui.QContextMenuEvent.__init__": [('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QContextMenuEvent.globalPos": (),
-    "PySide2.QtGui.QContextMenuEvent.globalX": (),
-    "PySide2.QtGui.QContextMenuEvent.global""Y": (),
-    "PySide2.QtGui.QContextMenuEvent.pos": (),
-    "PySide2.QtGui.QContextMenuEvent.reason": (),
-    "PySide2.QtGui.QContextMenuEvent.x": (),
-    "PySide2.QtGui.QContextMenuEvent.y": (),
-# class PySide2.QtGui.QCursor:
-    "PySide2.QtGui.QCursor.__init__": [(), ('PySide2.QtCore.Qt.CursorShape',), ('PySide2.QtGui.QBitmap', 'PySide2.QtGui.QBitmap', 'int', 'int'), ('PySide2.QtGui.QCursor',), ('PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QCursor.__copy__": (),
-    "PySide2.QtGui.QCursor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.bitmap": (),
-    "PySide2.QtGui.QCursor.hotSpot": (),
-    "PySide2.QtGui.QCursor.mask": (),
-    "PySide2.QtGui.QCursor.pixmap": (),
-    "PySide2.QtGui.QCursor.pos": [(), ('PySide2.QtGui.QScreen',)],
-    "PySide2.QtGui.QCursor.setPos": [('PySide2.QtCore.QPoint',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QScreen', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtGui.QCursor.setShape": ('PySide2.QtCore.Qt.CursorShape',),
-    "PySide2.QtGui.QCursor.shape": (),
-    "PySide2.QtGui.QCursor.swap": ('PySide2.QtGui.QCursor',),
-# class PySide2.QtGui.QDesktopServices:
-    "PySide2.QtGui.QDesktopServices.__init__": (),
-    "PySide2.QtGui.QDesktopServices.openUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QDesktopServices.setUrlHandler": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtGui.QDesktopServices.unsetUrlHandler": ('str',),
-# class PySide2.QtGui.QDoubleValidator:
-# class PySide2.QtGui.QDoubleValidator.Notation:
-    "PySide2.QtGui.QDoubleValidator.__init__": [('PySide2.QtCore.QObject',), ('float', 'float', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QDoubleValidator.bottom": (),
-    "PySide2.QtGui.QDoubleValidator.decimals": (),
-    "PySide2.QtGui.QDoubleValidator.notation": (),
-    "PySide2.QtGui.QDoubleValidator.setBottom": ('float',),
-    "PySide2.QtGui.QDoubleValidator.setDecimals": ('int',),
-    "PySide2.QtGui.QDoubleValidator.setNotation": ('PySide2.QtGui.QDoubleValidator.Notation',),
-    "PySide2.QtGui.QDoubleValidator.setRange": ('float', 'float', 'int'),
-    "PySide2.QtGui.QDoubleValidator.setTop": ('float',),
-    "PySide2.QtGui.QDoubleValidator.top": (),
-    "PySide2.QtGui.QDoubleValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QDrag:
-    "PySide2.QtGui.QDrag.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QDrag.cancel": (),
-    "PySide2.QtGui.QDrag.defaultAction": (),
-    "PySide2.QtGui.QDrag.dragCursor": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDrag.exec_": [('PySide2.QtCore.Qt.DropActions',), ('PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.Qt.DropAction')],
-    "PySide2.QtGui.QDrag.hotSpot": (),
-    "PySide2.QtGui.QDrag.mimeData": (),
-    "PySide2.QtGui.QDrag.pixmap": (),
-    "PySide2.QtGui.QDrag.setDragCursor": ('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtGui.QDrag.setHotSpot": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QDrag.setMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtGui.QDrag.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QDrag.source": (),
-    "PySide2.QtGui.QDrag.start": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtGui.QDrag.supportedActions": (),
-    "PySide2.QtGui.QDrag.target": (),
-# class PySide2.QtGui.QDragEnterEvent:
-    "PySide2.QtGui.QDragEnterEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-# class PySide2.QtGui.QDragLeaveEvent:
-    "PySide2.QtGui.QDragLeaveEvent.__init__": (),
-# class PySide2.QtGui.QDragMoveEvent:
-    "PySide2.QtGui.QDragMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDragMoveEvent.accept": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QDragMoveEvent.answerRect": (),
-    "PySide2.QtGui.QDragMoveEvent.ignore": [(), ('PySide2.QtCore.QRect',)],
-# class PySide2.QtGui.QDropEvent:
-    "PySide2.QtGui.QDropEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDropEvent.acceptProposedAction": (),
-    "PySide2.QtGui.QDropEvent.dropAction": (),
-    "PySide2.QtGui.QDropEvent.keyboardModifiers": (),
-    "PySide2.QtGui.QDropEvent.mimeData": (),
-    "PySide2.QtGui.QDropEvent.mouseButtons": (),
-    "PySide2.QtGui.QDropEvent.pos": (),
-    "PySide2.QtGui.QDropEvent.posF": (),
-    "PySide2.QtGui.QDropEvent.possibleActions": (),
-    "PySide2.QtGui.QDropEvent.proposedAction": (),
-    "PySide2.QtGui.QDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDropEvent.source": (),
-# class PySide2.QtGui.QEnterEvent:
-    "PySide2.QtGui.QEnterEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QEnterEvent.globalPos": (),
-    "PySide2.QtGui.QEnterEvent.globalX": (),
-    "PySide2.QtGui.QEnterEvent.global""Y": (),
-    "PySide2.QtGui.QEnterEvent.localPos": (),
-    "PySide2.QtGui.QEnterEvent.pos": (),
-    "PySide2.QtGui.QEnterEvent.screenPos": (),
-    "PySide2.QtGui.QEnterEvent.windowPos": (),
-    "PySide2.QtGui.QEnterEvent.x": (),
-    "PySide2.QtGui.QEnterEvent.y": (),
-# class PySide2.QtGui.QExposeEvent:
-    "PySide2.QtGui.QExposeEvent.__init__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QExposeEvent.region": (),
-# class PySide2.QtGui.QFileOpenEvent:
-    "PySide2.QtGui.QFileOpenEvent.__init__": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtGui.QFileOpenEvent.file": (),
-    "PySide2.QtGui.QFileOpenEvent.openFile": ('PySide2.QtCore.QFile', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtGui.QFileOpenEvent.url": (),
-# class PySide2.QtGui.QFocusEvent:
-    "PySide2.QtGui.QFocusEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtGui.QFocusEvent.gotFocus": (),
-    "PySide2.QtGui.QFocusEvent.lostFocus": (),
-    "PySide2.QtGui.QFocusEvent.reason": (),
-# class PySide2.QtGui.QFont:
-# class PySide2.QtGui.QFont.Capitalization:
-# class PySide2.QtGui.QFont.HintingPreference:
-# class PySide2.QtGui.QFont.SpacingType:
-# class PySide2.QtGui.QFont.Stretch:
-# class PySide2.QtGui.QFont.Style:
-# class PySide2.QtGui.QFont.StyleHint:
-# class PySide2.QtGui.QFont.StyleStrategy:
-# class PySide2.QtGui.QFont.Weight:
-    "PySide2.QtGui.QFont.__init__": [(), ('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('str', 'int', 'int', 'bool')],
-    "PySide2.QtGui.QFont.__copy__": (),
-    "PySide2.QtGui.QFont.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.bold": (),
-    "PySide2.QtGui.QFont.cacheStatistics": (),
-    "PySide2.QtGui.QFont.capitalization": (),
-    "PySide2.QtGui.QFont.cleanup": (),
-    "PySide2.QtGui.QFont.defaultFamily": (),
-    "PySide2.QtGui.QFont.exactMatch": (),
-    "PySide2.QtGui.QFont.families": (),
-    "PySide2.QtGui.QFont.family": (),
-    "PySide2.QtGui.QFont.fixedPitch": (),
-    "PySide2.QtGui.QFont.fromString": ('str',),
-    "PySide2.QtGui.QFont.hintingPreference": (),
-    "PySide2.QtGui.QFont.initialize": (),
-    "PySide2.QtGui.QFont.insertSubstitution": ('str', 'str'),
-    "PySide2.QtGui.QFont.insertSubstitutions": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtGui.QFont.isCopyOf": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.italic": (),
-    "PySide2.QtGui.QFont.kerning": (),
-    "PySide2.QtGui.QFont.key": (),
-    "PySide2.QtGui.QFont.lastResortFamily": (),
-    "PySide2.QtGui.QFont.lastResortFont": (),
-    "PySide2.QtGui.QFont.letterSpacing": (),
-    "PySide2.QtGui.QFont.letterSpacingType": (),
-    "PySide2.QtGui.QFont.overline": (),
-    "PySide2.QtGui.QFont.pixelSize": (),
-    "PySide2.QtGui.QFont.pointSize": (),
-    "PySide2.QtGui.QFont.pointSizeF": (),
-    "PySide2.QtGui.QFont.rawMode": (),
-    "PySide2.QtGui.QFont.rawName": (),
-    "PySide2.QtGui.QFont.removeSubstitutions": ('str',),
-    "PySide2.QtGui.QFont.resolve": [(), ('PySide2.QtGui.QFont',), ('int',)],
-    "PySide2.QtGui.QFont.setBold": ('bool',),
-    "PySide2.QtGui.QFont.setCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QFont.setFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QFont.setFamily": ('str',),
-    "PySide2.QtGui.QFont.setFixedPitch": ('bool',),
-    "PySide2.QtGui.QFont.setHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QFont.setItalic": ('bool',),
-    "PySide2.QtGui.QFont.setKerning": ('bool',),
-    "PySide2.QtGui.QFont.setLetterSpacing": ('PySide2.QtGui.QFont.SpacingType', 'float'),
-    "PySide2.QtGui.QFont.setOverline": ('bool',),
-    "PySide2.QtGui.QFont.setPixelSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSizeF": ('float',),
-    "PySide2.QtGui.QFont.setRawMode": ('bool',),
-    "PySide2.QtGui.QFont.setRawName": ('str',),
-    "PySide2.QtGui.QFont.setStretch": ('int',),
-    "PySide2.QtGui.QFont.setStrikeOut": ('bool',),
-    "PySide2.QtGui.QFont.setStyle": ('PySide2.QtGui.QFont.Style',),
-    "PySide2.QtGui.QFont.setStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QFont.setStyleName": ('str',),
-    "PySide2.QtGui.QFont.setStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QFont.setUnderline": ('bool',),
-    "PySide2.QtGui.QFont.setWeight": ('int',),
-    "PySide2.QtGui.QFont.setWordSpacing": ('float',),
-    "PySide2.QtGui.QFont.stretch": (),
-    "PySide2.QtGui.QFont.strikeOut": (),
-    "PySide2.QtGui.QFont.style": (),
-    "PySide2.QtGui.QFont.styleHint": (),
-    "PySide2.QtGui.QFont.styleName": (),
-    "PySide2.QtGui.QFont.styleStrategy": (),
-    "PySide2.QtGui.QFont.substitute": ('str',),
-    "PySide2.QtGui.QFont.substitutes": ('str',),
-    "PySide2.QtGui.QFont.substitutions": (),
-    "PySide2.QtGui.QFont.swap": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.toString": (),
-    "PySide2.QtGui.QFont.underline": (),
-    "PySide2.QtGui.QFont.weight": (),
-    "PySide2.QtGui.QFont.wordSpacing": (),
-# class PySide2.QtGui.QFontDatabase:
-# class PySide2.QtGui.QFontDatabase.SystemFont:
-# class PySide2.QtGui.QFontDatabase.WritingSystem:
-    "PySide2.QtGui.QFontDatabase.__init__": [(), ('PySide2.QtGui.QFontDatabase',)],
-    "PySide2.QtGui.QFontDatabase.__copy__": (),
-    "PySide2.QtGui.QFontDatabase.addApplicationFont": ('str',),
-    "PySide2.QtGui.QFontDatabase.addApplicationFontFromData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QFontDatabase.applicationFontFamilies": ('int',),
-    "PySide2.QtGui.QFontDatabase.bold": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.families": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.font": ('str', 'str', 'int'),
-    "PySide2.QtGui.QFontDatabase.hasFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isBitmapScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isFixedPitch": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isPrivateFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isSmoothlyScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.italic": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.pointSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.removeAllApplicationFonts": (),
-    "PySide2.QtGui.QFontDatabase.removeApplicationFont": ('int',),
-    "PySide2.QtGui.QFontDatabase.smoothSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.standardSizes": (),
-    "PySide2.QtGui.QFontDatabase.styleString": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontDatabase.styles": ('str',),
-    "PySide2.QtGui.QFontDatabase.supportsThreadedFontRendering": (),
-    "PySide2.QtGui.QFontDatabase.systemFont": ('PySide2.QtGui.QFontDatabase.SystemFont',),
-    "PySide2.QtGui.QFontDatabase.weight": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.writingSystemName": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystemSample": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystems": [(), ('str',)],
-# class PySide2.QtGui.QFontInfo:
-    "PySide2.QtGui.QFontInfo.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontInfo.__copy__": (),
-    "PySide2.QtGui.QFontInfo.bold": (),
-    "PySide2.QtGui.QFontInfo.exactMatch": (),
-    "PySide2.QtGui.QFontInfo.family": (),
-    "PySide2.QtGui.QFontInfo.fixedPitch": (),
-    "PySide2.QtGui.QFontInfo.italic": (),
-    "PySide2.QtGui.QFontInfo.overline": (),
-    "PySide2.QtGui.QFontInfo.pixelSize": (),
-    "PySide2.QtGui.QFontInfo.pointSize": (),
-    "PySide2.QtGui.QFontInfo.pointSizeF": (),
-    "PySide2.QtGui.QFontInfo.rawMode": (),
-    "PySide2.QtGui.QFontInfo.strikeOut": (),
-    "PySide2.QtGui.QFontInfo.style": (),
-    "PySide2.QtGui.QFontInfo.styleHint": (),
-    "PySide2.QtGui.QFontInfo.styleName": (),
-    "PySide2.QtGui.QFontInfo.swap": ('PySide2.QtGui.QFontInfo',),
-    "PySide2.QtGui.QFontInfo.underline": (),
-    "PySide2.QtGui.QFontInfo.weight": (),
-# class PySide2.QtGui.QFontMetrics:
-    "PySide2.QtGui.QFontMetrics.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',)],
-    "PySide2.QtGui.QFontMetrics.__copy__": (),
-    "PySide2.QtGui.QFontMetrics.ascent": (),
-    "PySide2.QtGui.QFontMetrics.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetrics.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('int', 'int', 'int', 'int', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetrics.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.capHeight": (),
-    "PySide2.QtGui.QFontMetrics.charWidth": ('str', 'int'),
-    "PySide2.QtGui.QFontMetrics.descent": (),
-    "PySide2.QtGui.QFontMetrics.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'int', 'int'),
-    "PySide2.QtGui.QFontMetrics.fontDpi": (),
-    "PySide2.QtGui.QFontMetrics.height": (),
-    "PySide2.QtGui.QFontMetrics.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetrics.inFont": ('str',),
-    "PySide2.QtGui.QFontMetrics.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetrics.leading": (),
-    "PySide2.QtGui.QFontMetrics.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.lineSpacing": (),
-    "PySide2.QtGui.QFontMetrics.lineWidth": (),
-    "PySide2.QtGui.QFontMetrics.maxWidth": (),
-    "PySide2.QtGui.QFontMetrics.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetrics.minRightBearing": (),
-    "PySide2.QtGui.QFontMetrics.overlinePos": (),
-    "PySide2.QtGui.QFontMetrics.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetrics.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetrics.swap": ('PySide2.QtGui.QFontMetrics',),
-    "PySide2.QtGui.QFontMetrics.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetrics.underlinePos": (),
-    "PySide2.QtGui.QFontMetrics.width": [('str', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtGui.QFontMetrics.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.xHeight": (),
-# class PySide2.QtGui.QFontMetricsF:
-    "PySide2.QtGui.QFontMetricsF.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',), ('PySide2.QtGui.QFontMetricsF',)],
-    "PySide2.QtGui.QFontMetricsF.__copy__": (),
-    "PySide2.QtGui.QFontMetricsF.ascent": (),
-    "PySide2.QtGui.QFontMetricsF.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetricsF.boundingRect": [('PySide2.QtCore.QRectF', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetricsF.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.capHeight": (),
-    "PySide2.QtGui.QFontMetricsF.descent": (),
-    "PySide2.QtGui.QFontMetricsF.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'float', 'int'),
-    "PySide2.QtGui.QFontMetricsF.fontDpi": (),
-    "PySide2.QtGui.QFontMetricsF.height": (),
-    "PySide2.QtGui.QFontMetricsF.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetricsF.inFont": ('str',),
-    "PySide2.QtGui.QFontMetricsF.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetricsF.leading": (),
-    "PySide2.QtGui.QFontMetricsF.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.lineSpacing": (),
-    "PySide2.QtGui.QFontMetricsF.lineWidth": (),
-    "PySide2.QtGui.QFontMetricsF.maxWidth": (),
-    "PySide2.QtGui.QFontMetricsF.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetricsF.minRightBearing": (),
-    "PySide2.QtGui.QFontMetricsF.overlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetricsF.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetricsF.swap": ('PySide2.QtGui.QFontMetricsF',),
-    "PySide2.QtGui.QFontMetricsF.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetricsF.underlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.width": ('str',),
-    "PySide2.QtGui.QFontMetricsF.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.xHeight": (),
-# class PySide2.QtGui.QGradient:
-# class PySide2.QtGui.QGradient.CoordinateMode:
-# class PySide2.QtGui.QGradient.InterpolationMode:
-# class PySide2.QtGui.QGradient.Preset:
-# class PySide2.QtGui.QGradient.Spread:
-# class PySide2.QtGui.QGradient.Type:
-    "PySide2.QtGui.QGradient.__init__": [(), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QGradient.Preset',)],
-    "PySide2.QtGui.QGradient.__copy__": (),
-    "PySide2.QtGui.QGradient.coordinateMode": (),
-    "PySide2.QtGui.QGradient.interpolationMode": (),
-    "PySide2.QtGui.QGradient.setColorAt": ('float', 'PySide2.QtGui.QColor'),
-    "PySide2.QtGui.QGradient.setCoordinateMode": ('PySide2.QtGui.QGradient.CoordinateMode',),
-    "PySide2.QtGui.QGradient.setInterpolationMode": ('PySide2.QtGui.QGradient.InterpolationMode',),
-    "PySide2.QtGui.QGradient.setSpread": ('PySide2.QtGui.QGradient.Spread',),
-    "PySide2.QtGui.QGradient.setStops": ('typing.List[typing.Tuple]',),
-    "PySide2.QtGui.QGradient.spread": (),
-    "PySide2.QtGui.QGradient.stops": (),
-    "PySide2.QtGui.QGradient.type": (),
-# class PySide2.QtGui.QGuiApplication:
-    "PySide2.QtGui.QGuiApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QGuiApplication.allWindows": (),
-    "PySide2.QtGui.QGuiApplication.applicationDisplayName": (),
-    "PySide2.QtGui.QGuiApplication.applicationState": (),
-    "PySide2.QtGui.QGuiApplication.changeOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.clipboard": (),
-    "PySide2.QtGui.QGuiApplication.desktopFileName": (),
-    "PySide2.QtGui.QGuiApplication.desktopSettingsAware": (),
-    "PySide2.QtGui.QGuiApplication.devicePixelRatio": (),
-    "PySide2.QtGui.QGuiApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QGuiApplication.exec_": (),
-    "PySide2.QtGui.QGuiApplication.focusObject": (),
-    "PySide2.QtGui.QGuiApplication.focusWindow": (),
-    "PySide2.QtGui.QGuiApplication.font": (),
-    "PySide2.QtGui.QGuiApplication.highDpiScaleFactorRoundingPolicy": (),
-    "PySide2.QtGui.QGuiApplication.inputMethod": (),
-    "PySide2.QtGui.QGuiApplication.isFallbackSessionManagementEnabled": (),
-    "PySide2.QtGui.QGuiApplication.isLeftToRight": (),
-    "PySide2.QtGui.QGuiApplication.isRightToLeft": (),
-    "PySide2.QtGui.QGuiApplication.isSavingSession": (),
-    "PySide2.QtGui.QGuiApplication.isSessionRestored": (),
-    "PySide2.QtGui.QGuiApplication.keyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.layoutDirection": (),
-    "PySide2.QtGui.QGuiApplication.modalWindow": (),
-    "PySide2.QtGui.QGuiApplication.mouseButtons": (),
-    "PySide2.QtGui.QGuiApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtGui.QGuiApplication.overrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.palette": (),
-    "PySide2.QtGui.QGuiApplication.platformName": (),
-    "PySide2.QtGui.QGuiApplication.primaryScreen": (),
-    "PySide2.QtGui.QGuiApplication.queryKeyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.quitOnLastWindowClosed": (),
-    "PySide2.QtGui.QGuiApplication.restoreOverrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.screenAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.screens": (),
-    "PySide2.QtGui.QGuiApplication.sessionId": (),
-    "PySide2.QtGui.QGuiApplication.sessionKey": (),
-    "PySide2.QtGui.QGuiApplication.setApplicationDisplayName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopFileName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopSettingsAware": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFallbackSessionManagementEnabled": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QGuiApplication.setHighDpiScaleFactorRoundingPolicy": ('PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy',),
-    "PySide2.QtGui.QGuiApplication.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QGuiApplication.setOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QGuiApplication.setQuitOnLastWindowClosed": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QGuiApplication.styleHints": (),
-    "PySide2.QtGui.QGuiApplication.sync": (),
-    "PySide2.QtGui.QGuiApplication.topLevelAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.topLevelWindows": (),
-    "PySide2.QtGui.QGuiApplication.windowIcon": (),
-# class PySide2.QtGui.QHelpEvent:
-    "PySide2.QtGui.QHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QHelpEvent.globalPos": (),
-    "PySide2.QtGui.QHelpEvent.globalX": (),
-    "PySide2.QtGui.QHelpEvent.global""Y": (),
-    "PySide2.QtGui.QHelpEvent.pos": (),
-    "PySide2.QtGui.QHelpEvent.x": (),
-    "PySide2.QtGui.QHelpEvent.y": (),
-# class PySide2.QtGui.QHideEvent:
-    "PySide2.QtGui.QHideEvent.__init__": (),
-# class PySide2.QtGui.QHoverEvent:
-    "PySide2.QtGui.QHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QHoverEvent.oldPos": (),
-    "PySide2.QtGui.QHoverEvent.oldPosF": (),
-    "PySide2.QtGui.QHoverEvent.pos": (),
-    "PySide2.QtGui.QHoverEvent.posF": (),
-# class PySide2.QtGui.QIcon:
-# class PySide2.QtGui.QIcon.Mode:
-# class PySide2.QtGui.QIcon.State:
-    "PySide2.QtGui.QIcon.__init__": [(), ('PySide2.QtGui.QIcon',), ('PySide2.QtGui.QIconEngine',), ('PySide2.QtGui.QPixmap',), ('str',)],
-    "PySide2.QtGui.QIcon.__copy__": (),
-    "PySide2.QtGui.QIcon.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.actualSize": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.cacheKey": (),
-    "PySide2.QtGui.QIcon.fallbackSearchPaths": (),
-    "PySide2.QtGui.QIcon.fallbackThemeName": (),
-    "PySide2.QtGui.QIcon.fromTheme": [('str',), ('str', 'PySide2.QtGui.QIcon')],
-    "PySide2.QtGui.QIcon.hasThemeIcon": ('str',),
-    "PySide2.QtGui.QIcon.isMask": (),
-    "PySide2.QtGui.QIcon.isNull": (),
-    "PySide2.QtGui.QIcon.name": (),
-    "PySide2.QtGui.QIcon.paint": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QPainter', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.pixmap": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.setFallbackSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.setFallbackThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setIsMask": ('bool',),
-    "PySide2.QtGui.QIcon.setThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setThemeSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.swap": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QIcon.themeName": (),
-    "PySide2.QtGui.QIcon.themeSearchPaths": (),
-# class PySide2.QtGui.QIconDragEvent:
-    "PySide2.QtGui.QIconDragEvent.__init__": (),
-# class PySide2.QtGui.QIconEngine:
-# class PySide2.QtGui.QIconEngine.AvailableSizesArgument:
-    "PySide2.QtGui.QIconEngine.AvailableSizesArgument.__init__": (),
-# class PySide2.QtGui.QIconEngine.IconEngineHook:
-    "PySide2.QtGui.QIconEngine.__init__": [(), ('PySide2.QtGui.QIconEngine',)],
-    "PySide2.QtGui.QIconEngine.actualSize": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.clone": (),
-    "PySide2.QtGui.QIconEngine.iconName": (),
-    "PySide2.QtGui.QIconEngine.isNull": (),
-    "PySide2.QtGui.QIconEngine.key": (),
-    "PySide2.QtGui.QIconEngine.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.pixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIconEngine.scaledPixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State', 'float'),
-    "PySide2.QtGui.QIconEngine.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QImage:
-# class PySide2.QtGui.QImage.Format:
-# class PySide2.QtGui.QImage.InvertMode:
-    "PySide2.QtGui.QImage.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QImage.Format'), ('PySide2.QtGui.QImage',), ('int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'str'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QImage.__copy__": (),
-    "PySide2.QtGui.QImage.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.allGray": (),
-    "PySide2.QtGui.QImage.alphaChannel": (),
-    "PySide2.QtGui.QImage.bitPlaneCount": (),
-    "PySide2.QtGui.QImage.bits": (),
-    "PySide2.QtGui.QImage.byteCount": (),
-    "PySide2.QtGui.QImage.bytesPerLine": (),
-    "PySide2.QtGui.QImage.cacheKey": (),
-    "PySide2.QtGui.QImage.color": ('int',),
-    "PySide2.QtGui.QImage.colorCount": (),
-    "PySide2.QtGui.QImage.colorSpace": (),
-    "PySide2.QtGui.QImage.colorTable": (),
-    "PySide2.QtGui.QImage.constBits": (),
-    "PySide2.QtGui.QImage.constScanLine": ('int',),
-    "PySide2.QtGui.QImage.convertTo": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.convertToFormat": [('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QImage.convertToFormat_helper": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToFormat_inplace": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertedToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QImage.createAlphaMask": ('PySide2.QtCore.Qt.ImageConversionFlags',),
-    "PySide2.QtGui.QImage.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QImage.createMaskFromColor": ('int', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QImage.depth": (),
-    "PySide2.QtGui.QImage.devType": (),
-    "PySide2.QtGui.QImage.devicePixelRatio": (),
-    "PySide2.QtGui.QImage.dotsPerMeterX": (),
-    "PySide2.QtGui.QImage.dotsPerMeterY": (),
-    "PySide2.QtGui.QImage.fill": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('int',)],
-    "PySide2.QtGui.QImage.format": (),
-    "PySide2.QtGui.QImage.fromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.hasAlphaChannel": (),
-    "PySide2.QtGui.QImage.height": (),
-    "PySide2.QtGui.QImage.invertPixels": ('PySide2.QtGui.QImage.InvertMode',),
-    "PySide2.QtGui.QImage.isGrayscale": (),
-    "PySide2.QtGui.QImage.isNull": (),
-    "PySide2.QtGui.QImage.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QImage.loadFromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QImage.mirrored": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_helper": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_inplace": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.offset": (),
-    "PySide2.QtGui.QImage.paintEngine": (),
-    "PySide2.QtGui.QImage.pixel": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelColor": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelFormat": (),
-    "PySide2.QtGui.QImage.pixelIndex": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.rect": (),
-    "PySide2.QtGui.QImage.reinterpretAsFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.rgbSwapped": (),
-    "PySide2.QtGui.QImage.rgbSwapped_helper": (),
-    "PySide2.QtGui.QImage.rgbSwapped_inplace": (),
-    "PySide2.QtGui.QImage.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QImage.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scanLine": ('int',),
-    "PySide2.QtGui.QImage.setAlphaChannel": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.setColor": ('int', 'int'),
-    "PySide2.QtGui.QImage.setColorCount": ('int',),
-    "PySide2.QtGui.QImage.setColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.setColorTable": ('typing.List[int]',),
-    "PySide2.QtGui.QImage.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QImage.setDotsPerMeterX": ('int',),
-    "PySide2.QtGui.QImage.setDotsPerMeterY": ('int',),
-    "PySide2.QtGui.QImage.setOffset": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QImage.setPixel": [('PySide2.QtCore.QPoint', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QImage.setPixelColor": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QImage.setText": ('str', 'str'),
-    "PySide2.QtGui.QImage.size": (),
-    "PySide2.QtGui.QImage.sizeInBytes": (),
-    "PySide2.QtGui.QImage.smoothScaled": ('int', 'int'),
-    "PySide2.QtGui.QImage.swap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.text": ('str',),
-    "PySide2.QtGui.QImage.textKeys": (),
-    "PySide2.QtGui.QImage.toImageFormat": ('PySide2.QtGui.QPixelFormat',),
-    "PySide2.QtGui.QImage.toPixelFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QImage.valid": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.width": (),
-# class PySide2.QtGui.QImageIOHandler:
-# class PySide2.QtGui.QImageIOHandler.ImageOption:
-# class PySide2.QtGui.QImageIOHandler.Transformation:
-# class PySide2.QtGui.QImageIOHandler.Transformations:
-    "PySide2.QtGui.QImageIOHandler.__init__": (),
-    "PySide2.QtGui.QImageIOHandler.canRead": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageNumber": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageRect": (),
-    "PySide2.QtGui.QImageIOHandler.device": (),
-    "PySide2.QtGui.QImageIOHandler.format": (),
-    "PySide2.QtGui.QImageIOHandler.imageCount": (),
-    "PySide2.QtGui.QImageIOHandler.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageIOHandler.jumpToNextImage": (),
-    "PySide2.QtGui.QImageIOHandler.loopCount": (),
-    "PySide2.QtGui.QImageIOHandler.name": (),
-    "PySide2.QtGui.QImageIOHandler.nextImageDelay": (),
-    "PySide2.QtGui.QImageIOHandler.option": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.read": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImageIOHandler.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageIOHandler.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageIOHandler.setOption": ('PySide2.QtGui.QImageIOHandler.ImageOption', 'typing.Any'),
-    "PySide2.QtGui.QImageIOHandler.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QImageReader:
-# class PySide2.QtGui.QImageReader.ImageReaderError:
-    "PySide2.QtGui.QImageReader.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageReader.autoDetectImageFormat": (),
-    "PySide2.QtGui.QImageReader.autoTransform": (),
-    "PySide2.QtGui.QImageReader.backgroundColor": (),
-    "PySide2.QtGui.QImageReader.canRead": (),
-    "PySide2.QtGui.QImageReader.clipRect": (),
-    "PySide2.QtGui.QImageReader.currentImageNumber": (),
-    "PySide2.QtGui.QImageReader.currentImageRect": (),
-    "PySide2.QtGui.QImageReader.decideFormatFromContent": (),
-    "PySide2.QtGui.QImageReader.device": (),
-    "PySide2.QtGui.QImageReader.error": (),
-    "PySide2.QtGui.QImageReader.errorString": (),
-    "PySide2.QtGui.QImageReader.fileName": (),
-    "PySide2.QtGui.QImageReader.format": (),
-    "PySide2.QtGui.QImageReader.gamma": (),
-    "PySide2.QtGui.QImageReader.imageCount": (),
-    "PySide2.QtGui.QImageReader.imageFormat": [(), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QImageReader.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageReader.jumpToNextImage": (),
-    "PySide2.QtGui.QImageReader.loopCount": (),
-    "PySide2.QtGui.QImageReader.nextImageDelay": (),
-    "PySide2.QtGui.QImageReader.quality": (),
-    "PySide2.QtGui.QImageReader.read": (),
-    "PySide2.QtGui.QImageReader.scaledClipRect": (),
-    "PySide2.QtGui.QImageReader.scaledSize": (),
-    "PySide2.QtGui.QImageReader.setAutoDetectImageFormat": ('bool',),
-    "PySide2.QtGui.QImageReader.setAutoTransform": ('bool',),
-    "PySide2.QtGui.QImageReader.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QImageReader.setClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setDecideFormatFromContent": ('bool',),
-    "PySide2.QtGui.QImageReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageReader.setFileName": ('str',),
-    "PySide2.QtGui.QImageReader.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.setGamma": ('float',),
-    "PySide2.QtGui.QImageReader.setQuality": ('int',),
-    "PySide2.QtGui.QImageReader.setScaledClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QImageReader.size": (),
-    "PySide2.QtGui.QImageReader.subType": (),
-    "PySide2.QtGui.QImageReader.supportedImageFormats": (),
-    "PySide2.QtGui.QImageReader.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageReader.supportedSubTypes": (),
-    "PySide2.QtGui.QImageReader.supportsAnimation": (),
-    "PySide2.QtGui.QImageReader.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageReader.text": ('str',),
-    "PySide2.QtGui.QImageReader.textKeys": (),
-    "PySide2.QtGui.QImageReader.transformation": (),
-# class PySide2.QtGui.QImageWriter:
-# class PySide2.QtGui.QImageWriter.ImageWriterError:
-    "PySide2.QtGui.QImageWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageWriter.canWrite": (),
-    "PySide2.QtGui.QImageWriter.compression": (),
-    "PySide2.QtGui.QImageWriter.description": (),
-    "PySide2.QtGui.QImageWriter.device": (),
-    "PySide2.QtGui.QImageWriter.error": (),
-    "PySide2.QtGui.QImageWriter.errorString": (),
-    "PySide2.QtGui.QImageWriter.fileName": (),
-    "PySide2.QtGui.QImageWriter.format": (),
-    "PySide2.QtGui.QImageWriter.gamma": (),
-    "PySide2.QtGui.QImageWriter.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.optimizedWrite": (),
-    "PySide2.QtGui.QImageWriter.progressiveScanWrite": (),
-    "PySide2.QtGui.QImageWriter.quality": (),
-    "PySide2.QtGui.QImageWriter.setCompression": ('int',),
-    "PySide2.QtGui.QImageWriter.setDescription": ('str',),
-    "PySide2.QtGui.QImageWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageWriter.setFileName": ('str',),
-    "PySide2.QtGui.QImageWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setGamma": ('float',),
-    "PySide2.QtGui.QImageWriter.setOptimizedWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setProgressiveScanWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setQuality": ('int',),
-    "PySide2.QtGui.QImageWriter.setSubType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setText": ('str', 'str'),
-    "PySide2.QtGui.QImageWriter.setTransformation": ('PySide2.QtGui.QImageIOHandler.Transformations',),
-    "PySide2.QtGui.QImageWriter.subType": (),
-    "PySide2.QtGui.QImageWriter.supportedImageFormats": (),
-    "PySide2.QtGui.QImageWriter.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageWriter.supportedSubTypes": (),
-    "PySide2.QtGui.QImageWriter.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageWriter.transformation": (),
-    "PySide2.QtGui.QImageWriter.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QInputEvent:
-    "PySide2.QtGui.QInputEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QInputEvent.modifiers": (),
-    "PySide2.QtGui.QInputEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtGui.QInputEvent.setTimestamp": ('int',),
-    "PySide2.QtGui.QInputEvent.timestamp": (),
-# class PySide2.QtGui.QInputMethod:
-# class PySide2.QtGui.QInputMethod.Action:
-    "PySide2.QtGui.QInputMethod.anchorRectangle": (),
-    "PySide2.QtGui.QInputMethod.commit": (),
-    "PySide2.QtGui.QInputMethod.cursorRectangle": (),
-    "PySide2.QtGui.QInputMethod.hide": (),
-    "PySide2.QtGui.QInputMethod.inputDirection": (),
-    "PySide2.QtGui.QInputMethod.inputItemClipRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemTransform": (),
-    "PySide2.QtGui.QInputMethod.invokeAction": ('PySide2.QtGui.QInputMethod.Action', 'int'),
-    "PySide2.QtGui.QInputMethod.isAnimating": (),
-    "PySide2.QtGui.QInputMethod.isVisible": (),
-    "PySide2.QtGui.QInputMethod.keyboardRectangle": (),
-    "PySide2.QtGui.QInputMethod.locale": (),
-    "PySide2.QtGui.QInputMethod.queryFocusObject": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethod.reset": (),
-    "PySide2.QtGui.QInputMethod.setInputItemRectangle": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QInputMethod.setInputItemTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QInputMethod.setVisible": ('bool',),
-    "PySide2.QtGui.QInputMethod.show": (),
-    "PySide2.QtGui.QInputMethod.update": ('PySide2.QtCore.Qt.InputMethodQueries',),
-# class PySide2.QtGui.QInputMethodEvent:
-# class PySide2.QtGui.QInputMethodEvent.Attribute:
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__init__": [('PySide2.QtGui.QInputMethodEvent.Attribute',), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int'), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int', 'typing.Any')],
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__copy__": (),
-# class PySide2.QtGui.QInputMethodEvent.AttributeType:
-    "PySide2.QtGui.QInputMethodEvent.__init__": [(), ('PySide2.QtGui.QInputMethodEvent',), ('str', 'typing.Sequence[PySide2.QtGui.QInputMethodEvent.Attribute]')],
-    "PySide2.QtGui.QInputMethodEvent.attributes": (),
-    "PySide2.QtGui.QInputMethodEvent.commitString": (),
-    "PySide2.QtGui.QInputMethodEvent.preeditString": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementLength": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementStart": (),
-    "PySide2.QtGui.QInputMethodEvent.setCommitString": ('str', 'int', 'int'),
-# class PySide2.QtGui.QInputMethodQueryEvent:
-    "PySide2.QtGui.QInputMethodQueryEvent.__init__": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtGui.QInputMethodQueryEvent.queries": (),
-    "PySide2.QtGui.QInputMethodQueryEvent.setValue": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethodQueryEvent.value": ('PySide2.QtCore.Qt.InputMethodQuery',),
-# class PySide2.QtGui.QIntValidator:
-    "PySide2.QtGui.QIntValidator.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QIntValidator.bottom": (),
-    "PySide2.QtGui.QIntValidator.fixup": ('str',),
-    "PySide2.QtGui.QIntValidator.setBottom": ('int',),
-    "PySide2.QtGui.QIntValidator.setRange": ('int', 'int'),
-    "PySide2.QtGui.QIntValidator.setTop": ('int',),
-    "PySide2.QtGui.QIntValidator.top": (),
-    "PySide2.QtGui.QIntValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QKeyEvent:
-    "PySide2.QtGui.QKeyEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'int', 'int', 'str', 'bool', 'int'), ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtGui.QKeyEvent.count": (),
-    "PySide2.QtGui.QKeyEvent.isAutoRepeat": (),
-    "PySide2.QtGui.QKeyEvent.key": (),
-    "PySide2.QtGui.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeyEvent.modifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeModifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeScanCode": (),
-    "PySide2.QtGui.QKeyEvent.nativeVirtualKey": (),
-    "PySide2.QtGui.QKeyEvent.text": (),
-# class PySide2.QtGui.QKeySequence:
-# class PySide2.QtGui.QKeySequence.SequenceFormat:
-# class PySide2.QtGui.QKeySequence.SequenceMatch:
-# class PySide2.QtGui.QKeySequence.StandardKey:
-    "PySide2.QtGui.QKeySequence.__init__": [(), ('PySide2.QtGui.QKeySequence',), ('PySide2.QtGui.QKeySequence.StandardKey',), ('int', 'int', 'int', 'int'), ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat')],
-    "PySide2.QtGui.QKeySequence.__copy__": (),
-    "PySide2.QtGui.QKeySequence.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.__reduce__": (),
-    "PySide2.QtGui.QKeySequence.__repr__": (),
-    "PySide2.QtGui.QKeySequence.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.count": (),
-    "PySide2.QtGui.QKeySequence.fromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.isEmpty": (),
-    "PySide2.QtGui.QKeySequence.keyBindings": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeySequence.listFromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.listToString": ('typing.Sequence[PySide2.QtGui.QKeySequence]', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.matches": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.mnemonic": ('str',),
-    "PySide2.QtGui.QKeySequence.swap": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.toString": ('PySide2.QtGui.QKeySequence.SequenceFormat',),
-# class PySide2.QtGui.QLinearGradient:
-    "PySide2.QtGui.QLinearGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QLinearGradient',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QLinearGradient.__copy__": (),
-    "PySide2.QtGui.QLinearGradient.finalStop": (),
-    "PySide2.QtGui.QLinearGradient.setFinalStop": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.setStart": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.start": (),
-# class PySide2.QtGui.QMatrix:
-    "PySide2.QtGui.QMatrix.__init__": [(), ('PySide2.QtGui.QMatrix',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix.__copy__": (),
-    "PySide2.QtGui.QMatrix.__imul__": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QMatrix.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix',)],
-    "PySide2.QtGui.QMatrix.__reduce__": (),
-    "PySide2.QtGui.QMatrix.__repr__": (),
-    "PySide2.QtGui.QMatrix.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.determinant": (),
-    "PySide2.QtGui.QMatrix.dx": (),
-    "PySide2.QtGui.QMatrix.dy": (),
-    "PySide2.QtGui.QMatrix.inverted": (),
-    "PySide2.QtGui.QMatrix.isIdentity": (),
-    "PySide2.QtGui.QMatrix.isInvertible": (),
-    "PySide2.QtGui.QMatrix.m11": (),
-    "PySide2.QtGui.QMatrix.m12": (),
-    "PySide2.QtGui.QMatrix.m21": (),
-    "PySide2.QtGui.QMatrix.m22": (),
-    "PySide2.QtGui.QMatrix.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float'), ('int', 'int')],
-    "PySide2.QtGui.QMatrix.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QMatrix.reset": (),
-    "PySide2.QtGui.QMatrix.rotate": ('float',),
-    "PySide2.QtGui.QMatrix.scale": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix.shear": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.translate": ('float', 'float'),
-# class PySide2.QtGui.QMatrix2x2:
-    "PySide2.QtGui.QMatrix2x2.__init__": [(), ('PySide2.QtGui.QMatrix2x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x2.__copy__": (),
-    "PySide2.QtGui.QMatrix2x2.__iadd__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x2.__isub__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x2.__repr__": (),
-    "PySide2.QtGui.QMatrix2x2.data": (),
-    "PySide2.QtGui.QMatrix2x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.transposed": (),
-# class PySide2.QtGui.QMatrix2x3:
-    "PySide2.QtGui.QMatrix2x3.__init__": [(), ('PySide2.QtGui.QMatrix2x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x3.__copy__": (),
-    "PySide2.QtGui.QMatrix2x3.__iadd__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x3.__isub__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x3.__repr__": (),
-    "PySide2.QtGui.QMatrix2x3.data": (),
-    "PySide2.QtGui.QMatrix2x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.transposed": (),
-# class PySide2.QtGui.QMatrix2x4:
-    "PySide2.QtGui.QMatrix2x4.__init__": [(), ('PySide2.QtGui.QMatrix2x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x4.__copy__": (),
-    "PySide2.QtGui.QMatrix2x4.__iadd__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x4.__isub__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x4.__repr__": (),
-    "PySide2.QtGui.QMatrix2x4.data": (),
-    "PySide2.QtGui.QMatrix2x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.transposed": (),
-# class PySide2.QtGui.QMatrix3x2:
-    "PySide2.QtGui.QMatrix3x2.__init__": [(), ('PySide2.QtGui.QMatrix3x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x2.__copy__": (),
-    "PySide2.QtGui.QMatrix3x2.__iadd__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x2.__isub__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x2.__repr__": (),
-    "PySide2.QtGui.QMatrix3x2.data": (),
-    "PySide2.QtGui.QMatrix3x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.transposed": (),
-# class PySide2.QtGui.QMatrix3x3:
-    "PySide2.QtGui.QMatrix3x3.__init__": [(), ('PySide2.QtGui.QMatrix3x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x3.__copy__": (),
-    "PySide2.QtGui.QMatrix3x3.__iadd__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x3.__isub__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x3.__repr__": (),
-    "PySide2.QtGui.QMatrix3x3.data": (),
-    "PySide2.QtGui.QMatrix3x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.transposed": (),
-# class PySide2.QtGui.QMatrix3x4:
-    "PySide2.QtGui.QMatrix3x4.__init__": [(), ('PySide2.QtGui.QMatrix3x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x4.__copy__": (),
-    "PySide2.QtGui.QMatrix3x4.__iadd__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x4.__isub__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x4.__repr__": (),
-    "PySide2.QtGui.QMatrix3x4.data": (),
-    "PySide2.QtGui.QMatrix3x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.transposed": (),
-# class PySide2.QtGui.QMatrix4x2:
-    "PySide2.QtGui.QMatrix4x2.__init__": [(), ('PySide2.QtGui.QMatrix4x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x2.__copy__": (),
-    "PySide2.QtGui.QMatrix4x2.__iadd__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x2.__isub__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x2.__repr__": (),
-    "PySide2.QtGui.QMatrix4x2.data": (),
-    "PySide2.QtGui.QMatrix4x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.transposed": (),
-# class PySide2.QtGui.QMatrix4x3:
-    "PySide2.QtGui.QMatrix4x3.__init__": [(), ('PySide2.QtGui.QMatrix4x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x3.__copy__": (),
-    "PySide2.QtGui.QMatrix4x3.__iadd__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x3.__isub__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x3.__repr__": (),
-    "PySide2.QtGui.QMatrix4x3.data": (),
-    "PySide2.QtGui.QMatrix4x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.transposed": (),
-# class PySide2.QtGui.QMatrix4x4:
-    "PySide2.QtGui.QMatrix4x4.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtGui.QMatrix4x4.__add__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__copy__": (),
-    "PySide2.QtGui.QMatrix4x4.__dummy": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QMatrix4x4.__iadd__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__imul__": [('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__isub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__mul__": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__neg__": (),
-    "PySide2.QtGui.QMatrix4x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x4.__repr__": (),
-    "PySide2.QtGui.QMatrix4x4.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__sub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.column": ('int',),
-    "PySide2.QtGui.QMatrix4x4.copyDataTo": (),
-    "PySide2.QtGui.QMatrix4x4.data": (),
-    "PySide2.QtGui.QMatrix4x4.determinant": (),
-    "PySide2.QtGui.QMatrix4x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x4.flipCoordinates": (),
-    "PySide2.QtGui.QMatrix4x4.frustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.inverted": (),
-    "PySide2.QtGui.QMatrix4x4.isAffine": (),
-    "PySide2.QtGui.QMatrix4x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.lookAt": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QMatrix4x4.map": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',)],
-    "PySide2.QtGui.QMatrix4x4.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix4x4.mapVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QMatrix4x4.normalMatrix": (),
-    "PySide2.QtGui.QMatrix4x4.optimize": (),
-    "PySide2.QtGui.QMatrix4x4.ortho": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.perspective": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.rotate": [('PySide2.QtGui.QQuaternion',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.row": ('int',),
-    "PySide2.QtGui.QMatrix4x4.scale": [('PySide2.QtGui.QVector3D',), ('float',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.setColumn": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setRow": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.toAffine": (),
-    "PySide2.QtGui.QMatrix4x4.toTransform": [(), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.translate": [('PySide2.QtGui.QVector3D',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.transposed": (),
-    "PySide2.QtGui.QMatrix4x4.viewport": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-# class PySide2.QtGui.QMouseEvent:
-    "PySide2.QtGui.QMouseEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QMouseEvent.button": (),
-    "PySide2.QtGui.QMouseEvent.buttons": (),
-    "PySide2.QtGui.QMouseEvent.flags": (),
-    "PySide2.QtGui.QMouseEvent.globalPos": (),
-    "PySide2.QtGui.QMouseEvent.globalX": (),
-    "PySide2.QtGui.QMouseEvent.global""Y": (),
-    "PySide2.QtGui.QMouseEvent.localPos": (),
-    "PySide2.QtGui.QMouseEvent.pos": (),
-    "PySide2.QtGui.QMouseEvent.screenPos": (),
-    "PySide2.QtGui.QMouseEvent.setLocalPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QMouseEvent.source": (),
-    "PySide2.QtGui.QMouseEvent.windowPos": (),
-    "PySide2.QtGui.QMouseEvent.x": (),
-    "PySide2.QtGui.QMouseEvent.y": (),
-# class PySide2.QtGui.QMoveEvent:
-    "PySide2.QtGui.QMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QMoveEvent.oldPos": (),
-    "PySide2.QtGui.QMoveEvent.pos": (),
-# class PySide2.QtGui.QMovie:
-# class PySide2.QtGui.QMovie.CacheMode:
-# class PySide2.QtGui.QMovie.MovieState:
-    "PySide2.QtGui.QMovie.__init__": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QMovie.backgroundColor": (),
-    "PySide2.QtGui.QMovie.cacheMode": (),
-    "PySide2.QtGui.QMovie.currentFrameNumber": (),
-    "PySide2.QtGui.QMovie.currentImage": (),
-    "PySide2.QtGui.QMovie.currentPixmap": (),
-    "PySide2.QtGui.QMovie.device": (),
-    "PySide2.QtGui.QMovie.fileName": (),
-    "PySide2.QtGui.QMovie.format": (),
-    "PySide2.QtGui.QMovie.frameCount": (),
-    "PySide2.QtGui.QMovie.frameRect": (),
-    "PySide2.QtGui.QMovie.isValid": (),
-    "PySide2.QtGui.QMovie.jumpToFrame": ('int',),
-    "PySide2.QtGui.QMovie.jumpToNextFrame": (),
-    "PySide2.QtGui.QMovie.lastError": (),
-    "PySide2.QtGui.QMovie.lastErrorString": (),
-    "PySide2.QtGui.QMovie.loopCount": (),
-    "PySide2.QtGui.QMovie.nextFrameDelay": (),
-    "PySide2.QtGui.QMovie.scaledSize": (),
-    "PySide2.QtGui.QMovie.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QMovie.setCacheMode": ('PySide2.QtGui.QMovie.CacheMode',),
-    "PySide2.QtGui.QMovie.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QMovie.setFileName": ('str',),
-    "PySide2.QtGui.QMovie.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QMovie.setPaused": ('bool',),
-    "PySide2.QtGui.QMovie.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QMovie.setSpeed": ('int',),
-    "PySide2.QtGui.QMovie.speed": (),
-    "PySide2.QtGui.QMovie.start": (),
-    "PySide2.QtGui.QMovie.state": (),
-    "PySide2.QtGui.QMovie.stop": (),
-    "PySide2.QtGui.QMovie.supportedFormats": (),
-# class PySide2.QtGui.QNativeGestureEvent:
-    "PySide2.QtGui.QNativeGestureEvent.__init__": [('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int'), ('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int')],
-    "PySide2.QtGui.QNativeGestureEvent.device": (),
-    "PySide2.QtGui.QNativeGestureEvent.gestureType": (),
-    "PySide2.QtGui.QNativeGestureEvent.globalPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.localPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.pos": (),
-    "PySide2.QtGui.QNativeGestureEvent.screenPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.value": (),
-    "PySide2.QtGui.QNativeGestureEvent.windowPos": (),
-# class PySide2.QtGui.QOffscreenSurface:
-    "PySide2.QtGui.QOffscreenSurface.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QOffscreenSurface.create": (),
-    "PySide2.QtGui.QOffscreenSurface.destroy": (),
-    "PySide2.QtGui.QOffscreenSurface.format": (),
-    "PySide2.QtGui.QOffscreenSurface.isValid": (),
-    "PySide2.QtGui.QOffscreenSurface.nativeHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.requestedFormat": (),
-    "PySide2.QtGui.QOffscreenSurface.screen": (),
-    "PySide2.QtGui.QOffscreenSurface.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOffscreenSurface.setNativeHandle": ('int',),
-    "PySide2.QtGui.QOffscreenSurface.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOffscreenSurface.size": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceType": (),
-# class PySide2.QtGui.QOpenGLBuffer:
-# class PySide2.QtGui.QOpenGLBuffer.Access:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlag:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags:
-# class PySide2.QtGui.QOpenGLBuffer.Type:
-# class PySide2.QtGui.QOpenGLBuffer.UsagePattern:
-    "PySide2.QtGui.QOpenGLBuffer.__init__": [(), ('PySide2.QtGui.QOpenGLBuffer',), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QOpenGLBuffer.bind": (),
-    "PySide2.QtGui.QOpenGLBuffer.bufferId": (),
-    "PySide2.QtGui.QOpenGLBuffer.create": (),
-    "PySide2.QtGui.QOpenGLBuffer.destroy": (),
-    "PySide2.QtGui.QOpenGLBuffer.isCreated": (),
-    "PySide2.QtGui.QOpenGLBuffer.map": ('PySide2.QtGui.QOpenGLBuffer.Access',),
-    "PySide2.QtGui.QOpenGLBuffer.mapRange": ('int', 'int', 'PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags'),
-    "PySide2.QtGui.QOpenGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLBuffer.release": [(), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.setUsagePattern": ('PySide2.QtGui.QOpenGLBuffer.UsagePattern',),
-    "PySide2.QtGui.QOpenGLBuffer.size": (),
-    "PySide2.QtGui.QOpenGLBuffer.type": (),
-    "PySide2.QtGui.QOpenGLBuffer.unmap": (),
-    "PySide2.QtGui.QOpenGLBuffer.usagePattern": (),
-    "PySide2.QtGui.QOpenGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtGui.QOpenGLContext:
-# class PySide2.QtGui.QOpenGLContext.OpenGLModuleType:
-    "PySide2.QtGui.QOpenGLContext.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLContext.areSharing": ('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLContext.create": (),
-    "PySide2.QtGui.QOpenGLContext.currentContext": (),
-    "PySide2.QtGui.QOpenGLContext.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLContext.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLContext.extensions": (),
-    "PySide2.QtGui.QOpenGLContext.extraFunctions": (),
-    "PySide2.QtGui.QOpenGLContext.format": (),
-    "PySide2.QtGui.QOpenGLContext.functions": (),
-    "PySide2.QtGui.QOpenGLContext.globalShareContext": (),
-    "PySide2.QtGui.QOpenGLContext.hasExtension": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QOpenGLContext.isOpenGLES": (),
-    "PySide2.QtGui.QOpenGLContext.isValid": (),
-    "PySide2.QtGui.QOpenGLContext.makeCurrent": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.nativeHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleType": (),
-    "PySide2.QtGui.QOpenGLContext.screen": (),
-    "PySide2.QtGui.QOpenGLContext.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOpenGLContext.setNativeHandle": ('typing.Any',),
-    "PySide2.QtGui.QOpenGLContext.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOpenGLContext.setShareContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLContext.shareContext": (),
-    "PySide2.QtGui.QOpenGLContext.shareGroup": (),
-    "PySide2.QtGui.QOpenGLContext.supportsThreadedOpenGL": (),
-    "PySide2.QtGui.QOpenGLContext.surface": (),
-    "PySide2.QtGui.QOpenGLContext.swapBuffers": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.versionFunctions": ('PySide2.QtGui.QOpenGLVersionProfile',),
-# class PySide2.QtGui.QOpenGLContextGroup:
-    "PySide2.QtGui.QOpenGLContextGroup.currentContextGroup": (),
-    "PySide2.QtGui.QOpenGLContextGroup.shares": (),
-# class PySide2.QtGui.QOpenGLDebugLogger:
-# class PySide2.QtGui.QOpenGLDebugLogger.LoggingMode:
-    "PySide2.QtGui.QOpenGLDebugLogger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLDebugLogger.disableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.enableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.initialize": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.isLogging": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.logMessage": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggedMessages": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggingMode": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.maximumMessageLength": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.popGroup": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.pushGroup": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Source'),
-    "PySide2.QtGui.QOpenGLDebugLogger.startLogging": ('PySide2.QtGui.QOpenGLDebugLogger.LoggingMode',),
-    "PySide2.QtGui.QOpenGLDebugLogger.stopLogging": (),
-# class PySide2.QtGui.QOpenGLDebugMessage:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severities:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severity:
-# class PySide2.QtGui.QOpenGLDebugMessage.Source:
-# class PySide2.QtGui.QOpenGLDebugMessage.Sources:
-# class PySide2.QtGui.QOpenGLDebugMessage.Type:
-# class PySide2.QtGui.QOpenGLDebugMessage.Types:
-    "PySide2.QtGui.QOpenGLDebugMessage.__init__": [(), ('PySide2.QtGui.QOpenGLDebugMessage',)],
-    "PySide2.QtGui.QOpenGLDebugMessage.__copy__": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.createApplicationMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.createThirdPartyMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.id": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.message": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.severity": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.source": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.swap": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugMessage.type": (),
-# class PySide2.QtGui.QOpenGLExtraFunctions:
-    "PySide2.QtGui.QOpenGLExtraFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLExtraFunctions.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginQuery": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindSampler": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendBarrier": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageControl": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDisablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEnablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEndQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformBlockiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformsiv": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetBufferParameteri64v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFramebufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetGraphicsResetStatus": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64i_v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64v": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetIntegeri_v": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInternalformativ": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetMultisamplefv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramBinary": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramInterfaceiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramPipelineiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceiv": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryObjectuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetStringi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameterfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformfv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformuiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateSubFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsSampler": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrier": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMinSampleShading": ('float',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPopDebugGroup": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPrimitiveBoundingBox": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSampleMaski": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1ui": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUnmapBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glValidateProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4iv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4uiv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexBindingDivisor": ('int', 'int'),
-# class PySide2.QtGui.QOpenGLFramebufferObject:
-# class PySide2.QtGui.QOpenGLFramebufferObject.Attachment:
-# class PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy:
-    "PySide2.QtGui.QOpenGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.addColorAttachment": [('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bind": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bindDefault": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.blitFramebuffer": [('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtGui.QOpenGLFramebufferObject', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.format": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.handle": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.height": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isBound": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isValid": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.release": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObject.size": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.sizes": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.takeTexture": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLFramebufferObject.texture": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.textures": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.toImage": [(), ('bool',), ('bool', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.width": (),
-# class PySide2.QtGui.QOpenGLFramebufferObjectFormat:
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtGui.QOpenGLFramebufferObjectFormat',)],
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtGui.QOpenGLFunctions:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeature:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeatures:
-    "PySide2.QtGui.QOpenGLFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLFunctions.glActiveTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glAttachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindBuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindTexture": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquation": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFunc": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClear": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glClearDepthf": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearStencil": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompileShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateProgram": (),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCullFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthFunc": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthRangef": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glDetachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDisable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glEnable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glFinish": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFlush": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFrontFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGenBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenerateMipmap": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttachedShaders": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetBufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetError": (),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFloatv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFramebufferAttachmentParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetIntegerv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetProgramiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetRenderbufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderPrecisionFormat": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetString": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glHint": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glIsBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsEnabled": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsFramebuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsRenderbuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glLineWidth": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glLinkProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glPixelStorei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glReleaseShaderCompiler": (),
-    "PySide2.QtGui.QOpenGLFunctions.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glShaderBinary": ('int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1i": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUseProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glValidateProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.hasOpenGLFeature": ('PySide2.QtGui.QOpenGLFunctions.OpenGLFeature',),
-    "PySide2.QtGui.QOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QOpenGLFunctions.openGLFeatures": (),
-# class PySide2.QtGui.QOpenGLPixelTransferOptions:
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__init__": [(), ('PySide2.QtGui.QOpenGLPixelTransferOptions',)],
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__copy__": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.alignment": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.imageHeight": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isLeastSignificantBitFirst": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isSwapBytesEnabled": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.rowLength": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setAlignment": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setImageHeight": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setLeastSignificantByteFirst": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setRowLength": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipImages": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipPixels": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipRows": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSwapBytesEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipImages": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipPixels": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipRows": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.swap": ('PySide2.QtGui.QOpenGLPixelTransferOptions',),
-# class PySide2.QtGui.QOpenGLShader:
-# class PySide2.QtGui.QOpenGLShader.ShaderType:
-# class PySide2.QtGui.QOpenGLShader.ShaderTypeBit:
-    "PySide2.QtGui.QOpenGLShader.__init__": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QOpenGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShader.compileSourceFile": ('str',),
-    "PySide2.QtGui.QOpenGLShader.hasOpenGLShaders": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLShader.isCompiled": (),
-    "PySide2.QtGui.QOpenGLShader.log": (),
-    "PySide2.QtGui.QOpenGLShader.shaderId": (),
-    "PySide2.QtGui.QOpenGLShader.shaderType": (),
-    "PySide2.QtGui.QOpenGLShader.sourceCode": (),
-# class PySide2.QtGui.QOpenGLShaderProgram:
-    "PySide2.QtGui.QOpenGLShaderProgram.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.bind": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.create": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultInnerTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultOuterTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLShaderProgram.isLinked": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.link": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.log": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.patchVertexCount": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.programId": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.release": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeArray": [('int', 'int', 'int', 'int', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'int', 'int', 'int', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultInnerTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultOuterTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setPatchVertexCount": ('int',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple]'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple]')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1f": [('int', 'float'), ('str', 'float')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1i": [('int', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValueArray": [('int', 'shibokensupport.typing27.Sequence', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'shibokensupport.typing27.Sequence', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.shaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtGui.QOpenGLTexture:
-# class PySide2.QtGui.QOpenGLTexture.BindingTarget:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonFunction:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonMode:
-# class PySide2.QtGui.QOpenGLTexture.CoordinateDirection:
-# class PySide2.QtGui.QOpenGLTexture.CubeMapFace:
-# class PySide2.QtGui.QOpenGLTexture.DepthStencilMode:
-# class PySide2.QtGui.QOpenGLTexture.Feature:
-# class PySide2.QtGui.QOpenGLTexture.Features:
-# class PySide2.QtGui.QOpenGLTexture.Filter:
-# class PySide2.QtGui.QOpenGLTexture.MipMapGeneration:
-# class PySide2.QtGui.QOpenGLTexture.PixelFormat:
-# class PySide2.QtGui.QOpenGLTexture.PixelType:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleComponent:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleValue:
-# class PySide2.QtGui.QOpenGLTexture.Target:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormat:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormatClass:
-# class PySide2.QtGui.QOpenGLTexture.TextureUnitReset:
-# class PySide2.QtGui.QOpenGLTexture.WrapMode:
-    "PySide2.QtGui.QOpenGLTexture.__init__": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.Target',)],
-    "PySide2.QtGui.QOpenGLTexture.allocateStorage": [(), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType')],
-    "PySide2.QtGui.QOpenGLTexture.bind": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.borderColor": (),
-    "PySide2.QtGui.QOpenGLTexture.boundTextureId": [('PySide2.QtGui.QOpenGLTexture.BindingTarget',), ('int', 'PySide2.QtGui.QOpenGLTexture.BindingTarget')],
-    "PySide2.QtGui.QOpenGLTexture.comparisonFunction": (),
-    "PySide2.QtGui.QOpenGLTexture.comparisonMode": (),
-    "PySide2.QtGui.QOpenGLTexture.create": (),
-    "PySide2.QtGui.QOpenGLTexture.createTextureView": ('PySide2.QtGui.QOpenGLTexture.Target', 'PySide2.QtGui.QOpenGLTexture.TextureFormat', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.depth": (),
-    "PySide2.QtGui.QOpenGLTexture.depthStencilMode": (),
-    "PySide2.QtGui.QOpenGLTexture.destroy": (),
-    "PySide2.QtGui.QOpenGLTexture.faces": (),
-    "PySide2.QtGui.QOpenGLTexture.format": (),
-    "PySide2.QtGui.QOpenGLTexture.generateMipMaps": [(), ('int', 'bool')],
-    "PySide2.QtGui.QOpenGLTexture.hasFeature": ('PySide2.QtGui.QOpenGLTexture.Feature',),
-    "PySide2.QtGui.QOpenGLTexture.height": (),
-    "PySide2.QtGui.QOpenGLTexture.isAutoMipMapGenerationEnabled": (),
-    "PySide2.QtGui.QOpenGLTexture.isBound": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLTexture.isCreated": (),
-    "PySide2.QtGui.QOpenGLTexture.isFixedSamplePositions": (),
-    "PySide2.QtGui.QOpenGLTexture.isStorageAllocated": (),
-    "PySide2.QtGui.QOpenGLTexture.isTextureView": (),
-    "PySide2.QtGui.QOpenGLTexture.layers": (),
-    "PySide2.QtGui.QOpenGLTexture.levelOfDetailRange": (),
-    "PySide2.QtGui.QOpenGLTexture.levelofDetailBias": (),
-    "PySide2.QtGui.QOpenGLTexture.magnificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumAnisotropy": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumMipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.minMagFilters": (),
-    "PySide2.QtGui.QOpenGLTexture.minificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.minimumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.mipBaseLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevelRange": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.mipMaxLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.release": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.samples": (),
-    "PySide2.QtGui.QOpenGLTexture.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setBorderColor": [('PySide2.QtGui.QColor',), ('float', 'float', 'float', 'float'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLTexture.setComparisonFunction": ('PySide2.QtGui.QOpenGLTexture.ComparisonFunction',),
-    "PySide2.QtGui.QOpenGLTexture.setComparisonMode": ('PySide2.QtGui.QOpenGLTexture.ComparisonMode',),
-    "PySide2.QtGui.QOpenGLTexture.setCompressedData": [('int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setData": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setDepthStencilMode": ('PySide2.QtGui.QOpenGLTexture.DepthStencilMode',),
-    "PySide2.QtGui.QOpenGLTexture.setFixedSamplePositions": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.QtGui.QOpenGLTexture.setLayers": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setLevelOfDetailRange": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLTexture.setLevelofDetailBias": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMagnificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMinMagFilters": ('PySide2.QtGui.QOpenGLTexture.Filter', 'PySide2.QtGui.QOpenGLTexture.Filter'),
-    "PySide2.QtGui.QOpenGLTexture.setMinificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMinimumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMipBaseLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevelRange": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevels": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipMaxLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setSwizzleMask": [('PySide2.QtGui.QOpenGLTexture.SwizzleComponent', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue'), ('PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue')],
-    "PySide2.QtGui.QOpenGLTexture.setWrapMode": [('PySide2.QtGui.QOpenGLTexture.CoordinateDirection', 'PySide2.QtGui.QOpenGLTexture.WrapMode'), ('PySide2.QtGui.QOpenGLTexture.WrapMode',)],
-    "PySide2.QtGui.QOpenGLTexture.swizzleMask": ('PySide2.QtGui.QOpenGLTexture.SwizzleComponent',),
-    "PySide2.QtGui.QOpenGLTexture.target": (),
-    "PySide2.QtGui.QOpenGLTexture.textureId": (),
-    "PySide2.QtGui.QOpenGLTexture.width": (),
-    "PySide2.QtGui.QOpenGLTexture.wrapMode": ('PySide2.QtGui.QOpenGLTexture.CoordinateDirection',),
-# class PySide2.QtGui.QOpenGLTextureBlitter:
-# class PySide2.QtGui.QOpenGLTextureBlitter.Origin:
-    "PySide2.QtGui.QOpenGLTextureBlitter.__init__": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.bind": ('int',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.blit": [('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin')],
-    "PySide2.QtGui.QOpenGLTextureBlitter.create": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.destroy": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.isCreated": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.release": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setOpacity": ('float',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setRedBlueSwizzle": ('bool',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.sourceTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin'),
-    "PySide2.QtGui.QOpenGLTextureBlitter.supportsExternalOESTarget": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.targetTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect'),
-# class PySide2.QtGui.QOpenGLTimeMonitor:
-    "PySide2.QtGui.QOpenGLTimeMonitor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.create": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.destroy": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.objectIds": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.recordSample": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.reset": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.sampleCount": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.setSampleCount": ('int',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForIntervals": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForSamples": (),
-# class PySide2.QtGui.QOpenGLTimerQuery:
-    "PySide2.QtGui.QOpenGLTimerQuery.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimerQuery.begin": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.create": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.destroy": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.end": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.objectId": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.recordTimestamp": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForResult": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForTimestamp": (),
-# class PySide2.QtGui.QOpenGLVersionProfile:
-    "PySide2.QtGui.QOpenGLVersionProfile.__init__": [(), ('PySide2.QtGui.QOpenGLVersionProfile',), ('PySide2.QtGui.QSurfaceFormat',)],
-    "PySide2.QtGui.QOpenGLVersionProfile.__copy__": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.hasProfiles": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isLegacyVersion": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isValid": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.profile": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QOpenGLVersionProfile.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLVersionProfile.version": (),
-# class PySide2.QtGui.QOpenGLVertexArrayObject:
-# class PySide2.QtGui.QOpenGLVertexArrayObject.Binder:
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.__init__": ('PySide2.QtGui.QOpenGLVertexArrayObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.rebind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.release": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.bind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.create": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.destroy": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.isCreated": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.objectId": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.release": (),
-# class PySide2.QtGui.QOpenGLWindow:
-# class PySide2.QtGui.QOpenGLWindow.UpdateBehavior:
-    "PySide2.QtGui.QOpenGLWindow.__init__": [('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow'), ('PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtGui.QOpenGLWindow.context": (),
-    "PySide2.QtGui.QOpenGLWindow.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLWindow.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.grabFramebuffer": (),
-    "PySide2.QtGui.QOpenGLWindow.initializeGL": (),
-    "PySide2.QtGui.QOpenGLWindow.isValid": (),
-    "PySide2.QtGui.QOpenGLWindow.makeCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QOpenGLWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QOpenGLWindow.paintGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintOverGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintUnderGL": (),
-    "PySide2.QtGui.QOpenGLWindow.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QOpenGLWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QOpenGLWindow.resizeGL": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLWindow.shareContext": (),
-    "PySide2.QtGui.QOpenGLWindow.updateBehavior": (),
-# class PySide2.QtGui.QPageLayout:
-# class PySide2.QtGui.QPageLayout.Mode:
-# class PySide2.QtGui.QPageLayout.Orientation:
-# class PySide2.QtGui.QPageLayout.Unit:
-    "PySide2.QtGui.QPageLayout.__init__": [(), ('PySide2.QtGui.QPageLayout',), ('PySide2.QtGui.QPageSize', 'PySide2.QtGui.QPageLayout.Orientation', 'PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit', 'PySide2.QtCore.QMarginsF')],
-    "PySide2.QtGui.QPageLayout.__copy__": (),
-    "PySide2.QtGui.QPageLayout.fullRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.fullRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.fullRectPoints": (),
-    "PySide2.QtGui.QPageLayout.isEquivalentTo": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.isValid": (),
-    "PySide2.QtGui.QPageLayout.margins": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.marginsPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.marginsPoints": (),
-    "PySide2.QtGui.QPageLayout.maximumMargins": (),
-    "PySide2.QtGui.QPageLayout.minimumMargins": (),
-    "PySide2.QtGui.QPageLayout.mode": (),
-    "PySide2.QtGui.QPageLayout.orientation": (),
-    "PySide2.QtGui.QPageLayout.pageSize": (),
-    "PySide2.QtGui.QPageLayout.paintRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.paintRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.paintRectPoints": (),
-    "PySide2.QtGui.QPageLayout.setBottomMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setLeftMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMinimumMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMode": ('PySide2.QtGui.QPageLayout.Mode',),
-    "PySide2.QtGui.QPageLayout.setOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPageLayout.setPageSize": ('PySide2.QtGui.QPageSize', 'PySide2.QtCore.QMarginsF'),
-    "PySide2.QtGui.QPageLayout.setRightMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setTopMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setUnits": ('PySide2.QtGui.QPageLayout.Unit',),
-    "PySide2.QtGui.QPageLayout.swap": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.units": (),
-# class PySide2.QtGui.QPageSize:
-# class PySide2.QtGui.QPageSize.PageSizeId:
-# class PySide2.QtGui.QPageSize.SizeMatchPolicy:
-# class PySide2.QtGui.QPageSize.Unit:
-    "PySide2.QtGui.QPageSize.__init__": [(), ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.__copy__": (),
-    "PySide2.QtGui.QPageSize.definitionSize": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.definitionUnits": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.id": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('int',)],
-    "PySide2.QtGui.QPageSize.isEquivalentTo": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.isValid": (),
-    "PySide2.QtGui.QPageSize.key": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.name": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.rect": ('PySide2.QtGui.QPageSize.Unit',),
-    "PySide2.QtGui.QPageSize.rectPixels": ('int',),
-    "PySide2.QtGui.QPageSize.rectPoints": (),
-    "PySide2.QtGui.QPageSize.size": [('PySide2.QtGui.QPageSize.PageSizeId', 'PySide2.QtGui.QPageSize.Unit'), ('PySide2.QtGui.QPageSize.Unit',)],
-    "PySide2.QtGui.QPageSize.sizePixels": [('PySide2.QtGui.QPageSize.PageSizeId', 'int'), ('int',)],
-    "PySide2.QtGui.QPageSize.sizePoints": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.swap": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.windowsId": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-# class PySide2.QtGui.QPagedPaintDevice:
-# class PySide2.QtGui.QPagedPaintDevice.Margins:
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__init__": [(), ('PySide2.QtGui.QPagedPaintDevice.Margins',)],
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__copy__": (),
-# class PySide2.QtGui.QPagedPaintDevice.PageSize:
-# class PySide2.QtGui.QPagedPaintDevice.PdfVersion:
-    "PySide2.QtGui.QPagedPaintDevice.__init__": (),
-    "PySide2.QtGui.QPagedPaintDevice.devicePageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.margins": (),
-    "PySide2.QtGui.QPagedPaintDevice.newPage": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSize": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSizeMM": (),
-    "PySide2.QtGui.QPagedPaintDevice.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageLayout": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit')],
-    "PySide2.QtGui.QPagedPaintDevice.setPageOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtGui.QPagedPaintDevice.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtGui.QPaintDevice:
-# class PySide2.QtGui.QPaintDevice.PaintDeviceMetric:
-    "PySide2.QtGui.QPaintDevice.__init__": (),
-    "PySide2.QtGui.QPaintDevice.colorCount": (),
-    "PySide2.QtGui.QPaintDevice.depth": (),
-    "PySide2.QtGui.QPaintDevice.devType": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatio": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioF": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioFScale": (),
-    "PySide2.QtGui.QPaintDevice.height": (),
-    "PySide2.QtGui.QPaintDevice.heightMM": (),
-    "PySide2.QtGui.QPaintDevice.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPaintDevice.logicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.logicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDevice.paintEngine": (),
-    "PySide2.QtGui.QPaintDevice.paintingActive": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPaintDevice.sharedPainter": (),
-    "PySide2.QtGui.QPaintDevice.width": (),
-    "PySide2.QtGui.QPaintDevice.widthMM": (),
-# class PySide2.QtGui.QPaintDeviceWindow:
-    "PySide2.QtGui.QPaintDeviceWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEngine": (),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-# class PySide2.QtGui.QPaintEngine:
-# class PySide2.QtGui.QPaintEngine.DirtyFlag:
-# class PySide2.QtGui.QPaintEngine.DirtyFlags:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeature:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeatures:
-# class PySide2.QtGui.QPaintEngine.PolygonDrawMode:
-# class PySide2.QtGui.QPaintEngine.Type:
-    "PySide2.QtGui.QPaintEngine.__init__": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPaintEngine.clearDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.coordinateOffset": (),
-    "PySide2.QtGui.QPaintEngine.drawEllipse": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QPaintEngine.drawImage": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPaintEngine.drawLines": [('PySide2.QtCore.QLine', 'int'), ('PySide2.QtCore.QLineF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPaintEngine.drawPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QPaintEngine.drawPoints": [('PySide2.QtCore.QPoint', 'int'), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPolygon": [('PySide2.QtCore.QPoint', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode')],
-    "PySide2.QtGui.QPaintEngine.drawRects": [('PySide2.QtCore.QRect', 'int'), ('PySide2.QtCore.QRectF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawTextItem": ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'),
-    "PySide2.QtGui.QPaintEngine.drawTiledPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPaintEngine.end": (),
-    "PySide2.QtGui.QPaintEngine.hasFeature": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.isActive": (),
-    "PySide2.QtGui.QPaintEngine.isExtended": (),
-    "PySide2.QtGui.QPaintEngine.paintDevice": (),
-    "PySide2.QtGui.QPaintEngine.painter": (),
-    "PySide2.QtGui.QPaintEngine.setActive": ('bool',),
-    "PySide2.QtGui.QPaintEngine.setDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.setSystemClip": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPaintEngine.setSystemRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPaintEngine.syncState": (),
-    "PySide2.QtGui.QPaintEngine.systemClip": (),
-    "PySide2.QtGui.QPaintEngine.systemRect": (),
-    "PySide2.QtGui.QPaintEngine.testDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.type": (),
-    "PySide2.QtGui.QPaintEngine.updateState": ('PySide2.QtGui.QPaintEngineState',),
-# class PySide2.QtGui.QPaintEngineState:
-    "PySide2.QtGui.QPaintEngineState.__init__": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundBrush": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundMode": (),
-    "PySide2.QtGui.QPaintEngineState.brush": (),
-    "PySide2.QtGui.QPaintEngineState.brushNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.brushOrigin": (),
-    "PySide2.QtGui.QPaintEngineState.clipOperation": (),
-    "PySide2.QtGui.QPaintEngineState.clipPath": (),
-    "PySide2.QtGui.QPaintEngineState.clipRegion": (),
-    "PySide2.QtGui.QPaintEngineState.compositionMode": (),
-    "PySide2.QtGui.QPaintEngineState.font": (),
-    "PySide2.QtGui.QPaintEngineState.isClipEnabled": (),
-    "PySide2.QtGui.QPaintEngineState.matrix": (),
-    "PySide2.QtGui.QPaintEngineState.opacity": (),
-    "PySide2.QtGui.QPaintEngineState.painter": (),
-    "PySide2.QtGui.QPaintEngineState.pen": (),
-    "PySide2.QtGui.QPaintEngineState.penNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.renderHints": (),
-    "PySide2.QtGui.QPaintEngineState.state": (),
-    "PySide2.QtGui.QPaintEngineState.transform": (),
-# class PySide2.QtGui.QPaintEvent:
-    "PySide2.QtGui.QPaintEvent.__init__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QPaintEvent.rect": (),
-    "PySide2.QtGui.QPaintEvent.region": (),
-# class PySide2.QtGui.QPainter:
-# class PySide2.QtGui.QPainter.CompositionMode:
-# class PySide2.QtGui.QPainter.PixmapFragment:
-    "PySide2.QtGui.QPainter.PixmapFragment.__init__": [(), ('PySide2.QtGui.QPainter.PixmapFragment',)],
-    "PySide2.QtGui.QPainter.PixmapFragment.__copy__": (),
-    "PySide2.QtGui.QPainter.PixmapFragment.create": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QRectF', 'float', 'float', 'float', 'float'),
-# class PySide2.QtGui.QPainter.PixmapFragmentHint:
-# class PySide2.QtGui.QPainter.PixmapFragmentHints:
-# class PySide2.QtGui.QPainter.RenderHint:
-# class PySide2.QtGui.QPainter.RenderHints:
-    "PySide2.QtGui.QPainter.__init__": [(), ('PySide2.QtGui.QPaintDevice',)],
-    "PySide2.QtGui.QPainter.background": (),
-    "PySide2.QtGui.QPainter.backgroundMode": (),
-    "PySide2.QtGui.QPainter.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.beginNativePainting": (),
-    "PySide2.QtGui.QPainter.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str'), ('PySide2.QtCore.QRectF', 'int', 'str'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.brush": (),
-    "PySide2.QtGui.QPainter.brushOrigin": (),
-    "PySide2.QtGui.QPainter.clipBoundingRect": (),
-    "PySide2.QtGui.QPainter.clipPath": (),
-    "PySide2.QtGui.QPainter.clipRegion": (),
-    "PySide2.QtGui.QPainter.combinedMatrix": (),
-    "PySide2.QtGui.QPainter.combinedTransform": (),
-    "PySide2.QtGui.QPainter.compositionMode": (),
-    "PySide2.QtGui.QPainter.device": (),
-    "PySide2.QtGui.QPainter.deviceMatrix": (),
-    "PySide2.QtGui.QPainter.deviceTransform": (),
-    "PySide2.QtGui.QPainter.drawArc": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawChord": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawConvexPolygon": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawEllipse": [('PySide2.QtCore.QPoint', 'int', 'int'), ('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawImage": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('int', 'int', 'PySide2.QtGui.QImage', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPainter.drawLine": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawLines": [('typing.List[PySide2.QtCore.QLineF]',), ('typing.List[PySide2.QtCore.QLine]',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainter.drawPicture": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPicture'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPicture'), ('int', 'int', 'PySide2.QtGui.QPicture')],
-    "PySide2.QtGui.QPainter.drawPie": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmap": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmapFragments": ('PySide2.QtGui.QPainter.PixmapFragment', 'int', 'PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPainter.PixmapFragmentHints'),
-    "PySide2.QtGui.QPainter.drawPoint": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.drawPoints": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPolygon": [('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPointF]', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPoint]', 'PySide2.QtCore.Qt.FillRule')],
-    "PySide2.QtGui.QPainter.drawPolyline": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRects": [('typing.List[PySide2.QtCore.QRectF]',), ('typing.List[PySide2.QtCore.QRect]',)],
-    "PySide2.QtGui.QPainter.drawRoundRect": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRoundedRect": [('PySide2.QtCore.QRect', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('int', 'int', 'int', 'int', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainter.drawStaticText": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QStaticText'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QStaticText'), ('int', 'int', 'PySide2.QtGui.QStaticText')],
-    "PySide2.QtGui.QPainter.drawText": [('PySide2.QtCore.QPoint', 'str'), ('PySide2.QtCore.QPointF', 'str'), ('PySide2.QtCore.QRect', 'int', 'str', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'int', 'str', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str', 'PySide2.QtCore.QRect'), ('int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.drawTextItem": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QTextItem'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'), ('int', 'int', 'PySide2.QtGui.QTextItem')],
-    "PySide2.QtGui.QPainter.drawTiledPixmap": [('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QPainter.end": (),
-    "PySide2.QtGui.QPainter.endNativePainting": (),
-    "PySide2.QtGui.QPainter.eraseRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.fillPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPainter.fillRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QGradient.Preset'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QGradient.Preset'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.BrushStyle'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.GlobalColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QBrush'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QGradient.Preset')],
-    "PySide2.QtGui.QPainter.font": (),
-    "PySide2.QtGui.QPainter.fontInfo": (),
-    "PySide2.QtGui.QPainter.fontMetrics": (),
-    "PySide2.QtGui.QPainter.hasClipping": (),
-    "PySide2.QtGui.QPainter.initFrom": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.isActive": (),
-    "PySide2.QtGui.QPainter.layoutDirection": (),
-    "PySide2.QtGui.QPainter.matrix": (),
-    "PySide2.QtGui.QPainter.matrixEnabled": (),
-    "PySide2.QtGui.QPainter.opacity": (),
-    "PySide2.QtGui.QPainter.paintEngine": (),
-    "PySide2.QtGui.QPainter.pen": (),
-    "PySide2.QtGui.QPainter.redirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.renderHints": (),
-    "PySide2.QtGui.QPainter.resetMatrix": (),
-    "PySide2.QtGui.QPainter.resetTransform": (),
-    "PySide2.QtGui.QPainter.restore": (),
-    "PySide2.QtGui.QPainter.restoreRedirected": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.rotate": ('float',),
-    "PySide2.QtGui.QPainter.save": (),
-    "PySide2.QtGui.QPainter.scale": ('float', 'float'),
-    "PySide2.QtGui.QPainter.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPainter.setBackgroundMode": ('PySide2.QtCore.Qt.BGMode',),
-    "PySide2.QtGui.QPainter.setBrush": [('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtGui.QBrush',)],
-    "PySide2.QtGui.QPainter.setBrushOrigin": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.setClipPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ClipOperation'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ClipOperation'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ClipOperation')],
-    "PySide2.QtGui.QPainter.setClipRegion": ('PySide2.QtGui.QRegion', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipping": ('bool',),
-    "PySide2.QtGui.QPainter.setCompositionMode": ('PySide2.QtGui.QPainter.CompositionMode',),
-    "PySide2.QtGui.QPainter.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QPainter.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QPainter.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setOpacity": ('float',),
-    "PySide2.QtGui.QPainter.setPen": [('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainter.setRedirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtGui.QPainter.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints', 'bool'),
-    "PySide2.QtGui.QPainter.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.setViewTransformEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setViewport": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWindow": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWorldMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setWorldMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setWorldTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.shear": ('float', 'float'),
-    "PySide2.QtGui.QPainter.strokePath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen'),
-    "PySide2.QtGui.QPainter.testRenderHint": ('PySide2.QtGui.QPainter.RenderHint',),
-    "PySide2.QtGui.QPainter.transform": (),
-    "PySide2.QtGui.QPainter.translate": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainter.viewTransformEnabled": (),
-    "PySide2.QtGui.QPainter.viewport": (),
-    "PySide2.QtGui.QPainter.window": (),
-    "PySide2.QtGui.QPainter.worldMatrix": (),
-    "PySide2.QtGui.QPainter.worldMatrixEnabled": (),
-    "PySide2.QtGui.QPainter.worldTransform": (),
-# class PySide2.QtGui.QPainterPath:
-# class PySide2.QtGui.QPainterPath.Element:
-    "PySide2.QtGui.QPainterPath.Element.__init__": [(), ('PySide2.QtGui.QPainterPath.Element',)],
-    "PySide2.QtGui.QPainterPath.Element.__copy__": (),
-    "PySide2.QtGui.QPainterPath.Element.isCurveTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isLineTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isMoveTo": (),
-# class PySide2.QtGui.QPainterPath.ElementType:
-    "PySide2.QtGui.QPainterPath.__init__": [(), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.__add__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__and__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__copy__": (),
-    "PySide2.QtGui.QPainterPath.__iadd__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__iand__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__ior__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__isub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.__or__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__sub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addEllipse": [('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPainterPath.addRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPainterPath.addRoundRect": [('PySide2.QtCore.QRectF', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtGui.QPainterPath.addRoundedRect": [('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('float', 'float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainterPath.addText": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QFont', 'str'), ('float', 'float', 'PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtGui.QPainterPath.angleAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.arcMoveTo": [('PySide2.QtCore.QRectF', 'float'), ('float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.arcTo": [('PySide2.QtCore.QRectF', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.boundingRect": (),
-    "PySide2.QtGui.QPainterPath.capacity": (),
-    "PySide2.QtGui.QPainterPath.clear": (),
-    "PySide2.QtGui.QPainterPath.closeSubpath": (),
-    "PySide2.QtGui.QPainterPath.connectPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.controlPointRect": (),
-    "PySide2.QtGui.QPainterPath.cubicTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.currentPosition": (),
-    "PySide2.QtGui.QPainterPath.elementAt": ('int',),
-    "PySide2.QtGui.QPainterPath.elementCount": (),
-    "PySide2.QtGui.QPainterPath.fillRule": (),
-    "PySide2.QtGui.QPainterPath.intersected": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.intersects": [('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.isEmpty": (),
-    "PySide2.QtGui.QPainterPath.length": (),
-    "PySide2.QtGui.QPainterPath.lineTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.percentAtLength": ('float',),
-    "PySide2.QtGui.QPainterPath.pointAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.quadTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.reserve": ('int',),
-    "PySide2.QtGui.QPainterPath.setElementPositionAt": ('int', 'float', 'float'),
-    "PySide2.QtGui.QPainterPath.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtGui.QPainterPath.simplified": (),
-    "PySide2.QtGui.QPainterPath.slopeAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.subtracted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.subtractedInverted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.swap": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.toFillPolygon": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toFillPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toReversed": (),
-    "PySide2.QtGui.QPainterPath.toSubpathPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.united": ('PySide2.QtGui.QPainterPath',),
-# class PySide2.QtGui.QPainterPathStroker:
-    "PySide2.QtGui.QPainterPathStroker.__init__": [(), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainterPathStroker.capStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.createStroke": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPathStroker.curveThreshold": (),
-    "PySide2.QtGui.QPainterPathStroker.dashOffset": (),
-    "PySide2.QtGui.QPainterPathStroker.dashPattern": (),
-    "PySide2.QtGui.QPainterPathStroker.joinStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.miterLimit": (),
-    "PySide2.QtGui.QPainterPathStroker.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setCurveThreshold": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashOffset": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashPattern": [('PySide2.QtCore.Qt.PenStyle',), ('typing.List[float]',)],
-    "PySide2.QtGui.QPainterPathStroker.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setWidth": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.width": (),
-# class PySide2.QtGui.QPalette:
-# class PySide2.QtGui.QPalette.ColorGroup:
-# class PySide2.QtGui.QPalette.ColorRole:
-    "PySide2.QtGui.QPalette.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette',)],
-    "PySide2.QtGui.QPalette.__copy__": (),
-    "PySide2.QtGui.QPalette.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.alternateBase": (),
-    "PySide2.QtGui.QPalette.background": (),
-    "PySide2.QtGui.QPalette.base": (),
-    "PySide2.QtGui.QPalette.brightText": (),
-    "PySide2.QtGui.QPalette.brush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.button": (),
-    "PySide2.QtGui.QPalette.buttonText": (),
-    "PySide2.QtGui.QPalette.cacheKey": (),
-    "PySide2.QtGui.QPalette.color": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.currentColorGroup": (),
-    "PySide2.QtGui.QPalette.dark": (),
-    "PySide2.QtGui.QPalette.foreground": (),
-    "PySide2.QtGui.QPalette.highlight": (),
-    "PySide2.QtGui.QPalette.highlightedText": (),
-    "PySide2.QtGui.QPalette.isBrushSet": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtGui.QPalette.isCopyOf": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.isEqual": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorGroup'),
-    "PySide2.QtGui.QPalette.light": (),
-    "PySide2.QtGui.QPalette.link": (),
-    "PySide2.QtGui.QPalette.linkVisited": (),
-    "PySide2.QtGui.QPalette.mid": (),
-    "PySide2.QtGui.QPalette.midlight": (),
-    "PySide2.QtGui.QPalette.placeholderText": (),
-    "PySide2.QtGui.QPalette.resolve": [(), ('PySide2.QtGui.QPalette',), ('int',)],
-    "PySide2.QtGui.QPalette.setBrush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtGui.QPalette.setColor": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QPalette.setColorGroup": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPalette.setCurrentColorGroup": ('PySide2.QtGui.QPalette.ColorGroup',),
-    "PySide2.QtGui.QPalette.shadow": (),
-    "PySide2.QtGui.QPalette.swap": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.text": (),
-    "PySide2.QtGui.QPalette.toolTipBase": (),
-    "PySide2.QtGui.QPalette.toolTipText": (),
-    "PySide2.QtGui.QPalette.window": (),
-    "PySide2.QtGui.QPalette.windowText": (),
-# class PySide2.QtGui.QPdfWriter:
-    "PySide2.QtGui.QPdfWriter.__init__": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPdfWriter.creator": (),
-    "PySide2.QtGui.QPdfWriter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPdfWriter.newPage": (),
-    "PySide2.QtGui.QPdfWriter.paintEngine": (),
-    "PySide2.QtGui.QPdfWriter.pdfVersion": (),
-    "PySide2.QtGui.QPdfWriter.resolution": (),
-    "PySide2.QtGui.QPdfWriter.setCreator": ('str',),
-    "PySide2.QtGui.QPdfWriter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPdfWriter.setPageSize": ('PySide2.QtGui.QPagedPaintDevice.PageSize',),
-    "PySide2.QtGui.QPdfWriter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QPdfWriter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtGui.QPdfWriter.setResolution": ('int',),
-    "PySide2.QtGui.QPdfWriter.setTitle": ('str',),
-    "PySide2.QtGui.QPdfWriter.title": (),
-# class PySide2.QtGui.QPen:
-    "PySide2.QtGui.QPen.__init__": [(), ('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QBrush', 'float', 'PySide2.QtCore.Qt.PenStyle', 'PySide2.QtCore.Qt.PenCapStyle', 'PySide2.QtCore.Qt.PenJoinStyle'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPen.__copy__": (),
-    "PySide2.QtGui.QPen.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.brush": (),
-    "PySide2.QtGui.QPen.capStyle": (),
-    "PySide2.QtGui.QPen.color": (),
-    "PySide2.QtGui.QPen.dashOffset": (),
-    "PySide2.QtGui.QPen.dashPattern": (),
-    "PySide2.QtGui.QPen.isCosmetic": (),
-    "PySide2.QtGui.QPen.isSolid": (),
-    "PySide2.QtGui.QPen.joinStyle": (),
-    "PySide2.QtGui.QPen.miterLimit": (),
-    "PySide2.QtGui.QPen.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPen.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPen.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QPen.setCosmetic": ('bool',),
-    "PySide2.QtGui.QPen.setDashOffset": ('float',),
-    "PySide2.QtGui.QPen.setDashPattern": ('typing.List[float]',),
-    "PySide2.QtGui.QPen.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPen.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPen.setStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtGui.QPen.setWidth": ('int',),
-    "PySide2.QtGui.QPen.setWidthF": ('float',),
-    "PySide2.QtGui.QPen.style": (),
-    "PySide2.QtGui.QPen.swap": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QPen.width": (),
-    "PySide2.QtGui.QPen.widthF": (),
-# class PySide2.QtGui.QPicture:
-    "PySide2.QtGui.QPicture.__init__": [('PySide2.QtGui.QPicture',), ('int',)],
-    "PySide2.QtGui.QPicture.__copy__": (),
-    "PySide2.QtGui.QPicture.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.boundingRect": (),
-    "PySide2.QtGui.QPicture.data": (),
-    "PySide2.QtGui.QPicture.devType": (),
-    "PySide2.QtGui.QPicture.inputFormatList": (),
-    "PySide2.QtGui.QPicture.inputFormats": (),
-    "PySide2.QtGui.QPicture.isNull": (),
-    "PySide2.QtGui.QPicture.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPicture.outputFormatList": (),
-    "PySide2.QtGui.QPicture.outputFormats": (),
-    "PySide2.QtGui.QPicture.paintEngine": (),
-    "PySide2.QtGui.QPicture.pictureFormat": ('str',),
-    "PySide2.QtGui.QPicture.play": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPicture.save": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.setBoundingRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPicture.setData": ('str', 'int'),
-    "PySide2.QtGui.QPicture.size": (),
-    "PySide2.QtGui.QPicture.swap": ('PySide2.QtGui.QPicture',),
-# class PySide2.QtGui.QPictureIO:
-    "PySide2.QtGui.QPictureIO.__init__": [(), ('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPictureIO.description": (),
-    "PySide2.QtGui.QPictureIO.fileName": (),
-    "PySide2.QtGui.QPictureIO.format": (),
-    "PySide2.QtGui.QPictureIO.gamma": (),
-    "PySide2.QtGui.QPictureIO.inputFormats": (),
-    "PySide2.QtGui.QPictureIO.ioDevice": (),
-    "PySide2.QtGui.QPictureIO.outputFormats": (),
-    "PySide2.QtGui.QPictureIO.parameters": (),
-    "PySide2.QtGui.QPictureIO.picture": (),
-    "PySide2.QtGui.QPictureIO.pictureFormat": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPictureIO.quality": (),
-    "PySide2.QtGui.QPictureIO.read": (),
-    "PySide2.QtGui.QPictureIO.setDescription": ('str',),
-    "PySide2.QtGui.QPictureIO.setFileName": ('str',),
-    "PySide2.QtGui.QPictureIO.setFormat": ('str',),
-    "PySide2.QtGui.QPictureIO.setGamma": ('float',),
-    "PySide2.QtGui.QPictureIO.setIODevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QPictureIO.setParameters": ('str',),
-    "PySide2.QtGui.QPictureIO.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtGui.QPictureIO.setQuality": ('int',),
-    "PySide2.QtGui.QPictureIO.setStatus": ('int',),
-    "PySide2.QtGui.QPictureIO.status": (),
-    "PySide2.QtGui.QPictureIO.write": (),
-# class PySide2.QtGui.QPixelFormat:
-# class PySide2.QtGui.QPixelFormat.AlphaPosition:
-# class PySide2.QtGui.QPixelFormat.AlphaPremultiplied:
-# class PySide2.QtGui.QPixelFormat.AlphaUsage:
-# class PySide2.QtGui.QPixelFormat.ByteOrder:
-# class PySide2.QtGui.QPixelFormat.ColorModel:
-# class PySide2.QtGui.QPixelFormat.TypeInterpretation:
-# class PySide2.QtGui.QPixelFormat.YUVLayout:
-    "PySide2.QtGui.QPixelFormat.__init__": [(), ('PySide2.QtGui.QPixelFormat',), ('PySide2.QtGui.QPixelFormat.ColorModel', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QPixelFormat.AlphaUsage', 'PySide2.QtGui.QPixelFormat.AlphaPosition', 'PySide2.QtGui.QPixelFormat.AlphaPremultiplied', 'PySide2.QtGui.QPixelFormat.TypeInterpretation', 'PySide2.QtGui.QPixelFormat.ByteOrder', 'int')],
-    "PySide2.QtGui.QPixelFormat.__copy__": (),
-    "PySide2.QtGui.QPixelFormat.alphaPosition": (),
-    "PySide2.QtGui.QPixelFormat.alphaSize": (),
-    "PySide2.QtGui.QPixelFormat.alphaUsage": (),
-    "PySide2.QtGui.QPixelFormat.bitsPerPixel": (),
-    "PySide2.QtGui.QPixelFormat.blackSize": (),
-    "PySide2.QtGui.QPixelFormat.blueSize": (),
-    "PySide2.QtGui.QPixelFormat.brightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.byteOrder": (),
-    "PySide2.QtGui.QPixelFormat.channelCount": (),
-    "PySide2.QtGui.QPixelFormat.colorModel": (),
-    "PySide2.QtGui.QPixelFormat.cyanSize": (),
-    "PySide2.QtGui.QPixelFormat.greenSize": (),
-    "PySide2.QtGui.QPixelFormat.hueSize": (),
-    "PySide2.QtGui.QPixelFormat.lightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.magentaSize": (),
-    "PySide2.QtGui.QPixelFormat.premultiplied": (),
-    "PySide2.QtGui.QPixelFormat.redSize": (),
-    "PySide2.QtGui.QPixelFormat.saturationSize": (),
-    "PySide2.QtGui.QPixelFormat.subEnum": (),
-    "PySide2.QtGui.QPixelFormat.typeInterpretation": (),
-    "PySide2.QtGui.QPixelFormat.yellowSize": (),
-    "PySide2.QtGui.QPixelFormat.yuvLayout": (),
-# class PySide2.QtGui.QPixmap:
-    "PySide2.QtGui.QPixmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QPixmap.__copy__": (),
-    "PySide2.QtGui.QPixmap.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.cacheKey": (),
-    "PySide2.QtGui.QPixmap.convertFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QPixmap.createMaskFromColor": ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QPixmap.defaultDepth": (),
-    "PySide2.QtGui.QPixmap.depth": (),
-    "PySide2.QtGui.QPixmap.devType": (),
-    "PySide2.QtGui.QPixmap.devicePixelRatio": (),
-    "PySide2.QtGui.QPixmap.fill": [('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QPaintDevice', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageInPlace": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageReader": ('PySide2.QtGui.QImageReader', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.grabWidget": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QObject', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QPixmap.hasAlpha": (),
-    "PySide2.QtGui.QPixmap.hasAlphaChannel": (),
-    "PySide2.QtGui.QPixmap.height": (),
-    "PySide2.QtGui.QPixmap.isNull": (),
-    "PySide2.QtGui.QPixmap.isQBitmap": (),
-    "PySide2.QtGui.QPixmap.load": ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.loadFromData": [('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('str', 'int', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPixmap.mask": (),
-    "PySide2.QtGui.QPixmap.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPixmap.paintEngine": (),
-    "PySide2.QtGui.QPixmap.rect": (),
-    "PySide2.QtGui.QPixmap.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QPixmap.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scroll": [('int', 'int', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion')],
-    "PySide2.QtGui.QPixmap.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QPixmap.setMask": ('PySide2.QtGui.QBitmap',),
-    "PySide2.QtGui.QPixmap.size": (),
-    "PySide2.QtGui.QPixmap.swap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QPixmap.toImage": (),
-    "PySide2.QtGui.QPixmap.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.width": (),
-# class PySide2.QtGui.QPixmapCache:
-# class PySide2.QtGui.QPixmapCache.Key:
-    "PySide2.QtGui.QPixmapCache.Key.__init__": [(), ('PySide2.QtGui.QPixmapCache.Key',)],
-    "PySide2.QtGui.QPixmapCache.Key.__copy__": (),
-    "PySide2.QtGui.QPixmapCache.Key.isValid": (),
-    "PySide2.QtGui.QPixmapCache.Key.swap": ('PySide2.QtGui.QPixmapCache.Key',),
-    "PySide2.QtGui.QPixmapCache.__init__": (),
-    "PySide2.QtGui.QPixmapCache.cacheLimit": (),
-    "PySide2.QtGui.QPixmapCache.clear": (),
-    "PySide2.QtGui.QPixmapCache.find": [('PySide2.QtGui.QPixmapCache.Key',), ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'), ('str',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.insert": [('PySide2.QtGui.QPixmap',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.remove": [('PySide2.QtGui.QPixmapCache.Key',), ('str',)],
-    "PySide2.QtGui.QPixmapCache.replace": ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtGui.QPixmapCache.setCacheLimit": ('int',),
-# class PySide2.QtGui.QPointingDeviceUniqueId:
-    "PySide2.QtGui.QPointingDeviceUniqueId.__init__": [(), ('PySide2.QtGui.QPointingDeviceUniqueId',)],
-    "PySide2.QtGui.QPointingDeviceUniqueId.__copy__": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.fromNumericId": ('int',),
-    "PySide2.QtGui.QPointingDeviceUniqueId.isValid": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.numericId": (),
-# class PySide2.QtGui.QPolygon:
-    "PySide2.QtGui.QPolygon.__init__": [(), ('PySide2.QtCore.QRect', 'bool'), ('PySide2.QtGui.QPolygon',), ('int',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__add__": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.__copy__": (),
-    "PySide2.QtGui.QPolygon.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.__lshift__": [('PySide2.QtCore.QDataStream',), ('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygon.__reduce__": (),
-    "PySide2.QtGui.QPolygon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygon.append": [('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.at": ('int',),
-    "PySide2.QtGui.QPolygon.back": (),
-    "PySide2.QtGui.QPolygon.boundingRect": (),
-    "PySide2.QtGui.QPolygon.capacity": (),
-    "PySide2.QtGui.QPolygon.clear": (),
-    "PySide2.QtGui.QPolygon.constData": (),
-    "PySide2.QtGui.QPolygon.constFirst": (),
-    "PySide2.QtGui.QPolygon.constLast": (),
-    "PySide2.QtGui.QPolygon.contains": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.containsPoint": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygon.count": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtGui.QPolygon.data": (),
-    "PySide2.QtGui.QPolygon.empty": (),
-    "PySide2.QtGui.QPolygon.endsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.fill": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.first": (),
-    "PySide2.QtGui.QPolygon.fromList": ('typing.Sequence[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.front": (),
-    "PySide2.QtGui.QPolygon.indexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.insert": [('int', 'PySide2.QtCore.QPoint'), ('int', 'int', 'PySide2.QtCore.QPoint')],
-    "PySide2.QtGui.QPolygon.intersected": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.intersects": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.isEmpty": (),
-    "PySide2.QtGui.QPolygon.isSharedWith": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.last": (),
-    "PySide2.QtGui.QPolygon.lastIndexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.length": (),
-    "PySide2.QtGui.QPolygon.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.pop_back": (),
-    "PySide2.QtGui.QPolygon.pop_front": (),
-    "PySide2.QtGui.QPolygon.prepend": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_back": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_front": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.removeAll": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.removeAt": ('int',),
-    "PySide2.QtGui.QPolygon.removeFirst": (),
-    "PySide2.QtGui.QPolygon.removeLast": (),
-    "PySide2.QtGui.QPolygon.removeOne": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.replace": ('int', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPolygon.reserve": ('int',),
-    "PySide2.QtGui.QPolygon.resize": ('int',),
-    "PySide2.QtGui.QPolygon.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygon.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygon.size": (),
-    "PySide2.QtGui.QPolygon.squeeze": (),
-    "PySide2.QtGui.QPolygon.startsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.subtracted": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swap": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.takeAt": ('int',),
-    "PySide2.QtGui.QPolygon.takeFirst": (),
-    "PySide2.QtGui.QPolygon.takeLast": (),
-    "PySide2.QtGui.QPolygon.toList": (),
-    "PySide2.QtGui.QPolygon.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.united": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.value": [('int',), ('int', 'PySide2.QtCore.QPoint')],
-# class PySide2.QtGui.QPolygonF:
-    "PySide2.QtGui.QPolygonF.__init__": [(), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('int',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.__add__": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.__copy__": (),
-    "PySide2.QtGui.QPolygonF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygonF.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.append": [('PySide2.QtCore.QPointF',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.at": ('int',),
-    "PySide2.QtGui.QPolygonF.back": (),
-    "PySide2.QtGui.QPolygonF.boundingRect": (),
-    "PySide2.QtGui.QPolygonF.capacity": (),
-    "PySide2.QtGui.QPolygonF.clear": (),
-    "PySide2.QtGui.QPolygonF.constData": (),
-    "PySide2.QtGui.QPolygonF.constFirst": (),
-    "PySide2.QtGui.QPolygonF.constLast": (),
-    "PySide2.QtGui.QPolygonF.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.containsPoint": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygonF.count": [(), ('PySide2.QtCore.QPointF',)],
-    "PySide2.QtGui.QPolygonF.data": (),
-    "PySide2.QtGui.QPolygonF.empty": (),
-    "PySide2.QtGui.QPolygonF.endsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.fill": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.first": (),
-    "PySide2.QtGui.QPolygonF.fromList": ('typing.Sequence[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.front": (),
-    "PySide2.QtGui.QPolygonF.indexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.insert": [('int', 'PySide2.QtCore.QPointF'), ('int', 'int', 'PySide2.QtCore.QPointF')],
-    "PySide2.QtGui.QPolygonF.intersected": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.intersects": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.isClosed": (),
-    "PySide2.QtGui.QPolygonF.isEmpty": (),
-    "PySide2.QtGui.QPolygonF.isSharedWith": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.last": (),
-    "PySide2.QtGui.QPolygonF.lastIndexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.length": (),
-    "PySide2.QtGui.QPolygonF.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.pop_back": (),
-    "PySide2.QtGui.QPolygonF.pop_front": (),
-    "PySide2.QtGui.QPolygonF.prepend": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_back": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_front": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygonF.removeAll": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.removeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.removeFirst": (),
-    "PySide2.QtGui.QPolygonF.removeLast": (),
-    "PySide2.QtGui.QPolygonF.removeOne": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.replace": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPolygonF.reserve": ('int',),
-    "PySide2.QtGui.QPolygonF.resize": ('int',),
-    "PySide2.QtGui.QPolygonF.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygonF.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygonF.size": (),
-    "PySide2.QtGui.QPolygonF.squeeze": (),
-    "PySide2.QtGui.QPolygonF.startsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.subtracted": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swap": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.takeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.takeFirst": (),
-    "PySide2.QtGui.QPolygonF.takeLast": (),
-    "PySide2.QtGui.QPolygonF.toList": (),
-    "PySide2.QtGui.QPolygonF.toPolygon": (),
-    "PySide2.QtGui.QPolygonF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.united": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.value": [('int',), ('int', 'PySide2.QtCore.QPointF')],
-# class PySide2.QtGui.QPyTextObject:
-    "PySide2.QtGui.QPyTextObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QPyTextObject.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QPyTextObject.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QQuaternion:
-    "PySide2.QtGui.QQuaternion.__init__": [(), ('PySide2.QtGui.QVector4D',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.__add__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__copy__": (),
-    "PySide2.QtGui.QQuaternion.__iadd__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__imul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__isub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__mul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__neg__": (),
-    "PySide2.QtGui.QQuaternion.__reduce__": (),
-    "PySide2.QtGui.QQuaternion.__repr__": (),
-    "PySide2.QtGui.QQuaternion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__sub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.conjugate": (),
-    "PySide2.QtGui.QQuaternion.conjugated": (),
-    "PySide2.QtGui.QQuaternion.dotProduct": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion'),
-    "PySide2.QtGui.QQuaternion.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromDirection": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromRotationMatrix": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QQuaternion.getAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.inverted": (),
-    "PySide2.QtGui.QQuaternion.isIdentity": (),
-    "PySide2.QtGui.QQuaternion.isNull": (),
-    "PySide2.QtGui.QQuaternion.length": (),
-    "PySide2.QtGui.QQuaternion.lengthSquared": (),
-    "PySide2.QtGui.QQuaternion.nlerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.normalize": (),
-    "PySide2.QtGui.QQuaternion.normalized": (),
-    "PySide2.QtGui.QQuaternion.rotatedVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QQuaternion.rotationTo": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.scalar": (),
-    "PySide2.QtGui.QQuaternion.setScalar": ('float',),
-    "PySide2.QtGui.QQuaternion.setVector": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.setX": ('float',),
-    "PySide2.QtGui.QQuaternion.setY": ('float',),
-    "PySide2.QtGui.QQuaternion.setZ": ('float',),
-    "PySide2.QtGui.QQuaternion.slerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.toEulerAngles": (),
-    "PySide2.QtGui.QQuaternion.toRotationMatrix": (),
-    "PySide2.QtGui.QQuaternion.toVector4D": (),
-    "PySide2.QtGui.QQuaternion.vector": (),
-    "PySide2.QtGui.QQuaternion.x": (),
-    "PySide2.QtGui.QQuaternion.y": (),
-    "PySide2.QtGui.QQuaternion.z": (),
-# class PySide2.QtGui.QRadialGradient:
-    "PySide2.QtGui.QRadialGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QRadialGradient',), ('float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QRadialGradient.__copy__": (),
-    "PySide2.QtGui.QRadialGradient.center": (),
-    "PySide2.QtGui.QRadialGradient.centerRadius": (),
-    "PySide2.QtGui.QRadialGradient.focalPoint": (),
-    "PySide2.QtGui.QRadialGradient.focalRadius": (),
-    "PySide2.QtGui.QRadialGradient.radius": (),
-    "PySide2.QtGui.QRadialGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setCenterRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setFocalPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setFocalRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setRadius": ('float',),
-# class PySide2.QtGui.QRasterWindow:
-    "PySide2.QtGui.QRasterWindow.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QRasterWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QRasterWindow.redirected": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtGui.QRawFont:
-# class PySide2.QtGui.QRawFont.AntialiasingType:
-# class PySide2.QtGui.QRawFont.LayoutFlag:
-# class PySide2.QtGui.QRawFont.LayoutFlags:
-    "PySide2.QtGui.QRawFont.__init__": [(), ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'), ('PySide2.QtGui.QRawFont',), ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference')],
-    "PySide2.QtGui.QRawFont.__copy__": (),
-    "PySide2.QtGui.QRawFont.advancesForGlyphIndexes": [('typing.List[int]',), ('typing.List[int]', 'PySide2.QtGui.QRawFont.LayoutFlags')],
-    "PySide2.QtGui.QRawFont.alphaMapForGlyph": ('int', 'PySide2.QtGui.QRawFont.AntialiasingType', 'PySide2.QtGui.QTransform'),
-    "PySide2.QtGui.QRawFont.ascent": (),
-    "PySide2.QtGui.QRawFont.averageCharWidth": (),
-    "PySide2.QtGui.QRawFont.boundingRect": ('int',),
-    "PySide2.QtGui.QRawFont.capHeight": (),
-    "PySide2.QtGui.QRawFont.descent": (),
-    "PySide2.QtGui.QRawFont.familyName": (),
-    "PySide2.QtGui.QRawFont.fontTable": ('str',),
-    "PySide2.QtGui.QRawFont.fromFont": ('PySide2.QtGui.QFont', 'PySide2.QtGui.QFontDatabase.WritingSystem'),
-    "PySide2.QtGui.QRawFont.glyphIndexesForString": ('str',),
-    "PySide2.QtGui.QRawFont.hintingPreference": (),
-    "PySide2.QtGui.QRawFont.isValid": (),
-    "PySide2.QtGui.QRawFont.leading": (),
-    "PySide2.QtGui.QRawFont.lineThickness": (),
-    "PySide2.QtGui.QRawFont.loadFromData": ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.loadFromFile": ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.maxCharWidth": (),
-    "PySide2.QtGui.QRawFont.pathForGlyph": ('int',),
-    "PySide2.QtGui.QRawFont.pixelSize": (),
-    "PySide2.QtGui.QRawFont.setPixelSize": ('float',),
-    "PySide2.QtGui.QRawFont.style": (),
-    "PySide2.QtGui.QRawFont.styleName": (),
-    "PySide2.QtGui.QRawFont.supportedWritingSystems": (),
-    "PySide2.QtGui.QRawFont.supportsCharacter": [('int',), ('str',)],
-    "PySide2.QtGui.QRawFont.swap": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QRawFont.underlinePosition": (),
-    "PySide2.QtGui.QRawFont.unitsPerEm": (),
-    "PySide2.QtGui.QRawFont.weight": (),
-    "PySide2.QtGui.QRawFont.xHeight": (),
-# class PySide2.QtGui.QRegExpValidator:
-    "PySide2.QtGui.QRegExpValidator.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRegExp', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QRegExpValidator.regExp": (),
-    "PySide2.QtGui.QRegExpValidator.setRegExp": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtGui.QRegExpValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QRegion:
-# class PySide2.QtGui.QRegion.RegionType:
-    "PySide2.QtGui.QRegion.__init__": [(), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion.RegionType'), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion.RegionType')],
-    "PySide2.QtGui.QRegion.__add__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__and__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__copy__": (),
-    "PySide2.QtGui.QRegion.__iadd__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__ior__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__isub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__ixor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QRegion.__or__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__sub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__xor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.begin": (),
-    "PySide2.QtGui.QRegion.boundingRect": (),
-    "PySide2.QtGui.QRegion.cbegin": (),
-    "PySide2.QtGui.QRegion.cend": (),
-    "PySide2.QtGui.QRegion.contains": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QRegion.end": (),
-    "PySide2.QtGui.QRegion.intersected": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.intersects": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.isEmpty": (),
-    "PySide2.QtGui.QRegion.isNull": (),
-    "PySide2.QtGui.QRegion.rectCount": (),
-    "PySide2.QtGui.QRegion.rects": (),
-    "PySide2.QtGui.QRegion.setRects": ('PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtGui.QRegion.subtracted": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.swap": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.united": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.xored": ('PySide2.QtGui.QRegion',),
-# class PySide2.QtGui.QResizeEvent:
-    "PySide2.QtGui.QResizeEvent.__init__": ('PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtGui.QResizeEvent.oldSize": (),
-    "PySide2.QtGui.QResizeEvent.size": (),
-# class PySide2.QtGui.QScreen:
-    "PySide2.QtGui.QScreen.angleBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation'),
-    "PySide2.QtGui.QScreen.availableGeometry": (),
-    "PySide2.QtGui.QScreen.availableSize": (),
-    "PySide2.QtGui.QScreen.availableVirtualGeometry": (),
-    "PySide2.QtGui.QScreen.availableVirtualSize": (),
-    "PySide2.QtGui.QScreen.depth": (),
-    "PySide2.QtGui.QScreen.devicePixelRatio": (),
-    "PySide2.QtGui.QScreen.geometry": (),
-    "PySide2.QtGui.QScreen.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QScreen.isLandscape": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.isPortrait": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.logicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.manufacturer": (),
-    "PySide2.QtGui.QScreen.mapBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.model": (),
-    "PySide2.QtGui.QScreen.name": (),
-    "PySide2.QtGui.QScreen.nativeOrientation": (),
-    "PySide2.QtGui.QScreen.orientation": (),
-    "PySide2.QtGui.QScreen.orientationUpdateMask": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.physicalSize": (),
-    "PySide2.QtGui.QScreen.primaryOrientation": (),
-    "PySide2.QtGui.QScreen.refreshRate": (),
-    "PySide2.QtGui.QScreen.serialNumber": (),
-    "PySide2.QtGui.QScreen.setOrientationUpdateMask": ('PySide2.QtCore.Qt.ScreenOrientations',),
-    "PySide2.QtGui.QScreen.size": (),
-    "PySide2.QtGui.QScreen.transformBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.virtualGeometry": (),
-    "PySide2.QtGui.QScreen.virtualSiblings": (),
-    "PySide2.QtGui.QScreen.virtualSize": (),
-# class PySide2.QtGui.QScrollEvent:
-# class PySide2.QtGui.QScrollEvent.ScrollState:
-    "PySide2.QtGui.QScrollEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QScrollEvent.ScrollState'),
-    "PySide2.QtGui.QScrollEvent.contentPos": (),
-    "PySide2.QtGui.QScrollEvent.overshootDistance": (),
-    "PySide2.QtGui.QScrollEvent.scrollState": (),
-# class PySide2.QtGui.QScrollPrepareEvent:
-    "PySide2.QtGui.QScrollPrepareEvent.__init__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPosRange": (),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPosRange": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setViewportSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QScrollPrepareEvent.startPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.viewportSize": (),
-# class PySide2.QtGui.QSessionManager:
-# class PySide2.QtGui.QSessionManager.RestartHint:
-    "PySide2.QtGui.QSessionManager.allowsErrorInteraction": (),
-    "PySide2.QtGui.QSessionManager.allowsInteraction": (),
-    "PySide2.QtGui.QSessionManager.cancel": (),
-    "PySide2.QtGui.QSessionManager.discardCommand": (),
-    "PySide2.QtGui.QSessionManager.isPhase2": (),
-    "PySide2.QtGui.QSessionManager.release": (),
-    "PySide2.QtGui.QSessionManager.requestPhase2": (),
-    "PySide2.QtGui.QSessionManager.restartCommand": (),
-    "PySide2.QtGui.QSessionManager.restartHint": (),
-    "PySide2.QtGui.QSessionManager.sessionId": (),
-    "PySide2.QtGui.QSessionManager.sessionKey": (),
-    "PySide2.QtGui.QSessionManager.setDiscardCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setManagerProperty": [('str', 'str'), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtGui.QSessionManager.setRestartCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setRestartHint": ('PySide2.QtGui.QSessionManager.RestartHint',),
-# class PySide2.QtGui.QShortcutEvent:
-    "PySide2.QtGui.QShortcutEvent.__init__": ('PySide2.QtGui.QKeySequence', 'int', 'bool'),
-    "PySide2.QtGui.QShortcutEvent.isAmbiguous": (),
-    "PySide2.QtGui.QShortcutEvent.key": (),
-    "PySide2.QtGui.QShortcutEvent.shortcutId": (),
-# class PySide2.QtGui.QShowEvent:
-    "PySide2.QtGui.QShowEvent.__init__": (),
-# class PySide2.QtGui.QStandardItem:
-# class PySide2.QtGui.QStandardItem.ItemType:
-    "PySide2.QtGui.QStandardItem.__init__": [(), ('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QStandardItem',), ('int', 'int'), ('str',)],
-    "PySide2.QtGui.QStandardItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.accessibleDescription": (),
-    "PySide2.QtGui.QStandardItem.accessibleText": (),
-    "PySide2.QtGui.QStandardItem.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItem.appendRows": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.background": (),
-    "PySide2.QtGui.QStandardItem.checkState": (),
-    "PySide2.QtGui.QStandardItem.child": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.clearData": (),
-    "PySide2.QtGui.QStandardItem.clone": (),
-    "PySide2.QtGui.QStandardItem.column": (),
-    "PySide2.QtGui.QStandardItem.columnCount": (),
-    "PySide2.QtGui.QStandardItem.data": ('int',),
-    "PySide2.QtGui.QStandardItem.emitDataChanged": (),
-    "PySide2.QtGui.QStandardItem.flags": (),
-    "PySide2.QtGui.QStandardItem.font": (),
-    "PySide2.QtGui.QStandardItem.foreground": (),
-    "PySide2.QtGui.QStandardItem.hasChildren": (),
-    "PySide2.QtGui.QStandardItem.icon": (),
-    "PySide2.QtGui.QStandardItem.index": (),
-    "PySide2.QtGui.QStandardItem.insertColumn": ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]'),
-    "PySide2.QtGui.QStandardItem.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.insertRow": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.insertRows": [('int', 'int'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.isAutoTristate": (),
-    "PySide2.QtGui.QStandardItem.isCheckable": (),
-    "PySide2.QtGui.QStandardItem.isDragEnabled": (),
-    "PySide2.QtGui.QStandardItem.isDropEnabled": (),
-    "PySide2.QtGui.QStandardItem.isEditable": (),
-    "PySide2.QtGui.QStandardItem.isEnabled": (),
-    "PySide2.QtGui.QStandardItem.isSelectable": (),
-    "PySide2.QtGui.QStandardItem.isTristate": (),
-    "PySide2.QtGui.QStandardItem.isUserTristate": (),
-    "PySide2.QtGui.QStandardItem.model": (),
-    "PySide2.QtGui.QStandardItem.parent": (),
-    "PySide2.QtGui.QStandardItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.removeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.removeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.row": (),
-    "PySide2.QtGui.QStandardItem.rowCount": (),
-    "PySide2.QtGui.QStandardItem.setAccessibleDescription": ('str',),
-    "PySide2.QtGui.QStandardItem.setAccessibleText": ('str',),
-    "PySide2.QtGui.QStandardItem.setAutoTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtGui.QStandardItem.setCheckable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setChild": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItem.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setData": ('typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItem.setDragEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setDropEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEditable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtGui.QStandardItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QStandardItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QStandardItem.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setSelectable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QStandardItem.setStatusTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setText": ('str',),
-    "PySide2.QtGui.QStandardItem.setTextAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QStandardItem.setToolTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setUserTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setWhatsThis": ('str',),
-    "PySide2.QtGui.QStandardItem.sizeHint": (),
-    "PySide2.QtGui.QStandardItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItem.statusTip": (),
-    "PySide2.QtGui.QStandardItem.takeChild": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.text": (),
-    "PySide2.QtGui.QStandardItem.textAlignment": (),
-    "PySide2.QtGui.QStandardItem.toolTip": (),
-    "PySide2.QtGui.QStandardItem.type": (),
-    "PySide2.QtGui.QStandardItem.whatsThis": (),
-    "PySide2.QtGui.QStandardItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QStandardItemModel:
-    "PySide2.QtGui.QStandardItemModel.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QStandardItemModel.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItemModel.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItemModel.clear": (),
-    "PySide2.QtGui.QStandardItemModel.clearItemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtGui.QStandardItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtGui.QStandardItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtGui.QStandardItemModel.horizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.indexFromItem": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.insertColumn": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.insertRow": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.invisibleRootItem": (),
-    "PySide2.QtGui.QStandardItemModel.item": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemPrototype": (),
-    "PySide2.QtGui.QStandardItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtGui.QStandardItemModel.mimeTypes": (),
-    "PySide2.QtGui.QStandardItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtGui.QStandardItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.setItem": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtGui.QStandardItemModel.setItemPrototype": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.setItemRoleNames": ('typing.Dict[int, PySide2.QtCore.QByteArray]',),
-    "PySide2.QtGui.QStandardItemModel.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setSortRole": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItemModel.sortRole": (),
-    "PySide2.QtGui.QStandardItemModel.supportedDropActions": (),
-    "PySide2.QtGui.QStandardItemModel.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeItem": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.verticalHeaderItem": ('int',),
-# class PySide2.QtGui.QStaticText:
-# class PySide2.QtGui.QStaticText.PerformanceHint:
-    "PySide2.QtGui.QStaticText.__init__": [(), ('PySide2.QtGui.QStaticText',), ('str',)],
-    "PySide2.QtGui.QStaticText.__copy__": (),
-    "PySide2.QtGui.QStaticText.performanceHint": (),
-    "PySide2.QtGui.QStaticText.prepare": ('PySide2.QtGui.QTransform', 'PySide2.QtGui.QFont'),
-    "PySide2.QtGui.QStaticText.setPerformanceHint": ('PySide2.QtGui.QStaticText.PerformanceHint',),
-    "PySide2.QtGui.QStaticText.setText": ('str',),
-    "PySide2.QtGui.QStaticText.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtGui.QStaticText.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QStaticText.setTextWidth": ('float',),
-    "PySide2.QtGui.QStaticText.size": (),
-    "PySide2.QtGui.QStaticText.swap": ('PySide2.QtGui.QStaticText',),
-    "PySide2.QtGui.QStaticText.text": (),
-    "PySide2.QtGui.QStaticText.textFormat": (),
-    "PySide2.QtGui.QStaticText.textOption": (),
-    "PySide2.QtGui.QStaticText.textWidth": (),
-# class PySide2.QtGui.QStatusTipEvent:
-    "PySide2.QtGui.QStatusTipEvent.__init__": ('str',),
-    "PySide2.QtGui.QStatusTipEvent.tip": (),
-# class PySide2.QtGui.QStyleHints:
-    "PySide2.QtGui.QStyleHints.cursorFlashTime": (),
-    "PySide2.QtGui.QStyleHints.fontSmoothingGamma": (),
-    "PySide2.QtGui.QStyleHints.keyboardAutoRepeatRate": (),
-    "PySide2.QtGui.QStyleHints.keyboardInputInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickDistance": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickInterval": (),
-    "PySide2.QtGui.QStyleHints.mousePressAndHoldInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseQuickSelectionThreshold": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskCharacter": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskDelay": (),
-    "PySide2.QtGui.QStyleHints.setCursorFlashTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setFocusOnTouchRelease": (),
-    "PySide2.QtGui.QStyleHints.setKeyboardInputInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseDoubleClickInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMousePressAndHoldInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseQuickSelectionThreshold": ('int',),
-    "PySide2.QtGui.QStyleHints.setShowShortcutsInContextMenus": ('bool',),
-    "PySide2.QtGui.QStyleHints.setStartDragDistance": ('int',),
-    "PySide2.QtGui.QStyleHints.setStartDragTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setTabFocusBehavior": ('PySide2.QtCore.Qt.TabFocusBehavior',),
-    "PySide2.QtGui.QStyleHints.setUseHoverEffects": ('bool',),
-    "PySide2.QtGui.QStyleHints.setWheelScrollLines": ('int',),
-    "PySide2.QtGui.QStyleHints.showIsFullScreen": (),
-    "PySide2.QtGui.QStyleHints.showIsMaximized": (),
-    "PySide2.QtGui.QStyleHints.showShortcutsInContextMenus": (),
-    "PySide2.QtGui.QStyleHints.singleClickActivation": (),
-    "PySide2.QtGui.QStyleHints.startDragDistance": (),
-    "PySide2.QtGui.QStyleHints.startDragTime": (),
-    "PySide2.QtGui.QStyleHints.startDragVelocity": (),
-    "PySide2.QtGui.QStyleHints.tabFocusBehavior": (),
-    "PySide2.QtGui.QStyleHints.touchDoubleTapDistance": (),
-    "PySide2.QtGui.QStyleHints.useHoverEffects": (),
-    "PySide2.QtGui.QStyleHints.useRtlExtensions": (),
-    "PySide2.QtGui.QStyleHints.wheelScrollLines": (),
-# class PySide2.QtGui.QSurface:
-# class PySide2.QtGui.QSurface.SurfaceClass:
-# class PySide2.QtGui.QSurface.SurfaceType:
-    "PySide2.QtGui.QSurface.__init__": ('PySide2.QtGui.QSurface.SurfaceClass',),
-    "PySide2.QtGui.QSurface.format": (),
-    "PySide2.QtGui.QSurface.size": (),
-    "PySide2.QtGui.QSurface.supportsOpenGL": (),
-    "PySide2.QtGui.QSurface.surfaceClass": (),
-    "PySide2.QtGui.QSurface.surfaceHandle": (),
-    "PySide2.QtGui.QSurface.surfaceType": (),
-# class PySide2.QtGui.QSurfaceFormat:
-# class PySide2.QtGui.QSurfaceFormat.ColorSpace:
-# class PySide2.QtGui.QSurfaceFormat.FormatOption:
-# class PySide2.QtGui.QSurfaceFormat.FormatOptions:
-# class PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile:
-# class PySide2.QtGui.QSurfaceFormat.RenderableType:
-# class PySide2.QtGui.QSurfaceFormat.SwapBehavior:
-    "PySide2.QtGui.QSurfaceFormat.__init__": [(), ('PySide2.QtGui.QSurfaceFormat',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.__copy__": (),
-    "PySide2.QtGui.QSurfaceFormat.alphaBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.blueBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.colorSpace": (),
-    "PySide2.QtGui.QSurfaceFormat.defaultFormat": (),
-    "PySide2.QtGui.QSurfaceFormat.depthBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.greenBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.hasAlpha": (),
-    "PySide2.QtGui.QSurfaceFormat.majorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.minorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.options": (),
-    "PySide2.QtGui.QSurfaceFormat.profile": (),
-    "PySide2.QtGui.QSurfaceFormat.redBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.renderableType": (),
-    "PySide2.QtGui.QSurfaceFormat.samples": (),
-    "PySide2.QtGui.QSurfaceFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setColorSpace": ('PySide2.QtGui.QSurfaceFormat.ColorSpace',),
-    "PySide2.QtGui.QSurfaceFormat.setDefaultFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QSurfaceFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMajorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMinorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption', 'bool'), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.setOptions": ('PySide2.QtGui.QSurfaceFormat.FormatOptions',),
-    "PySide2.QtGui.QSurfaceFormat.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QSurfaceFormat.setRedBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setRenderableType": ('PySide2.QtGui.QSurfaceFormat.RenderableType',),
-    "PySide2.QtGui.QSurfaceFormat.setSamples": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStereo": ('bool',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapBehavior": ('PySide2.QtGui.QSurfaceFormat.SwapBehavior',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapInterval": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QSurfaceFormat.stencilBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.stereo": (),
-    "PySide2.QtGui.QSurfaceFormat.swapBehavior": (),
-    "PySide2.QtGui.QSurfaceFormat.swapInterval": (),
-    "PySide2.QtGui.QSurfaceFormat.testOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.version": (),
-# class PySide2.QtGui.QSyntaxHighlighter:
-    "PySide2.QtGui.QSyntaxHighlighter.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QTextDocument',)],
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlock": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockUserData": (),
-    "PySide2.QtGui.QSyntaxHighlighter.document": (),
-    "PySide2.QtGui.QSyntaxHighlighter.format": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.highlightBlock": ('str',),
-    "PySide2.QtGui.QSyntaxHighlighter.previousBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlight": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlightBlock": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockState": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QSyntaxHighlighter.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QSyntaxHighlighter.setFormat": [('int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QFont'), ('int', 'int', 'PySide2.QtGui.QTextCharFormat')],
-# class PySide2.QtGui.QTabletEvent:
-# class PySide2.QtGui.QTabletEvent.PointerType:
-# class PySide2.QtGui.QTabletEvent.TabletDevice:
-    "PySide2.QtGui.QTabletEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons')],
-    "PySide2.QtGui.QTabletEvent.button": (),
-    "PySide2.QtGui.QTabletEvent.buttons": (),
-    "PySide2.QtGui.QTabletEvent.device": (),
-    "PySide2.QtGui.QTabletEvent.globalPos": (),
-    "PySide2.QtGui.QTabletEvent.globalPosF": (),
-    "PySide2.QtGui.QTabletEvent.globalX": (),
-    "PySide2.QtGui.QTabletEvent.global""Y": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobalX": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobal""Y": (),
-    "PySide2.QtGui.QTabletEvent.pointerType": (),
-    "PySide2.QtGui.QTabletEvent.pos": (),
-    "PySide2.QtGui.QTabletEvent.posF": (),
-    "PySide2.QtGui.QTabletEvent.pressure": (),
-    "PySide2.QtGui.QTabletEvent.rotation": (),
-    "PySide2.QtGui.QTabletEvent.tangentialPressure": (),
-    "PySide2.QtGui.QTabletEvent.uniqueId": (),
-    "PySide2.QtGui.QTabletEvent.x": (),
-    "PySide2.QtGui.QTabletEvent.xTilt": (),
-    "PySide2.QtGui.QTabletEvent.y": (),
-    "PySide2.QtGui.QTabletEvent.yTilt": (),
-    "PySide2.QtGui.QTabletEvent.z": (),
-# class PySide2.QtGui.QTextBlock:
-# class PySide2.QtGui.QTextBlock.iterator:
-    "PySide2.QtGui.QTextBlock.iterator.__init__": [(), ('PySide2.QtGui.QTextBlock.iterator',)],
-    "PySide2.QtGui.QTextBlock.iterator.__copy__": (),
-    "PySide2.QtGui.QTextBlock.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__iter__": (),
-    "PySide2.QtGui.QTextBlock.iterator.atEnd": (),
-    "PySide2.QtGui.QTextBlock.iterator.fragment": (),
-    "PySide2.QtGui.QTextBlock.__init__": [(), ('PySide2.QtGui.QTextBlock',)],
-    "PySide2.QtGui.QTextBlock.__copy__": (),
-    "PySide2.QtGui.QTextBlock.__iter__": (),
-    "PySide2.QtGui.QTextBlock.begin": (),
-    "PySide2.QtGui.QTextBlock.blockFormat": (),
-    "PySide2.QtGui.QTextBlock.blockFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.blockNumber": (),
-    "PySide2.QtGui.QTextBlock.charFormat": (),
-    "PySide2.QtGui.QTextBlock.charFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.clearLayout": (),
-    "PySide2.QtGui.QTextBlock.contains": ('int',),
-    "PySide2.QtGui.QTextBlock.document": (),
-    "PySide2.QtGui.QTextBlock.end": (),
-    "PySide2.QtGui.QTextBlock.firstLineNumber": (),
-    "PySide2.QtGui.QTextBlock.fragmentIndex": (),
-    "PySide2.QtGui.QTextBlock.isValid": (),
-    "PySide2.QtGui.QTextBlock.isVisible": (),
-    "PySide2.QtGui.QTextBlock.layout": (),
-    "PySide2.QtGui.QTextBlock.length": (),
-    "PySide2.QtGui.QTextBlock.lineCount": (),
-    "PySide2.QtGui.QTextBlock.position": (),
-    "PySide2.QtGui.QTextBlock.previous": (),
-    "PySide2.QtGui.QTextBlock.revision": (),
-    "PySide2.QtGui.QTextBlock.setLineCount": ('int',),
-    "PySide2.QtGui.QTextBlock.setRevision": ('int',),
-    "PySide2.QtGui.QTextBlock.setUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QTextBlock.setUserState": ('int',),
-    "PySide2.QtGui.QTextBlock.setVisible": ('bool',),
-    "PySide2.QtGui.QTextBlock.text": (),
-    "PySide2.QtGui.QTextBlock.textDirection": (),
-    "PySide2.QtGui.QTextBlock.textFormats": (),
-    "PySide2.QtGui.QTextBlock.textList": (),
-    "PySide2.QtGui.QTextBlock.userData": (),
-    "PySide2.QtGui.QTextBlock.userState": (),
-# class PySide2.QtGui.QTextBlockFormat:
-# class PySide2.QtGui.QTextBlockFormat.LineHeightTypes:
-# class PySide2.QtGui.QTextBlockFormat.MarkerType:
-    "PySide2.QtGui.QTextBlockFormat.__init__": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextBlockFormat.__copy__": (),
-    "PySide2.QtGui.QTextBlockFormat.alignment": (),
-    "PySide2.QtGui.QTextBlockFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.headingLevel": (),
-    "PySide2.QtGui.QTextBlockFormat.indent": (),
-    "PySide2.QtGui.QTextBlockFormat.isValid": (),
-    "PySide2.QtGui.QTextBlockFormat.leftMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.lineHeight": [(), ('float', 'float')],
-    "PySide2.QtGui.QTextBlockFormat.lineHeightType": (),
-    "PySide2.QtGui.QTextBlockFormat.marker": (),
-    "PySide2.QtGui.QTextBlockFormat.nonBreakableLines": (),
-    "PySide2.QtGui.QTextBlockFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextBlockFormat.rightMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextBlockFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setHeadingLevel": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setLineHeight": ('float', 'int'),
-    "PySide2.QtGui.QTextBlockFormat.setMarker": ('PySide2.QtGui.QTextBlockFormat.MarkerType',),
-    "PySide2.QtGui.QTextBlockFormat.setNonBreakableLines": ('bool',),
-    "PySide2.QtGui.QTextBlockFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextBlockFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTabPositions": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextBlockFormat.setTextIndent": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.tabPositions": (),
-    "PySide2.QtGui.QTextBlockFormat.textIndent": (),
-    "PySide2.QtGui.QTextBlockFormat.topMargin": (),
-# class PySide2.QtGui.QTextBlockGroup:
-    "PySide2.QtGui.QTextBlockGroup.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextBlockGroup.blockFormatChanged": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockInserted": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockList": (),
-    "PySide2.QtGui.QTextBlockGroup.blockRemoved": ('PySide2.QtGui.QTextBlock',),
-# class PySide2.QtGui.QTextBlockUserData:
-    "PySide2.QtGui.QTextBlockUserData.__init__": (),
-# class PySide2.QtGui.QTextCharFormat:
-# class PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior:
-# class PySide2.QtGui.QTextCharFormat.UnderlineStyle:
-# class PySide2.QtGui.QTextCharFormat.VerticalAlignment:
-    "PySide2.QtGui.QTextCharFormat.__init__": [(), ('PySide2.QtGui.QTextCharFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextCharFormat.__copy__": (),
-    "PySide2.QtGui.QTextCharFormat.anchorHref": (),
-    "PySide2.QtGui.QTextCharFormat.anchorName": (),
-    "PySide2.QtGui.QTextCharFormat.anchorNames": (),
-    "PySide2.QtGui.QTextCharFormat.font": (),
-    "PySide2.QtGui.QTextCharFormat.fontCapitalization": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamilies": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamily": (),
-    "PySide2.QtGui.QTextCharFormat.fontFixedPitch": (),
-    "PySide2.QtGui.QTextCharFormat.fontHintingPreference": (),
-    "PySide2.QtGui.QTextCharFormat.fontItalic": (),
-    "PySide2.QtGui.QTextCharFormat.fontKerning": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacingType": (),
-    "PySide2.QtGui.QTextCharFormat.fontOverline": (),
-    "PySide2.QtGui.QTextCharFormat.fontPointSize": (),
-    "PySide2.QtGui.QTextCharFormat.fontStretch": (),
-    "PySide2.QtGui.QTextCharFormat.fontStrikeOut": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleHint": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleName": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleStrategy": (),
-    "PySide2.QtGui.QTextCharFormat.fontUnderline": (),
-    "PySide2.QtGui.QTextCharFormat.fontWeight": (),
-    "PySide2.QtGui.QTextCharFormat.fontWordSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.isAnchor": (),
-    "PySide2.QtGui.QTextCharFormat.isValid": (),
-    "PySide2.QtGui.QTextCharFormat.setAnchor": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorHref": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorNames": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior')],
-    "PySide2.QtGui.QTextCharFormat.setFontCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamily": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontFixedPitch": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QTextCharFormat.setFontItalic": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontKerning": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacingType": ('PySide2.QtGui.QFont.SpacingType',),
-    "PySide2.QtGui.QTextCharFormat.setFontOverline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontPointSize": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontStretch": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontStrikeOut": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QTextCharFormat.setFontUnderline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontWeight": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontWordSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellColumnSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellRowSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTextOutline": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QTextCharFormat.setToolTip": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineStyle": ('PySide2.QtGui.QTextCharFormat.UnderlineStyle',),
-    "PySide2.QtGui.QTextCharFormat.setVerticalAlignment": ('PySide2.QtGui.QTextCharFormat.VerticalAlignment',),
-    "PySide2.QtGui.QTextCharFormat.tableCellColumnSpan": (),
-    "PySide2.QtGui.QTextCharFormat.tableCellRowSpan": (),
-    "PySide2.QtGui.QTextCharFormat.textOutline": (),
-    "PySide2.QtGui.QTextCharFormat.toolTip": (),
-    "PySide2.QtGui.QTextCharFormat.underlineColor": (),
-    "PySide2.QtGui.QTextCharFormat.underlineStyle": (),
-    "PySide2.QtGui.QTextCharFormat.verticalAlignment": (),
-# class PySide2.QtGui.QTextCursor:
-# class PySide2.QtGui.QTextCursor.MoveMode:
-# class PySide2.QtGui.QTextCursor.MoveOperation:
-# class PySide2.QtGui.QTextCursor.SelectionType:
-    "PySide2.QtGui.QTextCursor.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextFrame',)],
-    "PySide2.QtGui.QTextCursor.__copy__": (),
-    "PySide2.QtGui.QTextCursor.anchor": (),
-    "PySide2.QtGui.QTextCursor.atBlockEnd": (),
-    "PySide2.QtGui.QTextCursor.atBlockStart": (),
-    "PySide2.QtGui.QTextCursor.atEnd": (),
-    "PySide2.QtGui.QTextCursor.atStart": (),
-    "PySide2.QtGui.QTextCursor.beginEditBlock": (),
-    "PySide2.QtGui.QTextCursor.block": (),
-    "PySide2.QtGui.QTextCursor.blockCharFormat": (),
-    "PySide2.QtGui.QTextCursor.blockFormat": (),
-    "PySide2.QtGui.QTextCursor.blockNumber": (),
-    "PySide2.QtGui.QTextCursor.charFormat": (),
-    "PySide2.QtGui.QTextCursor.clearSelection": (),
-    "PySide2.QtGui.QTextCursor.columnNumber": (),
-    "PySide2.QtGui.QTextCursor.createList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.currentFrame": (),
-    "PySide2.QtGui.QTextCursor.currentList": (),
-    "PySide2.QtGui.QTextCursor.currentTable": (),
-    "PySide2.QtGui.QTextCursor.deleteChar": (),
-    "PySide2.QtGui.QTextCursor.deletePreviousChar": (),
-    "PySide2.QtGui.QTextCursor.document": (),
-    "PySide2.QtGui.QTextCursor.endEditBlock": (),
-    "PySide2.QtGui.QTextCursor.hasComplexSelection": (),
-    "PySide2.QtGui.QTextCursor.hasSelection": (),
-    "PySide2.QtGui.QTextCursor.insertBlock": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextBlockFormat', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.insertFragment": ('PySide2.QtGui.QTextDocumentFragment',),
-    "PySide2.QtGui.QTextCursor.insertFrame": ('PySide2.QtGui.QTextFrameFormat',),
-    "PySide2.QtGui.QTextCursor.insertHtml": ('str',),
-    "PySide2.QtGui.QTextCursor.insertImage": [('PySide2.QtGui.QImage', 'str'), ('PySide2.QtGui.QTextImageFormat',), ('PySide2.QtGui.QTextImageFormat', 'PySide2.QtGui.QTextFrameFormat.Position'), ('str',)],
-    "PySide2.QtGui.QTextCursor.insertList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.insertTable": [('int', 'int'), ('int', 'int', 'PySide2.QtGui.QTextTableFormat')],
-    "PySide2.QtGui.QTextCursor.insertText": [('str',), ('str', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.isCopyOf": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.isNull": (),
-    "PySide2.QtGui.QTextCursor.joinPreviousEditBlock": (),
-    "PySide2.QtGui.QTextCursor.keepPositionOnInsert": (),
-    "PySide2.QtGui.QTextCursor.mergeBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.mergeBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.mergeCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.movePosition": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode', 'int'),
-    "PySide2.QtGui.QTextCursor.position": (),
-    "PySide2.QtGui.QTextCursor.positionInBlock": (),
-    "PySide2.QtGui.QTextCursor.removeSelectedText": (),
-    "PySide2.QtGui.QTextCursor.select": ('PySide2.QtGui.QTextCursor.SelectionType',),
-    "PySide2.QtGui.QTextCursor.selectedTableCells": (),
-    "PySide2.QtGui.QTextCursor.selectedText": (),
-    "PySide2.QtGui.QTextCursor.selection": (),
-    "PySide2.QtGui.QTextCursor.selectionEnd": (),
-    "PySide2.QtGui.QTextCursor.selectionStart": (),
-    "PySide2.QtGui.QTextCursor.setBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.setCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setKeepPositionOnInsert": ('bool',),
-    "PySide2.QtGui.QTextCursor.setPosition": ('int', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtGui.QTextCursor.setVerticalMovementX": ('int',),
-    "PySide2.QtGui.QTextCursor.setVisualNavigation": ('bool',),
-    "PySide2.QtGui.QTextCursor.swap": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.verticalMovementX": (),
-    "PySide2.QtGui.QTextCursor.visualNavigation": (),
-# class PySide2.QtGui.QTextDocument:
-# class PySide2.QtGui.QTextDocument.FindFlag:
-# class PySide2.QtGui.QTextDocument.FindFlags:
-# class PySide2.QtGui.QTextDocument.MarkdownFeature:
-# class PySide2.QtGui.QTextDocument.MarkdownFeatures:
-# class PySide2.QtGui.QTextDocument.MetaInformation:
-# class PySide2.QtGui.QTextDocument.ResourceType:
-# class PySide2.QtGui.QTextDocument.Stacks:
-    "PySide2.QtGui.QTextDocument.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QTextDocument.addResource": ('int', 'PySide2.QtCore.QUrl', 'typing.Any'),
-    "PySide2.QtGui.QTextDocument.adjustSize": (),
-    "PySide2.QtGui.QTextDocument.allFormats": (),
-    "PySide2.QtGui.QTextDocument.availableRedoSteps": (),
-    "PySide2.QtGui.QTextDocument.availableUndoSteps": (),
-    "PySide2.QtGui.QTextDocument.baseUrl": (),
-    "PySide2.QtGui.QTextDocument.begin": (),
-    "PySide2.QtGui.QTextDocument.blockCount": (),
-    "PySide2.QtGui.QTextDocument.characterAt": ('int',),
-    "PySide2.QtGui.QTextDocument.characterCount": (),
-    "PySide2.QtGui.QTextDocument.clear": (),
-    "PySide2.QtGui.QTextDocument.clearUndoRedoStacks": ('PySide2.QtGui.QTextDocument.Stacks',),
-    "PySide2.QtGui.QTextDocument.clone": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTextDocument.createObject": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.defaultCursorMoveStyle": (),
-    "PySide2.QtGui.QTextDocument.defaultFont": (),
-    "PySide2.QtGui.QTextDocument.defaultStyleSheet": (),
-    "PySide2.QtGui.QTextDocument.defaultTextOption": (),
-    "PySide2.QtGui.QTextDocument.documentLayout": (),
-    "PySide2.QtGui.QTextDocument.documentMargin": (),
-    "PySide2.QtGui.QTextDocument.drawContents": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextDocument.end": (),
-    "PySide2.QtGui.QTextDocument.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegExp', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'int', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtGui.QTextDocument.findBlock": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByLineNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.firstBlock": (),
-    "PySide2.QtGui.QTextDocument.frameAt": ('int',),
-    "PySide2.QtGui.QTextDocument.idealWidth": (),
-    "PySide2.QtGui.QTextDocument.indentWidth": (),
-    "PySide2.QtGui.QTextDocument.isEmpty": (),
-    "PySide2.QtGui.QTextDocument.isModified": (),
-    "PySide2.QtGui.QTextDocument.isRedoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoRedoEnabled": (),
-    "PySide2.QtGui.QTextDocument.lastBlock": (),
-    "PySide2.QtGui.QTextDocument.lineCount": (),
-    "PySide2.QtGui.QTextDocument.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.markContentsDirty": ('int', 'int'),
-    "PySide2.QtGui.QTextDocument.maximumBlockCount": (),
-    "PySide2.QtGui.QTextDocument.metaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation',),
-    "PySide2.QtGui.QTextDocument.object": ('int',),
-    "PySide2.QtGui.QTextDocument.objectForFormat": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.pageCount": (),
-    "PySide2.QtGui.QTextDocument.pageSize": (),
-    "PySide2.QtGui.QTextDocument.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtGui.QTextDocument.redo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.resource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.revision": (),
-    "PySide2.QtGui.QTextDocument.rootFrame": (),
-    "PySide2.QtGui.QTextDocument.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QTextDocument.setDefaultCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextDocument.setDefaultFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextDocument.setDefaultStyleSheet": ('str',),
-    "PySide2.QtGui.QTextDocument.setDefaultTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextDocument.setDocumentLayout": ('PySide2.QtGui.QAbstractTextDocumentLayout',),
-    "PySide2.QtGui.QTextDocument.setDocumentMargin": ('float',),
-    "PySide2.QtGui.QTextDocument.setHtml": ('str',),
-    "PySide2.QtGui.QTextDocument.setIndentWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setMarkdown": ('str', 'PySide2.QtGui.QTextDocument.MarkdownFeatures'),
-    "PySide2.QtGui.QTextDocument.setMaximumBlockCount": ('int',),
-    "PySide2.QtGui.QTextDocument.setMetaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation', 'str'),
-    "PySide2.QtGui.QTextDocument.setModified": ('bool',),
-    "PySide2.QtGui.QTextDocument.setPageSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTextDocument.setPlainText": ('str',),
-    "PySide2.QtGui.QTextDocument.setTextWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtGui.QTextDocument.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextDocument.size": (),
-    "PySide2.QtGui.QTextDocument.textWidth": (),
-    "PySide2.QtGui.QTextDocument.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocument.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtGui.QTextDocument.toPlainText": (),
-    "PySide2.QtGui.QTextDocument.toRawText": (),
-    "PySide2.QtGui.QTextDocument.undo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.useDesignMetrics": (),
-# class PySide2.QtGui.QTextDocumentFragment:
-    "PySide2.QtGui.QTextDocumentFragment.__init__": [(), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-    "PySide2.QtGui.QTextDocumentFragment.__copy__": (),
-    "PySide2.QtGui.QTextDocumentFragment.fromHtml": [('str',), ('str', 'PySide2.QtGui.QTextDocument')],
-    "PySide2.QtGui.QTextDocumentFragment.fromPlainText": ('str',),
-    "PySide2.QtGui.QTextDocumentFragment.isEmpty": (),
-    "PySide2.QtGui.QTextDocumentFragment.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentFragment.toPlainText": (),
-# class PySide2.QtGui.QTextDocumentWriter:
-    "PySide2.QtGui.QTextDocumentWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QTextDocumentWriter.codec": (),
-    "PySide2.QtGui.QTextDocumentWriter.device": (),
-    "PySide2.QtGui.QTextDocumentWriter.fileName": (),
-    "PySide2.QtGui.QTextDocumentWriter.format": (),
-    "PySide2.QtGui.QTextDocumentWriter.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtGui.QTextDocumentWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QTextDocumentWriter.setFileName": ('str',),
-    "PySide2.QtGui.QTextDocumentWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentWriter.supportedDocumentFormats": (),
-    "PySide2.QtGui.QTextDocumentWriter.write": [('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-# class PySide2.QtGui.QTextFormat:
-# class PySide2.QtGui.QTextFormat.FormatType:
-# class PySide2.QtGui.QTextFormat.ObjectTypes:
-# class PySide2.QtGui.QTextFormat.PageBreakFlag:
-# class PySide2.QtGui.QTextFormat.PageBreakFlags:
-# class PySide2.QtGui.QTextFormat.Property:
-    "PySide2.QtGui.QTextFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('int',)],
-    "PySide2.QtGui.QTextFormat.__copy__": (),
-    "PySide2.QtGui.QTextFormat.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.background": (),
-    "PySide2.QtGui.QTextFormat.boolProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.brushProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.clearBackground": (),
-    "PySide2.QtGui.QTextFormat.clearForeground": (),
-    "PySide2.QtGui.QTextFormat.clearProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.colorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.doubleProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.foreground": (),
-    "PySide2.QtGui.QTextFormat.hasProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.intProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.isBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.isCharFormat": (),
-    "PySide2.QtGui.QTextFormat.isEmpty": (),
-    "PySide2.QtGui.QTextFormat.isFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.isImageFormat": (),
-    "PySide2.QtGui.QTextFormat.isListFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableFormat": (),
-    "PySide2.QtGui.QTextFormat.isValid": (),
-    "PySide2.QtGui.QTextFormat.layoutDirection": (),
-    "PySide2.QtGui.QTextFormat.lengthProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.lengthVectorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.merge": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.objectIndex": (),
-    "PySide2.QtGui.QTextFormat.objectType": (),
-    "PySide2.QtGui.QTextFormat.penProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.properties": (),
-    "PySide2.QtGui.QTextFormat.property": ('int',),
-    "PySide2.QtGui.QTextFormat.propertyCount": (),
-    "PySide2.QtGui.QTextFormat.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextFormat.setObjectIndex": ('int',),
-    "PySide2.QtGui.QTextFormat.setObjectType": ('int',),
-    "PySide2.QtGui.QTextFormat.setProperty": [('int', 'typing.Any'), ('int', 'typing.List[PySide2.QtGui.QTextLength]')],
-    "PySide2.QtGui.QTextFormat.stringProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.swap": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.toBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.toCharFormat": (),
-    "PySide2.QtGui.QTextFormat.toFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.toImageFormat": (),
-    "PySide2.QtGui.QTextFormat.toListFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableFormat": (),
-    "PySide2.QtGui.QTextFormat.type": (),
-# class PySide2.QtGui.QTextFragment:
-    "PySide2.QtGui.QTextFragment.__init__": [(), ('PySide2.QtGui.QTextFragment',)],
-    "PySide2.QtGui.QTextFragment.__copy__": (),
-    "PySide2.QtGui.QTextFragment.charFormat": (),
-    "PySide2.QtGui.QTextFragment.charFormatIndex": (),
-    "PySide2.QtGui.QTextFragment.contains": ('int',),
-    "PySide2.QtGui.QTextFragment.isValid": (),
-    "PySide2.QtGui.QTextFragment.length": (),
-    "PySide2.QtGui.QTextFragment.position": (),
-    "PySide2.QtGui.QTextFragment.text": (),
-# class PySide2.QtGui.QTextFrame:
-# class PySide2.QtGui.QTextFrame.iterator:
-    "PySide2.QtGui.QTextFrame.iterator.__init__": [(), ('PySide2.QtGui.QTextFrame.iterator',)],
-    "PySide2.QtGui.QTextFrame.iterator.__copy__": (),
-    "PySide2.QtGui.QTextFrame.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__iter__": (),
-    "PySide2.QtGui.QTextFrame.iterator.atEnd": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentBlock": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentFrame": (),
-    "PySide2.QtGui.QTextFrame.iterator.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextFrame.__iter__": (),
-    "PySide2.QtGui.QTextFrame.begin": (),
-    "PySide2.QtGui.QTextFrame.childFrames": (),
-    "PySide2.QtGui.QTextFrame.end": (),
-    "PySide2.QtGui.QTextFrame.firstCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.firstPosition": (),
-    "PySide2.QtGui.QTextFrame.frameFormat": (),
-    "PySide2.QtGui.QTextFrame.lastCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.lastPosition": (),
-    "PySide2.QtGui.QTextFrame.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.setFrameFormat": ('PySide2.QtGui.QTextFrameFormat',),
-# class PySide2.QtGui.QTextFrameFormat:
-# class PySide2.QtGui.QTextFrameFormat.BorderStyle:
-# class PySide2.QtGui.QTextFrameFormat.Position:
-    "PySide2.QtGui.QTextFrameFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextFrameFormat',)],
-    "PySide2.QtGui.QTextFrameFormat.__copy__": (),
-    "PySide2.QtGui.QTextFrameFormat.border": (),
-    "PySide2.QtGui.QTextFrameFormat.borderBrush": (),
-    "PySide2.QtGui.QTextFrameFormat.borderStyle": (),
-    "PySide2.QtGui.QTextFrameFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.height": (),
-    "PySide2.QtGui.QTextFrameFormat.isValid": (),
-    "PySide2.QtGui.QTextFrameFormat.leftMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.margin": (),
-    "PySide2.QtGui.QTextFrameFormat.padding": (),
-    "PySide2.QtGui.QTextFrameFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextFrameFormat.position": (),
-    "PySide2.QtGui.QTextFrameFormat.rightMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextFrameFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setHeight": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextFrameFormat.setPosition": ('PySide2.QtGui.QTextFrameFormat.Position',),
-    "PySide2.QtGui.QTextFrameFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setWidth": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.topMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.width": (),
-# class PySide2.QtGui.QTextImageFormat:
-    "PySide2.QtGui.QTextImageFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextImageFormat',)],
-    "PySide2.QtGui.QTextImageFormat.__copy__": (),
-    "PySide2.QtGui.QTextImageFormat.height": (),
-    "PySide2.QtGui.QTextImageFormat.isValid": (),
-    "PySide2.QtGui.QTextImageFormat.name": (),
-    "PySide2.QtGui.QTextImageFormat.quality": (),
-    "PySide2.QtGui.QTextImageFormat.setHeight": ('float',),
-    "PySide2.QtGui.QTextImageFormat.setName": ('str',),
-    "PySide2.QtGui.QTextImageFormat.setQuality": ('int',),
-    "PySide2.QtGui.QTextImageFormat.setWidth": ('float',),
-    "PySide2.QtGui.QTextImageFormat.width": (),
-# class PySide2.QtGui.QTextInlineObject:
-    "PySide2.QtGui.QTextInlineObject.__init__": (),
-    "PySide2.QtGui.QTextInlineObject.__copy__": (),
-    "PySide2.QtGui.QTextInlineObject.ascent": (),
-    "PySide2.QtGui.QTextInlineObject.descent": (),
-    "PySide2.QtGui.QTextInlineObject.format": (),
-    "PySide2.QtGui.QTextInlineObject.formatIndex": (),
-    "PySide2.QtGui.QTextInlineObject.height": (),
-    "PySide2.QtGui.QTextInlineObject.isValid": (),
-    "PySide2.QtGui.QTextInlineObject.rect": (),
-    "PySide2.QtGui.QTextInlineObject.setAscent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setDescent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setWidth": ('float',),
-    "PySide2.QtGui.QTextInlineObject.textDirection": (),
-    "PySide2.QtGui.QTextInlineObject.textPosition": (),
-    "PySide2.QtGui.QTextInlineObject.width": (),
-# class PySide2.QtGui.QTextItem:
-# class PySide2.QtGui.QTextItem.RenderFlag:
-# class PySide2.QtGui.QTextItem.RenderFlags:
-    "PySide2.QtGui.QTextItem.__init__": (),
-    "PySide2.QtGui.QTextItem.ascent": (),
-    "PySide2.QtGui.QTextItem.descent": (),
-    "PySide2.QtGui.QTextItem.font": (),
-    "PySide2.QtGui.QTextItem.renderFlags": (),
-    "PySide2.QtGui.QTextItem.text": (),
-    "PySide2.QtGui.QTextItem.width": (),
-# class PySide2.QtGui.QTextLayout:
-# class PySide2.QtGui.QTextLayout.CursorMode:
-# class PySide2.QtGui.QTextLayout.FormatRange:
-    "PySide2.QtGui.QTextLayout.FormatRange.__init__": [(), ('PySide2.QtGui.QTextLayout.FormatRange',)],
-    "PySide2.QtGui.QTextLayout.FormatRange.__copy__": (),
-    "PySide2.QtGui.QTextLayout.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('str',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice')],
-    "PySide2.QtGui.QTextLayout.additionalFormats": (),
-    "PySide2.QtGui.QTextLayout.beginLayout": (),
-    "PySide2.QtGui.QTextLayout.boundingRect": (),
-    "PySide2.QtGui.QTextLayout.cacheEnabled": (),
-    "PySide2.QtGui.QTextLayout.clearAdditionalFormats": (),
-    "PySide2.QtGui.QTextLayout.clearFormats": (),
-    "PySide2.QtGui.QTextLayout.clearLayout": (),
-    "PySide2.QtGui.QTextLayout.createLine": (),
-    "PySide2.QtGui.QTextLayout.cursorMoveStyle": (),
-    "PySide2.QtGui.QTextLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'typing.List[PySide2.QtGui.QTextLayout.FormatRange]', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextLayout.drawCursor": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int', 'int')],
-    "PySide2.QtGui.QTextLayout.endLayout": (),
-    "PySide2.QtGui.QTextLayout.font": (),
-    "PySide2.QtGui.QTextLayout.formats": (),
-    "PySide2.QtGui.QTextLayout.isValidCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.leftCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.lineAt": ('int',),
-    "PySide2.QtGui.QTextLayout.lineCount": (),
-    "PySide2.QtGui.QTextLayout.lineForTextPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.maximumWidth": (),
-    "PySide2.QtGui.QTextLayout.minimumWidth": (),
-    "PySide2.QtGui.QTextLayout.nextCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.position": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaPosition": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaText": (),
-    "PySide2.QtGui.QTextLayout.previousCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.rightCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.setAdditionalFormats": ('typing.Sequence[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setCacheEnabled": ('bool',),
-    "PySide2.QtGui.QTextLayout.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextLayout.setFlags": ('int',),
-    "PySide2.QtGui.QTextLayout.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextLayout.setFormats": ('typing.List[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLayout.setPreeditArea": ('int', 'str'),
-    "PySide2.QtGui.QTextLayout.setRawFont": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QTextLayout.setText": ('str',),
-    "PySide2.QtGui.QTextLayout.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextLayout.text": (),
-    "PySide2.QtGui.QTextLayout.textOption": (),
-# class PySide2.QtGui.QTextLength:
-# class PySide2.QtGui.QTextLength.Type:
-    "PySide2.QtGui.QTextLength.__init__": [(), ('PySide2.QtGui.QTextLength',), ('PySide2.QtGui.QTextLength.Type', 'float')],
-    "PySide2.QtGui.QTextLength.__copy__": (),
-    "PySide2.QtGui.QTextLength.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.rawValue": (),
-    "PySide2.QtGui.QTextLength.type": (),
-    "PySide2.QtGui.QTextLength.value": ('float',),
-# class PySide2.QtGui.QTextLine:
-# class PySide2.QtGui.QTextLine.CursorPosition:
-# class PySide2.QtGui.QTextLine.Edge:
-    "PySide2.QtGui.QTextLine.__init__": (),
-    "PySide2.QtGui.QTextLine.__copy__": (),
-    "PySide2.QtGui.QTextLine.ascent": (),
-    "PySide2.QtGui.QTextLine.cursorToX": ('int', 'PySide2.QtGui.QTextLine.Edge'),
-    "PySide2.QtGui.QTextLine.descent": (),
-    "PySide2.QtGui.QTextLine.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextLayout.FormatRange'),
-    "PySide2.QtGui.QTextLine.height": (),
-    "PySide2.QtGui.QTextLine.horizontalAdvance": (),
-    "PySide2.QtGui.QTextLine.isValid": (),
-    "PySide2.QtGui.QTextLine.leading": (),
-    "PySide2.QtGui.QTextLine.leadingIncluded": (),
-    "PySide2.QtGui.QTextLine.lineNumber": (),
-    "PySide2.QtGui.QTextLine.naturalTextRect": (),
-    "PySide2.QtGui.QTextLine.naturalTextWidth": (),
-    "PySide2.QtGui.QTextLine.position": (),
-    "PySide2.QtGui.QTextLine.rect": (),
-    "PySide2.QtGui.QTextLine.setLeadingIncluded": ('bool',),
-    "PySide2.QtGui.QTextLine.setLineWidth": ('float',),
-    "PySide2.QtGui.QTextLine.setNumColumns": [('int',), ('int', 'float')],
-    "PySide2.QtGui.QTextLine.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLine.textLength": (),
-    "PySide2.QtGui.QTextLine.textStart": (),
-    "PySide2.QtGui.QTextLine.width": (),
-    "PySide2.QtGui.QTextLine.x": (),
-    "PySide2.QtGui.QTextLine.xToCursor": ('float', 'PySide2.QtGui.QTextLine.CursorPosition'),
-    "PySide2.QtGui.QTextLine.y": (),
-# class PySide2.QtGui.QTextList:
-    "PySide2.QtGui.QTextList.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextList.add": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.count": (),
-    "PySide2.QtGui.QTextList.format": (),
-    "PySide2.QtGui.QTextList.item": ('int',),
-    "PySide2.QtGui.QTextList.itemNumber": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.itemText": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.remove": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.removeItem": ('int',),
-    "PySide2.QtGui.QTextList.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-# class PySide2.QtGui.QTextListFormat:
-# class PySide2.QtGui.QTextListFormat.Style:
-    "PySide2.QtGui.QTextListFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-    "PySide2.QtGui.QTextListFormat.__copy__": (),
-    "PySide2.QtGui.QTextListFormat.indent": (),
-    "PySide2.QtGui.QTextListFormat.isValid": (),
-    "PySide2.QtGui.QTextListFormat.numberPrefix": (),
-    "PySide2.QtGui.QTextListFormat.numberSuffix": (),
-    "PySide2.QtGui.QTextListFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextListFormat.setNumberPrefix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setNumberSuffix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setStyle": ('PySide2.QtGui.QTextListFormat.Style',),
-    "PySide2.QtGui.QTextListFormat.style": (),
-# class PySide2.QtGui.QTextObject:
-    "PySide2.QtGui.QTextObject.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextObject.document": (),
-    "PySide2.QtGui.QTextObject.format": (),
-    "PySide2.QtGui.QTextObject.formatIndex": (),
-    "PySide2.QtGui.QTextObject.objectIndex": (),
-    "PySide2.QtGui.QTextObject.setFormat": ('PySide2.QtGui.QTextFormat',),
-# class PySide2.QtGui.QTextObjectInterface:
-    "PySide2.QtGui.QTextObjectInterface.__init__": (),
-    "PySide2.QtGui.QTextObjectInterface.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QTextObjectInterface.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QTextOption:
-# class PySide2.QtGui.QTextOption.Flag:
-# class PySide2.QtGui.QTextOption.Flags:
-# class PySide2.QtGui.QTextOption.Tab:
-    "PySide2.QtGui.QTextOption.Tab.__init__": [(), ('PySide2.QtGui.QTextOption.Tab',), ('float', 'PySide2.QtGui.QTextOption.TabType', 'str')],
-    "PySide2.QtGui.QTextOption.Tab.__copy__": (),
-# class PySide2.QtGui.QTextOption.TabType:
-# class PySide2.QtGui.QTextOption.WrapMode:
-    "PySide2.QtGui.QTextOption.__init__": [(), ('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtGui.QTextOption',)],
-    "PySide2.QtGui.QTextOption.__copy__": (),
-    "PySide2.QtGui.QTextOption.alignment": (),
-    "PySide2.QtGui.QTextOption.flags": (),
-    "PySide2.QtGui.QTextOption.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextOption.setFlags": ('PySide2.QtGui.QTextOption.Flags',),
-    "PySide2.QtGui.QTextOption.setTabArray": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QTextOption.setTabStop": ('float',),
-    "PySide2.QtGui.QTextOption.setTabStopDistance": ('float',),
-    "PySide2.QtGui.QTextOption.setTabs": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextOption.setTextDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextOption.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextOption.setWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtGui.QTextOption.tabArray": (),
-    "PySide2.QtGui.QTextOption.tabStop": (),
-    "PySide2.QtGui.QTextOption.tabStopDistance": (),
-    "PySide2.QtGui.QTextOption.tabs": (),
-    "PySide2.QtGui.QTextOption.textDirection": (),
-    "PySide2.QtGui.QTextOption.useDesignMetrics": (),
-    "PySide2.QtGui.QTextOption.wrapMode": (),
-# class PySide2.QtGui.QTextTable:
-    "PySide2.QtGui.QTextTable.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextTable.appendColumns": ('int',),
-    "PySide2.QtGui.QTextTable.appendRows": ('int',),
-    "PySide2.QtGui.QTextTable.cellAt": [('PySide2.QtGui.QTextCursor',), ('int',), ('int', 'int')],
-    "PySide2.QtGui.QTextTable.columns": (),
-    "PySide2.QtGui.QTextTable.format": (),
-    "PySide2.QtGui.QTextTable.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.insertRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.mergeCells": [('PySide2.QtGui.QTextCursor',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QTextTable.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.resize": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.rowEnd": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rowStart": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rows": (),
-    "PySide2.QtGui.QTextTable.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTable.splitCell": ('int', 'int', 'int', 'int'),
-# class PySide2.QtGui.QTextTableCell:
-    "PySide2.QtGui.QTextTableCell.__init__": [(), ('PySide2.QtGui.QTextTableCell',)],
-    "PySide2.QtGui.QTextTableCell.__copy__": (),
-    "PySide2.QtGui.QTextTableCell.begin": (),
-    "PySide2.QtGui.QTextTableCell.column": (),
-    "PySide2.QtGui.QTextTableCell.columnSpan": (),
-    "PySide2.QtGui.QTextTableCell.end": (),
-    "PySide2.QtGui.QTextTableCell.firstCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.firstPosition": (),
-    "PySide2.QtGui.QTextTableCell.format": (),
-    "PySide2.QtGui.QTextTableCell.isValid": (),
-    "PySide2.QtGui.QTextTableCell.lastCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.lastPosition": (),
-    "PySide2.QtGui.QTextTableCell.row": (),
-    "PySide2.QtGui.QTextTableCell.rowSpan": (),
-    "PySide2.QtGui.QTextTableCell.setFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextTableCell.tableCellFormatIndex": (),
-# class PySide2.QtGui.QTextTableCellFormat:
-    "PySide2.QtGui.QTextTableCellFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableCellFormat',)],
-    "PySide2.QtGui.QTextTableCellFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.isValid": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.topBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.topPadding": (),
-# class PySide2.QtGui.QTextTableFormat:
-    "PySide2.QtGui.QTextTableFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTableFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableFormat.alignment": (),
-    "PySide2.QtGui.QTextTableFormat.borderCollapse": (),
-    "PySide2.QtGui.QTextTableFormat.cellPadding": (),
-    "PySide2.QtGui.QTextTableFormat.cellSpacing": (),
-    "PySide2.QtGui.QTextTableFormat.clearColumnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columns": (),
-    "PySide2.QtGui.QTextTableFormat.headerRowCount": (),
-    "PySide2.QtGui.QTextTableFormat.isValid": (),
-    "PySide2.QtGui.QTextTableFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextTableFormat.setBorderCollapse": ('bool',),
-    "PySide2.QtGui.QTextTableFormat.setCellPadding": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setCellSpacing": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setColumnWidthConstraints": ('typing.List[PySide2.QtGui.QTextLength]',),
-    "PySide2.QtGui.QTextTableFormat.setColumns": ('int',),
-    "PySide2.QtGui.QTextTableFormat.setHeaderRowCount": ('int',),
-# class PySide2.QtGui.QToolBarChangeEvent:
-    "PySide2.QtGui.QToolBarChangeEvent.__init__": ('bool',),
-    "PySide2.QtGui.QToolBarChangeEvent.toggle": (),
-# class PySide2.QtGui.QTouchDevice:
-# class PySide2.QtGui.QTouchDevice.Capabilities:
-# class PySide2.QtGui.QTouchDevice.CapabilityFlag:
-# class PySide2.QtGui.QTouchDevice.DeviceType:
-    "PySide2.QtGui.QTouchDevice.__init__": (),
-    "PySide2.QtGui.QTouchDevice.capabilities": (),
-    "PySide2.QtGui.QTouchDevice.devices": (),
-    "PySide2.QtGui.QTouchDevice.maximumTouchPoints": (),
-    "PySide2.QtGui.QTouchDevice.name": (),
-    "PySide2.QtGui.QTouchDevice.setCapabilities": ('PySide2.QtGui.QTouchDevice.Capabilities',),
-    "PySide2.QtGui.QTouchDevice.setMaximumTouchPoints": ('int',),
-    "PySide2.QtGui.QTouchDevice.setName": ('str',),
-    "PySide2.QtGui.QTouchDevice.setType": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtGui.QTouchDevice.type": (),
-# class PySide2.QtGui.QTouchEvent:
-# class PySide2.QtGui.QTouchEvent.TouchPoint:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlag:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags:
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__init__": [('PySide2.QtGui.QTouchEvent.TouchPoint',), ('int',)],
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__copy__": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.ellipseDiameters": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.flags": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.id": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.normalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pressure": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rawScreenPositions": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rotation": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.scenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.sceneRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setEllipseDiameters": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setFlags": ('PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPressure": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRawScreenPositions": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRotation": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setState": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setUniqueId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setVelocity": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.state": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.swap": ('PySide2.QtGui.QTouchEvent.TouchPoint',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.uniqueId": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.velocity": (),
-    "PySide2.QtGui.QTouchEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.TouchPointStates', 'typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]'),
-    "PySide2.QtGui.QTouchEvent.device": (),
-    "PySide2.QtGui.QTouchEvent.setDevice": ('PySide2.QtGui.QTouchDevice',),
-    "PySide2.QtGui.QTouchEvent.setTarget": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTouchEvent.setTouchPointStates": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.setTouchPoints": ('typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]',),
-    "PySide2.QtGui.QTouchEvent.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QTouchEvent.target": (),
-    "PySide2.QtGui.QTouchEvent.touchPointStates": (),
-    "PySide2.QtGui.QTouchEvent.touchPoints": (),
-    "PySide2.QtGui.QTouchEvent.window": (),
-# class PySide2.QtGui.QTransform:
-# class PySide2.QtGui.QTransform.TransformationType:
-    "PySide2.QtGui.QTransform.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QTransform.__add__": ('float',),
-    "PySide2.QtGui.QTransform.__copy__": (),
-    "PySide2.QtGui.QTransform.__iadd__": ('float',),
-    "PySide2.QtGui.QTransform.__imul__": [('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__isub__": ('float',),
-    "PySide2.QtGui.QTransform.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__reduce__": (),
-    "PySide2.QtGui.QTransform.__repr__": (),
-    "PySide2.QtGui.QTransform.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__sub__": ('float',),
-    "PySide2.QtGui.QTransform.adjoint": (),
-    "PySide2.QtGui.QTransform.det": (),
-    "PySide2.QtGui.QTransform.determinant": (),
-    "PySide2.QtGui.QTransform.dx": (),
-    "PySide2.QtGui.QTransform.dy": (),
-    "PySide2.QtGui.QTransform.fromScale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.fromTranslate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.inverted": (),
-    "PySide2.QtGui.QTransform.isAffine": (),
-    "PySide2.QtGui.QTransform.isIdentity": (),
-    "PySide2.QtGui.QTransform.isInvertible": (),
-    "PySide2.QtGui.QTransform.isRotating": (),
-    "PySide2.QtGui.QTransform.isScaling": (),
-    "PySide2.QtGui.QTransform.isTranslating": (),
-    "PySide2.QtGui.QTransform.m11": (),
-    "PySide2.QtGui.QTransform.m12": (),
-    "PySide2.QtGui.QTransform.m13": (),
-    "PySide2.QtGui.QTransform.m21": (),
-    "PySide2.QtGui.QTransform.m22": (),
-    "PySide2.QtGui.QTransform.m23": (),
-    "PySide2.QtGui.QTransform.m31": (),
-    "PySide2.QtGui.QTransform.m32": (),
-    "PySide2.QtGui.QTransform.m33": (),
-    "PySide2.QtGui.QTransform.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float')],
-    "PySide2.QtGui.QTransform.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QTransform.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QTransform.quadToQuad": [('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.quadToSquare": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.reset": (),
-    "PySide2.QtGui.QTransform.rotate": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.rotateRadians": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.scale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QTransform.shear": ('float', 'float'),
-    "PySide2.QtGui.QTransform.squareToQuad": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.toAffine": (),
-    "PySide2.QtGui.QTransform.translate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.transposed": (),
-    "PySide2.QtGui.QTransform.type": (),
-# class PySide2.QtGui.QValidator:
-# class PySide2.QtGui.QValidator.State:
-    "PySide2.QtGui.QValidator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QValidator.fixup": ('str',),
-    "PySide2.QtGui.QValidator.locale": (),
-    "PySide2.QtGui.QValidator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtGui.QValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QVector2D:
-    "PySide2.QtGui.QVector2D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',), ('float', 'float')],
-    "PySide2.QtGui.QVector2D.__add__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__copy__": (),
-    "PySide2.QtGui.QVector2D.__iadd__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__imul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__isub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__mul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__neg__": (),
-    "PySide2.QtGui.QVector2D.__reduce__": (),
-    "PySide2.QtGui.QVector2D.__repr__": (),
-    "PySide2.QtGui.QVector2D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__sub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.distanceToLine": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.distanceToPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.dotProduct": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.isNull": (),
-    "PySide2.QtGui.QVector2D.length": (),
-    "PySide2.QtGui.QVector2D.lengthSquared": (),
-    "PySide2.QtGui.QVector2D.normalize": (),
-    "PySide2.QtGui.QVector2D.normalized": (),
-    "PySide2.QtGui.QVector2D.setX": ('float',),
-    "PySide2.QtGui.QVector2D.setY": ('float',),
-    "PySide2.QtGui.QVector2D.toPoint": (),
-    "PySide2.QtGui.QVector2D.toPointF": (),
-    "PySide2.QtGui.QVector2D.toTuple": (),
-    "PySide2.QtGui.QVector2D.toVector3D": (),
-    "PySide2.QtGui.QVector2D.toVector4D": (),
-    "PySide2.QtGui.QVector2D.x": (),
-    "PySide2.QtGui.QVector2D.y": (),
-# class PySide2.QtGui.QVector3D:
-    "PySide2.QtGui.QVector3D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float'), ('PySide2.QtGui.QVector4D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QVector3D.__add__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__copy__": (),
-    "PySide2.QtGui.QVector3D.__iadd__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__imul__": [('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__isub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QQuaternion',), ('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__neg__": (),
-    "PySide2.QtGui.QVector3D.__reduce__": (),
-    "PySide2.QtGui.QVector3D.__repr__": (),
-    "PySide2.QtGui.QVector3D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__sub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.crossProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToLine": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToPlane": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.distanceToPoint": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.dotProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.isNull": (),
-    "PySide2.QtGui.QVector3D.length": (),
-    "PySide2.QtGui.QVector3D.lengthSquared": (),
-    "PySide2.QtGui.QVector3D.normal": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.normalize": (),
-    "PySide2.QtGui.QVector3D.normalized": (),
-    "PySide2.QtGui.QVector3D.project": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.setX": ('float',),
-    "PySide2.QtGui.QVector3D.setY": ('float',),
-    "PySide2.QtGui.QVector3D.setZ": ('float',),
-    "PySide2.QtGui.QVector3D.toPoint": (),
-    "PySide2.QtGui.QVector3D.toPointF": (),
-    "PySide2.QtGui.QVector3D.toTuple": (),
-    "PySide2.QtGui.QVector3D.toVector2D": (),
-    "PySide2.QtGui.QVector3D.toVector4D": (),
-    "PySide2.QtGui.QVector3D.unproject": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.x": (),
-    "PySide2.QtGui.QVector3D.y": (),
-    "PySide2.QtGui.QVector3D.z": (),
-# class PySide2.QtGui.QVector4D:
-    "PySide2.QtGui.QVector4D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float', 'float'), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QVector4D.__add__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__copy__": (),
-    "PySide2.QtGui.QVector4D.__iadd__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__imul__": [('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__isub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__neg__": (),
-    "PySide2.QtGui.QVector4D.__reduce__": (),
-    "PySide2.QtGui.QVector4D.__repr__": (),
-    "PySide2.QtGui.QVector4D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__sub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.dotProduct": ('PySide2.QtGui.QVector4D', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QVector4D.isNull": (),
-    "PySide2.QtGui.QVector4D.length": (),
-    "PySide2.QtGui.QVector4D.lengthSquared": (),
-    "PySide2.QtGui.QVector4D.normalize": (),
-    "PySide2.QtGui.QVector4D.normalized": (),
-    "PySide2.QtGui.QVector4D.setW": ('float',),
-    "PySide2.QtGui.QVector4D.setX": ('float',),
-    "PySide2.QtGui.QVector4D.setY": ('float',),
-    "PySide2.QtGui.QVector4D.setZ": ('float',),
-    "PySide2.QtGui.QVector4D.toPoint": (),
-    "PySide2.QtGui.QVector4D.toPointF": (),
-    "PySide2.QtGui.QVector4D.toTuple": (),
-    "PySide2.QtGui.QVector4D.toVector2D": (),
-    "PySide2.QtGui.QVector4D.toVector2DAffine": (),
-    "PySide2.QtGui.QVector4D.toVector3D": (),
-    "PySide2.QtGui.QVector4D.toVector3DAffine": (),
-    "PySide2.QtGui.QVector4D.w": (),
-    "PySide2.QtGui.QVector4D.x": (),
-    "PySide2.QtGui.QVector4D.y": (),
-    "PySide2.QtGui.QVector4D.z": (),
-# class PySide2.QtGui.QWhatsThisClickedEvent:
-    "PySide2.QtGui.QWhatsThisClickedEvent.__init__": ('str',),
-    "PySide2.QtGui.QWhatsThisClickedEvent.href": (),
-# class PySide2.QtGui.QWheelEvent:
-    "PySide2.QtGui.QWheelEvent.__init__": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'bool', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource', 'bool'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtGui.QWheelEvent.angleDelta": (),
-    "PySide2.QtGui.QWheelEvent.buttons": (),
-    "PySide2.QtGui.QWheelEvent.delta": (),
-    "PySide2.QtGui.QWheelEvent.globalPos": (),
-    "PySide2.QtGui.QWheelEvent.globalPosF": (),
-    "PySide2.QtGui.QWheelEvent.globalPosition": (),
-    "PySide2.QtGui.QWheelEvent.globalX": (),
-    "PySide2.QtGui.QWheelEvent.global""Y": (),
-    "PySide2.QtGui.QWheelEvent.inverted": (),
-    "PySide2.QtGui.QWheelEvent.orientation": (),
-    "PySide2.QtGui.QWheelEvent.phase": (),
-    "PySide2.QtGui.QWheelEvent.pixelDelta": (),
-    "PySide2.QtGui.QWheelEvent.pos": (),
-    "PySide2.QtGui.QWheelEvent.posF": (),
-    "PySide2.QtGui.QWheelEvent.position": (),
-    "PySide2.QtGui.QWheelEvent.source": (),
-    "PySide2.QtGui.QWheelEvent.x": (),
-    "PySide2.QtGui.QWheelEvent.y": (),
-# class PySide2.QtGui.QWindow:
-# class PySide2.QtGui.QWindow.AncestorMode:
-# class PySide2.QtGui.QWindow.Visibility:
-    "PySide2.QtGui.QWindow.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QWindow',)],
-    "PySide2.QtGui.QWindow.accessibleRoot": (),
-    "PySide2.QtGui.QWindow.alert": ('int',),
-    "PySide2.QtGui.QWindow.baseSize": (),
-    "PySide2.QtGui.QWindow.close": (),
-    "PySide2.QtGui.QWindow.contentOrientation": (),
-    "PySide2.QtGui.QWindow.create": (),
-    "PySide2.QtGui.QWindow.cursor": (),
-    "PySide2.QtGui.QWindow.destroy": (),
-    "PySide2.QtGui.QWindow.devicePixelRatio": (),
-    "PySide2.QtGui.QWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QWindow.filePath": (),
-    "PySide2.QtGui.QWindow.flags": (),
-    "PySide2.QtGui.QWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.focusObject": (),
-    "PySide2.QtGui.QWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.format": (),
-    "PySide2.QtGui.QWindow.frameGeometry": (),
-    "PySide2.QtGui.QWindow.frameMargins": (),
-    "PySide2.QtGui.QWindow.framePosition": (),
-    "PySide2.QtGui.QWindow.fromWinId": ('int',),
-    "PySide2.QtGui.QWindow.geometry": (),
-    "PySide2.QtGui.QWindow.height": (),
-    "PySide2.QtGui.QWindow.hide": (),
-    "PySide2.QtGui.QWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtGui.QWindow.icon": (),
-    "PySide2.QtGui.QWindow.isActive": (),
-    "PySide2.QtGui.QWindow.isAncestorOf": ('PySide2.QtGui.QWindow', 'PySide2.QtGui.QWindow.AncestorMode'),
-    "PySide2.QtGui.QWindow.isExposed": (),
-    "PySide2.QtGui.QWindow.isModal": (),
-    "PySide2.QtGui.QWindow.isTopLevel": (),
-    "PySide2.QtGui.QWindow.isVisible": (),
-    "PySide2.QtGui.QWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.lower": (),
-    "PySide2.QtGui.QWindow.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mask": (),
-    "PySide2.QtGui.QWindow.maximumHeight": (),
-    "PySide2.QtGui.QWindow.maximumSize": (),
-    "PySide2.QtGui.QWindow.maximumWidth": (),
-    "PySide2.QtGui.QWindow.minimumHeight": (),
-    "PySide2.QtGui.QWindow.minimumSize": (),
-    "PySide2.QtGui.QWindow.minimumWidth": (),
-    "PySide2.QtGui.QWindow.modality": (),
-    "PySide2.QtGui.QWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtGui.QWindow.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtGui.QWindow.opacity": (),
-    "PySide2.QtGui.QWindow.parent": [(), ('PySide2.QtGui.QWindow.AncestorMode',)],
-    "PySide2.QtGui.QWindow.position": (),
-    "PySide2.QtGui.QWindow.raise_": (),
-    "PySide2.QtGui.QWindow.reportContentOrientationChange": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QWindow.requestActivate": (),
-    "PySide2.QtGui.QWindow.requestUpdate": (),
-    "PySide2.QtGui.QWindow.requestedFormat": (),
-    "PySide2.QtGui.QWindow.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QWindow.screen": (),
-    "PySide2.QtGui.QWindow.setBaseSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QWindow.setFilePath": ('str',),
-    "PySide2.QtGui.QWindow.setFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtGui.QWindow.setFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtGui.QWindow.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QWindow.setFramePosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QWindow.setHeight": ('int',),
-    "PySide2.QtGui.QWindow.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QWindow.setKeyboardGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setMask": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QWindow.setMaximumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMaximumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMaximumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMinimumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtGui.QWindow.setMouseGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setOpacity": ('float',),
-    "PySide2.QtGui.QWindow.setParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setPosition": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QWindow.setSizeIncrement": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setSurfaceType": ('PySide2.QtGui.QSurface.SurfaceType',),
-    "PySide2.QtGui.QWindow.setTitle": ('str',),
-    "PySide2.QtGui.QWindow.setTransientParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setVisibility": ('PySide2.QtGui.QWindow.Visibility',),
-    "PySide2.QtGui.QWindow.setVisible": ('bool',),
-    "PySide2.QtGui.QWindow.setWidth": ('int',),
-    "PySide2.QtGui.QWindow.setWindowState": ('PySide2.QtCore.Qt.WindowState',),
-    "PySide2.QtGui.QWindow.setWindowStates": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtGui.QWindow.setX": ('int',),
-    "PySide2.QtGui.QWindow.setY": ('int',),
-    "PySide2.QtGui.QWindow.show": (),
-    "PySide2.QtGui.QWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtGui.QWindow.showFullScreen": (),
-    "PySide2.QtGui.QWindow.showMaximized": (),
-    "PySide2.QtGui.QWindow.showMinimized": (),
-    "PySide2.QtGui.QWindow.showNormal": (),
-    "PySide2.QtGui.QWindow.size": (),
-    "PySide2.QtGui.QWindow.sizeIncrement": (),
-    "PySide2.QtGui.QWindow.surfaceHandle": (),
-    "PySide2.QtGui.QWindow.surfaceType": (),
-    "PySide2.QtGui.QWindow.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtGui.QWindow.title": (),
-    "PySide2.QtGui.QWindow.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtGui.QWindow.transientParent": (),
-    "PySide2.QtGui.QWindow.type": (),
-    "PySide2.QtGui.QWindow.unsetCursor": (),
-    "PySide2.QtGui.QWindow.visibility": (),
-    "PySide2.QtGui.QWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtGui.QWindow.width": (),
-    "PySide2.QtGui.QWindow.winId": (),
-    "PySide2.QtGui.QWindow.windowState": (),
-    "PySide2.QtGui.QWindow.windowStates": (),
-    "PySide2.QtGui.QWindow.x": (),
-    "PySide2.QtGui.QWindow.y": (),
-# class PySide2.QtGui.QWindowStateChangeEvent:
-    "PySide2.QtGui.QWindowStateChangeEvent.__init__": ('PySide2.QtCore.Qt.WindowStates', 'bool'),
-    "PySide2.QtGui.QWindowStateChangeEvent.isOverride": (),
-    "PySide2.QtGui.QWindowStateChangeEvent.oldState": (),
-# class PySide2.QtGui.Qt:
-    "PySide2.QtGui.Qt.codecForHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.Qt.convertFromPlainText": ('str', 'PySide2.QtCore.Qt.WhiteSpaceMode'),
-    "PySide2.QtGui.Qt.mightBeRichText": ('str',),
-    "PySide2.QtGui.Qt.qAlpha": ('int',),
-    "PySide2.QtGui.Qt.qBlue": ('int',),
-    "PySide2.QtGui.Qt.qGray": [('int',), ('int', 'int', 'int')],
-    "PySide2.QtGui.Qt.qGreen": ('int',),
-    "PySide2.QtGui.Qt.qIsGray": ('int',),
-    "PySide2.QtGui.Qt.qRed": ('int',),
-    "PySide2.QtGui.Qt.qRgb": ('int', 'int', 'int'),
-    "PySide2.QtGui.Qt.qRgba": ('int', 'int', 'int', 'int'),
-    }) if "PySide2.QtGui" in sys.modules else None
-# Module PySide2.QtWidgets
-sig_dict.update({
-# class PySide2.QtWidgets.QAbstractButton:
-    "PySide2.QtWidgets.QAbstractButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractButton.animateClick": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.autoExclusive": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeat": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatDelay": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatInterval": (),
-    "PySide2.QtWidgets.QAbstractButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.checkStateSet": (),
-    "PySide2.QtWidgets.QAbstractButton.click": (),
-    "PySide2.QtWidgets.QAbstractButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.group": (),
-    "PySide2.QtWidgets.QAbstractButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractButton.icon": (),
-    "PySide2.QtWidgets.QAbstractButton.iconSize": (),
-    "PySide2.QtWidgets.QAbstractButton.isCheckable": (),
-    "PySide2.QtWidgets.QAbstractButton.isChecked": (),
-    "PySide2.QtWidgets.QAbstractButton.isDown": (),
-    "PySide2.QtWidgets.QAbstractButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.nextCheckState": (),
-    "PySide2.QtWidgets.QAbstractButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoExclusive": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatDelay": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatInterval": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAbstractButton.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractButton.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAbstractButton.setText": ('str',),
-    "PySide2.QtWidgets.QAbstractButton.shortcut": (),
-    "PySide2.QtWidgets.QAbstractButton.text": (),
-    "PySide2.QtWidgets.QAbstractButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractButton.toggle": (),
-# class PySide2.QtWidgets.QAbstractGraphicsShapeItem:
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.brush": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.opaqueArea": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.pen": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setPen": ('PySide2.QtGui.QPen',),
-# class PySide2.QtWidgets.QAbstractItemDelegate:
-# class PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint:
-    "PySide2.QtWidgets.QAbstractItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.destroyEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.elidedText": ('PySide2.QtGui.QFontMetrics', 'int', 'PySide2.QtCore.Qt.TextElideMode', 'str'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.helpEvent": ('PySide2.QtGui.QHelpEvent', 'PySide2.QtWidgets.QAbstractItemView', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paintingRoles": (),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QAbstractItemView:
-# class PySide2.QtWidgets.QAbstractItemView.CursorAction:
-# class PySide2.QtWidgets.QAbstractItemView.DragDropMode:
-# class PySide2.QtWidgets.QAbstractItemView.DropIndicatorPosition:
-# class PySide2.QtWidgets.QAbstractItemView.EditTrigger:
-# class PySide2.QtWidgets.QAbstractItemView.EditTriggers:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollHint:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollMode:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionBehavior:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionMode:
-# class PySide2.QtWidgets.QAbstractItemView.State:
-    "PySide2.QtWidgets.QAbstractItemView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.alternatingRowColors": (),
-    "PySide2.QtWidgets.QAbstractItemView.autoScrollMargin": (),
-    "PySide2.QtWidgets.QAbstractItemView.clearSelection": (),
-    "PySide2.QtWidgets.QAbstractItemView.closeEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint'),
-    "PySide2.QtWidgets.QAbstractItemView.closePersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.commitData": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemView.currentIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QAbstractItemView.defaultDropAction": (),
-    "PySide2.QtWidgets.QAbstractItemView.dirtyRegionOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.doAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.doItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropOverwriteMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnabled": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropIndicatorPosition": (),
-    "PySide2.QtWidgets.QAbstractItemView.edit": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.EditTrigger', 'PySide2.QtCore.QEvent')],
-    "PySide2.QtWidgets.QAbstractItemView.editTriggers": (),
-    "PySide2.QtWidgets.QAbstractItemView.editorDestroyed": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.executeDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.hasAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.iconSize": (),
-    "PySide2.QtWidgets.QAbstractItemView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractItemView.indexWidget": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractItemView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.isPersistentEditorOpen": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegate": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QAbstractItemView.model": (),
-    "PySide2.QtWidgets.QAbstractItemView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QAbstractItemView.openPersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.reset": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetHorizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetVerticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.rootIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scheduleDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollDirtyRegion": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToBottom": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToTop": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectAll": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectedIndexes": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionBehavior": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionCommand": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionModel": (),
-    "PySide2.QtWidgets.QAbstractItemView.setAlternatingRowColors": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScroll": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScrollMargin": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setCurrentIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setDefaultDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QAbstractItemView.setDirtyRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropMode": ('PySide2.QtWidgets.QAbstractItemView.DragDropMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDropIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setEditTriggers": ('PySide2.QtWidgets.QAbstractItemView.EditTriggers',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractItemView.setIndexWidget": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForColumn": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForRow": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionBehavior": ('PySide2.QtWidgets.QAbstractItemView.SelectionBehavior',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionMode": ('PySide2.QtWidgets.QAbstractItemView.SelectionMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setState": ('PySide2.QtWidgets.QAbstractItemView.State',),
-    "PySide2.QtWidgets.QAbstractItemView.setTabKeyNavigation": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setTextElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.showDropIndicator": (),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.startAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QAbstractItemView.state": (),
-    "PySide2.QtWidgets.QAbstractItemView.stopAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.tabKeyNavigation": (),
-    "PySide2.QtWidgets.QAbstractItemView.textElideMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.update": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorData": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewOptions": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractItemView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QAbstractScrollArea:
-# class PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QAbstractScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.addScrollBarWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QAbstractScrollArea.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.cornerWidget": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.maximumViewportSize": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollBarWidgets": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractScrollArea.setCornerWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setSizeAdjustPolicy": ('PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewportMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QAbstractScrollArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewport": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportMargins": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSlider:
-# class PySide2.QtWidgets.QAbstractSlider.SliderAction:
-# class PySide2.QtWidgets.QAbstractSlider.SliderChange:
-    "PySide2.QtWidgets.QAbstractSlider.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSlider.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.hasTracking": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedAppearance": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedControls": (),
-    "PySide2.QtWidgets.QAbstractSlider.isSliderDown": (),
-    "PySide2.QtWidgets.QAbstractSlider.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.maximum": (),
-    "PySide2.QtWidgets.QAbstractSlider.minimum": (),
-    "PySide2.QtWidgets.QAbstractSlider.orientation": (),
-    "PySide2.QtWidgets.QAbstractSlider.pageStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.repeatAction": (),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedControls": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setMaximum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setMinimum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QAbstractSlider.setPageStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setRepeatAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderPosition": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setValue": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.singleStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QAbstractSlider.sliderPosition": (),
-    "PySide2.QtWidgets.QAbstractSlider.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.triggerAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction',),
-    "PySide2.QtWidgets.QAbstractSlider.value": (),
-    "PySide2.QtWidgets.QAbstractSlider.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSpinBox:
-# class PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols:
-# class PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabled:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabledFlag:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepType:
-    "PySide2.QtWidgets.QAbstractSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSpinBox.alignment": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.buttonSymbols": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.clear": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.correctionMode": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasFrame": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QAbstractSpinBox.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractSpinBox.interpretText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isAccelerated": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isGroupSeparatorShown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isReadOnly": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyboardTracking": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.lineEdit": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.selectAll": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAccelerated": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setButtonSymbols": ('PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setCorrectionMode": ('PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setGroupSeparatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setKeyboardTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setSpecialValueText": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.specialValueText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepBy": ('int',),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepDown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepEnabled": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepUp": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.text": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QAbstractSpinBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.wrapping": (),
-# class PySide2.QtWidgets.QAccessibleWidget:
-    "PySide2.QtWidgets.QAccessibleWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QAccessible.Role', 'str'),
-    "PySide2.QtWidgets.QAccessibleWidget.actionNames": (),
-    "PySide2.QtWidgets.QAccessibleWidget.addControllingSignal": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.backgroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.child": ('int',),
-    "PySide2.QtWidgets.QAccessibleWidget.childCount": (),
-    "PySide2.QtWidgets.QAccessibleWidget.doAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.focusChild": (),
-    "PySide2.QtWidgets.QAccessibleWidget.foregroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtWidgets.QAccessibleWidget.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtWidgets.QAccessibleWidget.isValid": (),
-    "PySide2.QtWidgets.QAccessibleWidget.keyBindingsForAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.parent": (),
-    "PySide2.QtWidgets.QAccessibleWidget.parentObject": (),
-    "PySide2.QtWidgets.QAccessibleWidget.rect": (),
-    "PySide2.QtWidgets.QAccessibleWidget.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtWidgets.QAccessibleWidget.role": (),
-    "PySide2.QtWidgets.QAccessibleWidget.state": (),
-    "PySide2.QtWidgets.QAccessibleWidget.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtWidgets.QAccessibleWidget.widget": (),
-    "PySide2.QtWidgets.QAccessibleWidget.window": (),
-# class PySide2.QtWidgets.QAction:
-# class PySide2.QtWidgets.QAction.ActionEvent:
-# class PySide2.QtWidgets.QAction.MenuRole:
-# class PySide2.QtWidgets.QAction.Priority:
-    "PySide2.QtWidgets.QAction.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QAction.actionGroup": (),
-    "PySide2.QtWidgets.QAction.activate": ('PySide2.QtWidgets.QAction.ActionEvent',),
-    "PySide2.QtWidgets.QAction.associatedGraphicsWidgets": (),
-    "PySide2.QtWidgets.QAction.associatedWidgets": (),
-    "PySide2.QtWidgets.QAction.autoRepeat": (),
-    "PySide2.QtWidgets.QAction.data": (),
-    "PySide2.QtWidgets.QAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAction.font": (),
-    "PySide2.QtWidgets.QAction.hover": (),
-    "PySide2.QtWidgets.QAction.icon": (),
-    "PySide2.QtWidgets.QAction.iconText": (),
-    "PySide2.QtWidgets.QAction.isCheckable": (),
-    "PySide2.QtWidgets.QAction.isChecked": (),
-    "PySide2.QtWidgets.QAction.isEnabled": (),
-    "PySide2.QtWidgets.QAction.isIconVisibleInMenu": (),
-    "PySide2.QtWidgets.QAction.isSeparator": (),
-    "PySide2.QtWidgets.QAction.isShortcutVisibleInContextMenu": (),
-    "PySide2.QtWidgets.QAction.isVisible": (),
-    "PySide2.QtWidgets.QAction.menu": (),
-    "PySide2.QtWidgets.QAction.menuRole": (),
-    "PySide2.QtWidgets.QAction.parentWidget": (),
-    "PySide2.QtWidgets.QAction.priority": (),
-    "PySide2.QtWidgets.QAction.setActionGroup": ('PySide2.QtWidgets.QActionGroup',),
-    "PySide2.QtWidgets.QAction.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAction.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAction.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAction.setData": ('typing.Any',),
-    "PySide2.QtWidgets.QAction.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QAction.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAction.setIconText": ('str',),
-    "PySide2.QtWidgets.QAction.setIconVisibleInMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QAction.setMenuRole": ('PySide2.QtWidgets.QAction.MenuRole',),
-    "PySide2.QtWidgets.QAction.setPriority": ('PySide2.QtWidgets.QAction.Priority',),
-    "PySide2.QtWidgets.QAction.setSeparator": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAction.setShortcutContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QAction.setShortcutVisibleInContextMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcuts": [('PySide2.QtGui.QKeySequence.StandardKey',), ('typing.Sequence[PySide2.QtGui.QKeySequence]',)],
-    "PySide2.QtWidgets.QAction.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QAction.setText": ('str',),
-    "PySide2.QtWidgets.QAction.setToolTip": ('str',),
-    "PySide2.QtWidgets.QAction.setVisible": ('bool',),
-    "PySide2.QtWidgets.QAction.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QAction.shortcut": (),
-    "PySide2.QtWidgets.QAction.shortcutContext": (),
-    "PySide2.QtWidgets.QAction.shortcuts": (),
-    "PySide2.QtWidgets.QAction.showStatusText": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAction.statusTip": (),
-    "PySide2.QtWidgets.QAction.text": (),
-    "PySide2.QtWidgets.QAction.toggle": (),
-    "PySide2.QtWidgets.QAction.toolTip": (),
-    "PySide2.QtWidgets.QAction.trigger": (),
-    "PySide2.QtWidgets.QAction.whatsThis": (),
-# class PySide2.QtWidgets.QActionGroup:
-# class PySide2.QtWidgets.QActionGroup.ExclusionPolicy:
-    "PySide2.QtWidgets.QActionGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QActionGroup.actions": (),
-    "PySide2.QtWidgets.QActionGroup.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction',), ('str',)],
-    "PySide2.QtWidgets.QActionGroup.checkedAction": (),
-    "PySide2.QtWidgets.QActionGroup.exclusionPolicy": (),
-    "PySide2.QtWidgets.QActionGroup.isEnabled": (),
-    "PySide2.QtWidgets.QActionGroup.isExclusive": (),
-    "PySide2.QtWidgets.QActionGroup.isVisible": (),
-    "PySide2.QtWidgets.QActionGroup.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QActionGroup.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setExclusionPolicy": ('PySide2.QtWidgets.QActionGroup.ExclusionPolicy',),
-    "PySide2.QtWidgets.QActionGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setVisible": ('bool',),
-# class PySide2.QtWidgets.QApplication:
-# class PySide2.QtWidgets.QApplication.ColorSpec:
-    "PySide2.QtWidgets.QApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtWidgets.QApplication.aboutQt": (),
-    "PySide2.QtWidgets.QApplication.activeModalWidget": (),
-    "PySide2.QtWidgets.QApplication.activePopupWidget": (),
-    "PySide2.QtWidgets.QApplication.activeWindow": (),
-    "PySide2.QtWidgets.QApplication.alert": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QApplication.allWidgets": (),
-    "PySide2.QtWidgets.QApplication.autoSipEnabled": (),
-    "PySide2.QtWidgets.QApplication.beep": (),
-    "PySide2.QtWidgets.QApplication.closeAllWindows": (),
-    "PySide2.QtWidgets.QApplication.colorSpec": (),
-    "PySide2.QtWidgets.QApplication.cursorFlashTime": (),
-    "PySide2.QtWidgets.QApplication.desktop": (),
-    "PySide2.QtWidgets.QApplication.doubleClickInterval": (),
-    "PySide2.QtWidgets.QApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QApplication.exec_": (),
-    "PySide2.QtWidgets.QApplication.focusWidget": (),
-    "PySide2.QtWidgets.QApplication.font": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.fontMetrics": (),
-    "PySide2.QtWidgets.QApplication.globalStrut": (),
-    "PySide2.QtWidgets.QApplication.isEffectEnabled": ('PySide2.QtCore.Qt.UIEffect',),
-    "PySide2.QtWidgets.QApplication.keyboardInputInterval": (),
-    "PySide2.QtWidgets.QApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QApplication.palette": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setActiveWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QApplication.setAutoSipEnabled": ('bool',),
-    "PySide2.QtWidgets.QApplication.setColorSpec": ('int',),
-    "PySide2.QtWidgets.QApplication.setCursorFlashTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setDoubleClickInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setEffectEnabled": ('PySide2.QtCore.Qt.UIEffect', 'bool'),
-    "PySide2.QtWidgets.QApplication.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtWidgets.QApplication.setGlobalStrut": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QApplication.setKeyboardInputInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setPalette": [('PySide2.QtGui.QPalette',), ('PySide2.QtGui.QPalette', 'str')],
-    "PySide2.QtWidgets.QApplication.setStartDragDistance": ('int',),
-    "PySide2.QtWidgets.QApplication.setStartDragTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setStyle": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QApplication.setWheelScrollLines": ('int',),
-    "PySide2.QtWidgets.QApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QApplication.startDragDistance": (),
-    "PySide2.QtWidgets.QApplication.startDragTime": (),
-    "PySide2.QtWidgets.QApplication.style": (),
-    "PySide2.QtWidgets.QApplication.styleSheet": (),
-    "PySide2.QtWidgets.QApplication.topLevelAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.topLevelWidgets": (),
-    "PySide2.QtWidgets.QApplication.wheelScrollLines": (),
-    "PySide2.QtWidgets.QApplication.widgetAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.windowIcon": (),
-# class PySide2.QtWidgets.QBoxLayout:
-# class PySide2.QtWidgets.QBoxLayout.Direction:
-    "PySide2.QtWidgets.QBoxLayout.__init__": ('PySide2.QtWidgets.QBoxLayout.Direction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QBoxLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QBoxLayout.addLayout": ('PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.addSpacerItem": ('PySide2.QtWidgets.QSpacerItem',),
-    "PySide2.QtWidgets.QBoxLayout.addSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStrut": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QBoxLayout.count": (),
-    "PySide2.QtWidgets.QBoxLayout.direction": (),
-    "PySide2.QtWidgets.QBoxLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QBoxLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QBoxLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.insertItem": ('int', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertLayout": ('int', 'PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacerItem": ('int', 'PySide2.QtWidgets.QSpacerItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacing": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QBoxLayout.invalidate": (),
-    "PySide2.QtWidgets.QBoxLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.maximumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.minimumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.setDirection": ('PySide2.QtWidgets.QBoxLayout.Direction',),
-    "PySide2.QtWidgets.QBoxLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QBoxLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.setStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.setStretchFactor": [('PySide2.QtWidgets.QLayout', 'int'), ('PySide2.QtWidgets.QWidget', 'int')],
-    "PySide2.QtWidgets.QBoxLayout.sizeHint": (),
-    "PySide2.QtWidgets.QBoxLayout.spacing": (),
-    "PySide2.QtWidgets.QBoxLayout.stretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.takeAt": ('int',),
-# class PySide2.QtWidgets.QButtonGroup:
-    "PySide2.QtWidgets.QButtonGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QButtonGroup.addButton": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-    "PySide2.QtWidgets.QButtonGroup.button": ('int',),
-    "PySide2.QtWidgets.QButtonGroup.buttons": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedButton": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedId": (),
-    "PySide2.QtWidgets.QButtonGroup.exclusive": (),
-    "PySide2.QtWidgets.QButtonGroup.id": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QButtonGroup.setId": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-# class PySide2.QtWidgets.QCalendarWidget:
-# class PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat:
-# class PySide2.QtWidgets.QCalendarWidget.SelectionMode:
-# class PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat:
-    "PySide2.QtWidgets.QCalendarWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCalendarWidget.calendar": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateEditAcceptDelay": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateTextFormat": [(), ('PySide2.QtCore.QDate',)],
-    "PySide2.QtWidgets.QCalendarWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCalendarWidget.firstDayOfWeek": (),
-    "PySide2.QtWidgets.QCalendarWidget.headerTextFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.horizontalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.isDateEditEnabled": (),
-    "PySide2.QtWidgets.QCalendarWidget.isGridVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.isNavigationBarVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.maximumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.monthShown": (),
-    "PySide2.QtWidgets.QCalendarWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.paintCell": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.selectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.selectionMode": (),
-    "PySide2.QtWidgets.QCalendarWidget.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QCalendarWidget.setCurrentPage": ('int', 'int'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditAcceptDelay": ('int',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditEnabled": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateTextFormat": ('PySide2.QtCore.QDate', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.setFirstDayOfWeek": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.setGridVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setHeaderTextFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setHorizontalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setNavigationBarVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectedDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectionMode": ('PySide2.QtWidgets.QCalendarWidget.SelectionMode',),
-    "PySide2.QtWidgets.QCalendarWidget.setVerticalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setWeekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.showNextMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showNextYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showSelectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.showToday": (),
-    "PySide2.QtWidgets.QCalendarWidget.sizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.updateCell": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.updateCells": (),
-    "PySide2.QtWidgets.QCalendarWidget.verticalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.weekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.yearShown": (),
-# class PySide2.QtWidgets.QCheckBox:
-    "PySide2.QtWidgets.QCheckBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCheckBox.checkState": (),
-    "PySide2.QtWidgets.QCheckBox.checkStateSet": (),
-    "PySide2.QtWidgets.QCheckBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCheckBox.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QCheckBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QCheckBox.isTristate": (),
-    "PySide2.QtWidgets.QCheckBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCheckBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCheckBox.nextCheckState": (),
-    "PySide2.QtWidgets.QCheckBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCheckBox.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QCheckBox.setTristate": ('bool',),
-    "PySide2.QtWidgets.QCheckBox.sizeHint": (),
-# class PySide2.QtWidgets.QColorDialog:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOption:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOptions:
-    "PySide2.QtWidgets.QColorDialog.__init__": [('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QColorDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QColorDialog.currentColor": (),
-    "PySide2.QtWidgets.QColorDialog.customColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.customCount": (),
-    "PySide2.QtWidgets.QColorDialog.done": ('int',),
-    "PySide2.QtWidgets.QColorDialog.getColor": ('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QColorDialog.ColorDialogOptions'),
-    "PySide2.QtWidgets.QColorDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QColorDialog.options": (),
-    "PySide2.QtWidgets.QColorDialog.selectedColor": (),
-    "PySide2.QtWidgets.QColorDialog.setCurrentColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColorDialog.setCustomColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption', 'bool'),
-    "PySide2.QtWidgets.QColorDialog.setOptions": ('PySide2.QtWidgets.QColorDialog.ColorDialogOptions',),
-    "PySide2.QtWidgets.QColorDialog.setStandardColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QColorDialog.standardColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.testOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption',),
-# class PySide2.QtWidgets.QColormap:
-# class PySide2.QtWidgets.QColormap.Mode:
-    "PySide2.QtWidgets.QColormap.__init__": ('PySide2.QtWidgets.QColormap',),
-    "PySide2.QtWidgets.QColormap.__copy__": (),
-    "PySide2.QtWidgets.QColormap.cleanup": (),
-    "PySide2.QtWidgets.QColormap.colorAt": ('int',),
-    "PySide2.QtWidgets.QColormap.colormap": (),
-    "PySide2.QtWidgets.QColormap.depth": (),
-    "PySide2.QtWidgets.QColormap.initialize": (),
-    "PySide2.QtWidgets.QColormap.instance": ('int',),
-    "PySide2.QtWidgets.QColormap.mode": (),
-    "PySide2.QtWidgets.QColormap.pixel": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColormap.size": (),
-# class PySide2.QtWidgets.QColumnView:
-    "PySide2.QtWidgets.QColumnView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.columnWidths": (),
-    "PySide2.QtWidgets.QColumnView.createColumn": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QColumnView.horizontalOffset": (),
-    "PySide2.QtWidgets.QColumnView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QColumnView.initializeColumn": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QColumnView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QColumnView.previewWidget": (),
-    "PySide2.QtWidgets.QColumnView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QColumnView.resizeGripsVisible": (),
-    "PySide2.QtWidgets.QColumnView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QColumnView.selectAll": (),
-    "PySide2.QtWidgets.QColumnView.setColumnWidths": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QColumnView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QColumnView.setPreviewWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.setResizeGripsVisible": ('bool',),
-    "PySide2.QtWidgets.QColumnView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QColumnView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QColumnView.sizeHint": (),
-    "PySide2.QtWidgets.QColumnView.verticalOffset": (),
-    "PySide2.QtWidgets.QColumnView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QComboBox:
-# class PySide2.QtWidgets.QComboBox.InsertPolicy:
-# class PySide2.QtWidgets.QComboBox.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QComboBox.addItem": [('PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QComboBox.autoCompletion": (),
-    "PySide2.QtWidgets.QComboBox.autoCompletionCaseSensitivity": (),
-    "PySide2.QtWidgets.QComboBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.clear": (),
-    "PySide2.QtWidgets.QComboBox.clearEditText": (),
-    "PySide2.QtWidgets.QComboBox.completer": (),
-    "PySide2.QtWidgets.QComboBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QComboBox.count": (),
-    "PySide2.QtWidgets.QComboBox.currentData": ('int',),
-    "PySide2.QtWidgets.QComboBox.currentIndex": (),
-    "PySide2.QtWidgets.QComboBox.currentText": (),
-    "PySide2.QtWidgets.QComboBox.duplicatesEnabled": (),
-    "PySide2.QtWidgets.QComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.findData": ('typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.findText": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.hasFrame": (),
-    "PySide2.QtWidgets.QComboBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QComboBox.hidePopup": (),
-    "PySide2.QtWidgets.QComboBox.iconSize": (),
-    "PySide2.QtWidgets.QComboBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionComboBox',),
-    "PySide2.QtWidgets.QComboBox.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QComboBox.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItem": [('int', 'PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('int', 'str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QComboBox.insertPolicy": (),
-    "PySide2.QtWidgets.QComboBox.insertSeparator": ('int',),
-    "PySide2.QtWidgets.QComboBox.isEditable": (),
-    "PySide2.QtWidgets.QComboBox.itemData": ('int', 'int'),
-    "PySide2.QtWidgets.QComboBox.itemDelegate": (),
-    "PySide2.QtWidgets.QComboBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QComboBox.itemText": ('int',),
-    "PySide2.QtWidgets.QComboBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.lineEdit": (),
-    "PySide2.QtWidgets.QComboBox.maxCount": (),
-    "PySide2.QtWidgets.QComboBox.maxVisibleItems": (),
-    "PySide2.QtWidgets.QComboBox.minimumContentsLength": (),
-    "PySide2.QtWidgets.QComboBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QComboBox.model": (),
-    "PySide2.QtWidgets.QComboBox.modelColumn": (),
-    "PySide2.QtWidgets.QComboBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QComboBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QComboBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QComboBox.rootModelIndex": (),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletion": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletionCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QComboBox.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QComboBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QComboBox.setCurrentText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setDuplicatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setEditText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setEditable": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QComboBox.setInsertPolicy": ('PySide2.QtWidgets.QComboBox.InsertPolicy',),
-    "PySide2.QtWidgets.QComboBox.setItemData": ('int', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QComboBox.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QComboBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QComboBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QComboBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QComboBox.setMaxCount": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMinimumContentsLength": ('int',),
-    "PySide2.QtWidgets.QComboBox.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QComboBox.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QComboBox.setRootModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QComboBox.setSizeAdjustPolicy": ('PySide2.QtWidgets.QComboBox.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QComboBox.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QComboBox.setView": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QComboBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QComboBox.showPopup": (),
-    "PySide2.QtWidgets.QComboBox.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QComboBox.validator": (),
-    "PySide2.QtWidgets.QComboBox.view": (),
-    "PySide2.QtWidgets.QComboBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QCommandLinkButton:
-    "PySide2.QtWidgets.QCommandLinkButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget'), ('str', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCommandLinkButton.description": (),
-    "PySide2.QtWidgets.QCommandLinkButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QCommandLinkButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCommandLinkButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.setDescription": ('str',),
-    "PySide2.QtWidgets.QCommandLinkButton.sizeHint": (),
-# class PySide2.QtWidgets.QCommonStyle:
-    "PySide2.QtWidgets.QCommonStyle.__init__": (),
-    "PySide2.QtWidgets.QCommonStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QCommonStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QCommonStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QCommonStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QCompleter:
-# class PySide2.QtWidgets.QCompleter.CompletionMode:
-# class PySide2.QtWidgets.QCompleter.ModelSorting:
-    "PySide2.QtWidgets.QCompleter.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QCompleter.caseSensitivity": (),
-    "PySide2.QtWidgets.QCompleter.complete": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QCompleter.completionColumn": (),
-    "PySide2.QtWidgets.QCompleter.completionCount": (),
-    "PySide2.QtWidgets.QCompleter.completionMode": (),
-    "PySide2.QtWidgets.QCompleter.completionModel": (),
-    "PySide2.QtWidgets.QCompleter.completionPrefix": (),
-    "PySide2.QtWidgets.QCompleter.completionRole": (),
-    "PySide2.QtWidgets.QCompleter.currentCompletion": (),
-    "PySide2.QtWidgets.QCompleter.currentIndex": (),
-    "PySide2.QtWidgets.QCompleter.currentRow": (),
-    "PySide2.QtWidgets.QCompleter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCompleter.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCompleter.filterMode": (),
-    "PySide2.QtWidgets.QCompleter.maxVisibleItems": (),
-    "PySide2.QtWidgets.QCompleter.model": (),
-    "PySide2.QtWidgets.QCompleter.modelSorting": (),
-    "PySide2.QtWidgets.QCompleter.pathFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QCompleter.popup": (),
-    "PySide2.QtWidgets.QCompleter.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QCompleter.setCompletionColumn": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCompletionMode": ('PySide2.QtWidgets.QCompleter.CompletionMode',),
-    "PySide2.QtWidgets.QCompleter.setCompletionPrefix": ('str',),
-    "PySide2.QtWidgets.QCompleter.setCompletionRole": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCurrentRow": ('int',),
-    "PySide2.QtWidgets.QCompleter.setFilterMode": ('PySide2.QtCore.Qt.MatchFlags',),
-    "PySide2.QtWidgets.QCompleter.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QCompleter.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QCompleter.setModelSorting": ('PySide2.QtWidgets.QCompleter.ModelSorting',),
-    "PySide2.QtWidgets.QCompleter.setPopup": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QCompleter.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCompleter.setWrapAround": ('bool',),
-    "PySide2.QtWidgets.QCompleter.splitPath": ('str',),
-    "PySide2.QtWidgets.QCompleter.widget": (),
-    "PySide2.QtWidgets.QCompleter.wrapAround": (),
-# class PySide2.QtWidgets.QDataWidgetMapper:
-# class PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy:
-    "PySide2.QtWidgets.QDataWidgetMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QDataWidgetMapper.addMapping": [('PySide2.QtWidgets.QWidget', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtWidgets.QDataWidgetMapper.clearMapping": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.currentIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.itemDelegate": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedPropertyName": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedSection": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedWidgetAt": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.model": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.orientation": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.removeMapping": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.revert": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.rootIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setSubmitPolicy": ('PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy',),
-    "PySide2.QtWidgets.QDataWidgetMapper.submit": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.submitPolicy": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toFirst": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toLast": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toNext": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toPrevious": (),
-# class PySide2.QtWidgets.QDateEdit:
-    "PySide2.QtWidgets.QDateEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDateTimeEdit:
-# class PySide2.QtWidgets.QDateTimeEdit.Section:
-# class PySide2.QtWidgets.QDateTimeEdit.Sections:
-    "PySide2.QtWidgets.QDateTimeEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QDateTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('typing.Any', 'type', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QDateTimeEdit.calendar": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarPopup": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarWidget": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clear": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSection": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSectionIndex": (),
-    "PySide2.QtWidgets.QDateTimeEdit.date": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTimeFromText": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.displayFormat": (),
-    "PySide2.QtWidgets.QDateTimeEdit.displayedSections": (),
-    "PySide2.QtWidgets.QDateTimeEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.fixup": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QDateTimeEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionAt": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionCount": (),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionText": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarPopup": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarWidget": ('PySide2.QtWidgets.QCalendarWidget',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSectionIndex": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTimeRange": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDisplayFormat": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setSelectedSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeRange": ('PySide2.QtCore.QTime', 'PySide2.QtCore.QTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtWidgets.QDateTimeEdit.sizeHint": (),
-    "PySide2.QtWidgets.QDateTimeEdit.stepBy": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.stepEnabled": (),
-    "PySide2.QtWidgets.QDateTimeEdit.textFromDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.time": (),
-    "PySide2.QtWidgets.QDateTimeEdit.timeSpec": (),
-    "PySide2.QtWidgets.QDateTimeEdit.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDateTimeEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QDesktopWidget:
-    "PySide2.QtWidgets.QDesktopWidget.__init__": (),
-    "PySide2.QtWidgets.QDesktopWidget.availableGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.isVirtualDesktop": (),
-    "PySide2.QtWidgets.QDesktopWidget.numScreens": (),
-    "PySide2.QtWidgets.QDesktopWidget.primaryScreen": (),
-    "PySide2.QtWidgets.QDesktopWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDesktopWidget.screen": [(), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenCount": (),
-    "PySide2.QtWidgets.QDesktopWidget.screenGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenNumber": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDial:
-    "PySide2.QtWidgets.QDial.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDial.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDial.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QDial.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDial.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.notchSize": (),
-    "PySide2.QtWidgets.QDial.notchTarget": (),
-    "PySide2.QtWidgets.QDial.notchesVisible": (),
-    "PySide2.QtWidgets.QDial.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDial.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDial.setNotchTarget": ('float',),
-    "PySide2.QtWidgets.QDial.setNotchesVisible": ('bool',),
-    "PySide2.QtWidgets.QDial.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QDial.sizeHint": (),
-    "PySide2.QtWidgets.QDial.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QDial.wrapping": (),
-# class PySide2.QtWidgets.QDialog:
-# class PySide2.QtWidgets.QDialog.DialogCode:
-    "PySide2.QtWidgets.QDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QDialog.accept": (),
-    "PySide2.QtWidgets.QDialog.adjustPosition": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDialog.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QDialog.done": ('int',),
-    "PySide2.QtWidgets.QDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QDialog.exec_": (),
-    "PySide2.QtWidgets.QDialog.extension": (),
-    "PySide2.QtWidgets.QDialog.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QDialog.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDialog.open": (),
-    "PySide2.QtWidgets.QDialog.orientation": (),
-    "PySide2.QtWidgets.QDialog.reject": (),
-    "PySide2.QtWidgets.QDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDialog.result": (),
-    "PySide2.QtWidgets.QDialog.setExtension": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.setModal": ('bool',),
-    "PySide2.QtWidgets.QDialog.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialog.setResult": ('int',),
-    "PySide2.QtWidgets.QDialog.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QDialog.showExtension": ('bool',),
-    "PySide2.QtWidgets.QDialog.sizeHint": (),
-# class PySide2.QtWidgets.QDialogButtonBox:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonLayout:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonRole:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButton:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButtons:
-    "PySide2.QtWidgets.QDialogButtonBox.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QDialogButtonBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',), ('str', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole')],
-    "PySide2.QtWidgets.QDialogButtonBox.button": ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.centerButtons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.clear": (),
-    "PySide2.QtWidgets.QDialogButtonBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.orientation": (),
-    "PySide2.QtWidgets.QDialogButtonBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.setCenterButtons": ('bool',),
-    "PySide2.QtWidgets.QDialogButtonBox.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialogButtonBox.setStandardButtons": ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButtons": (),
-# class PySide2.QtWidgets.QDirModel:
-# class PySide2.QtWidgets.QDirModel.Roles:
-    "PySide2.QtWidgets.QDirModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QDirModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QDirModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QDirModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filter": (),
-    "PySide2.QtWidgets.QDirModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QDirModel.iconProvider": (),
-    "PySide2.QtWidgets.QDirModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QDirModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.isReadOnly": (),
-    "PySide2.QtWidgets.QDirModel.lazyChildCount": (),
-    "PySide2.QtWidgets.QDirModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QDirModel.mimeTypes": (),
-    "PySide2.QtWidgets.QDirModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QDirModel.nameFilters": (),
-    "PySide2.QtWidgets.QDirModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QDirModel.refresh": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QDirModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QDirModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QDirModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QDirModel.setLazyChildCount": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QDirModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtWidgets.QDirModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QDirModel.sorting": (),
-    "PySide2.QtWidgets.QDirModel.supportedDropActions": (),
-# class PySide2.QtWidgets.QDockWidget:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeature:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeatures:
-    "PySide2.QtWidgets.QDockWidget.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QDockWidget.allowedAreas": (),
-    "PySide2.QtWidgets.QDockWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDockWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.features": (),
-    "PySide2.QtWidgets.QDockWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionDockWidget',),
-    "PySide2.QtWidgets.QDockWidget.isAreaAllowed": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QDockWidget.isFloating": (),
-    "PySide2.QtWidgets.QDockWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDockWidget.setAllowedAreas": ('PySide2.QtCore.Qt.DockWidgetAreas',),
-    "PySide2.QtWidgets.QDockWidget.setFeatures": ('PySide2.QtWidgets.QDockWidget.DockWidgetFeatures',),
-    "PySide2.QtWidgets.QDockWidget.setFloating": ('bool',),
-    "PySide2.QtWidgets.QDockWidget.setTitleBarWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.titleBarWidget": (),
-    "PySide2.QtWidgets.QDockWidget.toggleViewAction": (),
-    "PySide2.QtWidgets.QDockWidget.widget": (),
-# class PySide2.QtWidgets.QDoubleSpinBox:
-    "PySide2.QtWidgets.QDoubleSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDoubleSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.decimals": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.maximum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.minimum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.prefix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.setDecimals": ('int',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMaximum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMinimum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setRange": ('float', 'float'),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSingleStep": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.stepType": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.suffix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.textFromValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDoubleSpinBox.value": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QErrorMessage:
-    "PySide2.QtWidgets.QErrorMessage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QErrorMessage.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QErrorMessage.done": ('int',),
-    "PySide2.QtWidgets.QErrorMessage.qtHandler": (),
-    "PySide2.QtWidgets.QErrorMessage.showMessage": [('str',), ('str', 'str')],
-# class PySide2.QtWidgets.QFileDialog:
-# class PySide2.QtWidgets.QFileDialog.AcceptMode:
-# class PySide2.QtWidgets.QFileDialog.DialogLabel:
-# class PySide2.QtWidgets.QFileDialog.FileMode:
-# class PySide2.QtWidgets.QFileDialog.Option:
-# class PySide2.QtWidgets.QFileDialog.Options:
-# class PySide2.QtWidgets.QFileDialog.ViewMode:
-    "PySide2.QtWidgets.QFileDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str')],
-    "PySide2.QtWidgets.QFileDialog.accept": (),
-    "PySide2.QtWidgets.QFileDialog.acceptMode": (),
-    "PySide2.QtWidgets.QFileDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileDialog.confirmOverwrite": (),
-    "PySide2.QtWidgets.QFileDialog.defaultSuffix": (),
-    "PySide2.QtWidgets.QFileDialog.directory": (),
-    "PySide2.QtWidgets.QFileDialog.directoryUrl": (),
-    "PySide2.QtWidgets.QFileDialog.done": ('int',),
-    "PySide2.QtWidgets.QFileDialog.fileMode": (),
-    "PySide2.QtWidgets.QFileDialog.filter": (),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectory": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectoryUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileNames": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrls": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.history": (),
-    "PySide2.QtWidgets.QFileDialog.iconProvider": (),
-    "PySide2.QtWidgets.QFileDialog.isNameFilterDetailsVisible": (),
-    "PySide2.QtWidgets.QFileDialog.isReadOnly": (),
-    "PySide2.QtWidgets.QFileDialog.itemDelegate": (),
-    "PySide2.QtWidgets.QFileDialog.labelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel',),
-    "PySide2.QtWidgets.QFileDialog.mimeTypeFilters": (),
-    "PySide2.QtWidgets.QFileDialog.nameFilters": (),
-    "PySide2.QtWidgets.QFileDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFileDialog.options": (),
-    "PySide2.QtWidgets.QFileDialog.proxyModel": (),
-    "PySide2.QtWidgets.QFileDialog.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileDialog.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QFileDialog.saveFileContent": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtWidgets.QFileDialog.saveState": (),
-    "PySide2.QtWidgets.QFileDialog.selectFile": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectMimeTypeFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.selectedFiles": (),
-    "PySide2.QtWidgets.QFileDialog.selectedMimeTypeFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedNameFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedUrls": (),
-    "PySide2.QtWidgets.QFileDialog.setAcceptMode": ('PySide2.QtWidgets.QFileDialog.AcceptMode',),
-    "PySide2.QtWidgets.QFileDialog.setConfirmOverwrite": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setDefaultSuffix": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setDirectory": [('PySide2.QtCore.QDir',), ('str',)],
-    "PySide2.QtWidgets.QFileDialog.setDirectoryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.setFileMode": ('PySide2.QtWidgets.QFileDialog.FileMode',),
-    "PySide2.QtWidgets.QFileDialog.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileDialog.setHistory": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileDialog.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QFileDialog.setLabelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel', 'str'),
-    "PySide2.QtWidgets.QFileDialog.setMimeTypeFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilterDetailsVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setOption": ('PySide2.QtWidgets.QFileDialog.Option', 'bool'),
-    "PySide2.QtWidgets.QFileDialog.setOptions": ('PySide2.QtWidgets.QFileDialog.Options',),
-    "PySide2.QtWidgets.QFileDialog.setProxyModel": ('PySide2.QtCore.QAbstractProxyModel',),
-    "PySide2.QtWidgets.QFileDialog.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setSidebarUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWidgets.QFileDialog.setSupportedSchemes": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setViewMode": ('PySide2.QtWidgets.QFileDialog.ViewMode',),
-    "PySide2.QtWidgets.QFileDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.sidebarUrls": (),
-    "PySide2.QtWidgets.QFileDialog.supportedSchemes": (),
-    "PySide2.QtWidgets.QFileDialog.testOption": ('PySide2.QtWidgets.QFileDialog.Option',),
-    "PySide2.QtWidgets.QFileDialog.viewMode": (),
-# class PySide2.QtWidgets.QFileIconProvider:
-# class PySide2.QtWidgets.QFileIconProvider.IconType:
-# class PySide2.QtWidgets.QFileIconProvider.Option:
-# class PySide2.QtWidgets.QFileIconProvider.Options:
-    "PySide2.QtWidgets.QFileIconProvider.__init__": (),
-    "PySide2.QtWidgets.QFileIconProvider.icon": [('PySide2.QtCore.QFileInfo',), ('PySide2.QtWidgets.QFileIconProvider.IconType',)],
-    "PySide2.QtWidgets.QFileIconProvider.options": (),
-    "PySide2.QtWidgets.QFileIconProvider.setOptions": ('PySide2.QtWidgets.QFileIconProvider.Options',),
-    "PySide2.QtWidgets.QFileIconProvider.type": ('PySide2.QtCore.QFileInfo',),
-# class PySide2.QtWidgets.QFileSystemModel:
-# class PySide2.QtWidgets.QFileSystemModel.Option:
-# class PySide2.QtWidgets.QFileSystemModel.Options:
-# class PySide2.QtWidgets.QFileSystemModel.Roles:
-    "PySide2.QtWidgets.QFileSystemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QFileSystemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filter": (),
-    "PySide2.QtWidgets.QFileSystemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.iconProvider": (),
-    "PySide2.QtWidgets.QFileSystemModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QFileSystemModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.isReadOnly": (),
-    "PySide2.QtWidgets.QFileSystemModel.lastModified": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeTypes": (),
-    "PySide2.QtWidgets.QFileSystemModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QFileSystemModel.myComputer": ('int',),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilterDisables": (),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilters": (),
-    "PySide2.QtWidgets.QFileSystemModel.options": (),
-    "PySide2.QtWidgets.QFileSystemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QFileSystemModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileSystemModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.rootDirectory": (),
-    "PySide2.QtWidgets.QFileSystemModel.rootPath": (),
-    "PySide2.QtWidgets.QFileSystemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileSystemModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilterDisables": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileSystemModel.setOption": ('PySide2.QtWidgets.QFileSystemModel.Option', 'bool'),
-    "PySide2.QtWidgets.QFileSystemModel.setOptions": ('PySide2.QtWidgets.QFileSystemModel.Options',),
-    "PySide2.QtWidgets.QFileSystemModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setRootPath": ('str',),
-    "PySide2.QtWidgets.QFileSystemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.size": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QFileSystemModel.supportedDropActions": (),
-    "PySide2.QtWidgets.QFileSystemModel.testOption": ('PySide2.QtWidgets.QFileSystemModel.Option',),
-    "PySide2.QtWidgets.QFileSystemModel.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.type": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtWidgets.QFocusFrame:
-    "PySide2.QtWidgets.QFocusFrame.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFocusFrame.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFocusFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QFocusFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFocusFrame.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.widget": (),
-# class PySide2.QtWidgets.QFontComboBox:
-# class PySide2.QtWidgets.QFontComboBox.FontFilter:
-# class PySide2.QtWidgets.QFontComboBox.FontFilters:
-    "PySide2.QtWidgets.QFontComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFontComboBox.currentFont": (),
-    "PySide2.QtWidgets.QFontComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontComboBox.fontFilters": (),
-    "PySide2.QtWidgets.QFontComboBox.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontComboBox.setFontFilters": ('PySide2.QtWidgets.QFontComboBox.FontFilters',),
-    "PySide2.QtWidgets.QFontComboBox.setWritingSystem": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtWidgets.QFontComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QFontComboBox.writingSystem": (),
-# class PySide2.QtWidgets.QFontDialog:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOption:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOptions:
-    "PySide2.QtWidgets.QFontDialog.__init__": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontDialog.currentFont": (),
-    "PySide2.QtWidgets.QFontDialog.done": ('int',),
-    "PySide2.QtWidgets.QFontDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFontDialog.getFont": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QFontDialog.FontDialogOptions'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFontDialog.options": (),
-    "PySide2.QtWidgets.QFontDialog.selectedFont": (),
-    "PySide2.QtWidgets.QFontDialog.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontDialog.setOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption', 'bool'),
-    "PySide2.QtWidgets.QFontDialog.setOptions": ('PySide2.QtWidgets.QFontDialog.FontDialogOptions',),
-    "PySide2.QtWidgets.QFontDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFontDialog.testOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption',),
-# class PySide2.QtWidgets.QFormLayout:
-# class PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy:
-# class PySide2.QtWidgets.QFormLayout.ItemRole:
-# class PySide2.QtWidgets.QFormLayout.RowWrapPolicy:
-    "PySide2.QtWidgets.QFormLayout.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFormLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QFormLayout.addRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QLayout'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.count": (),
-    "PySide2.QtWidgets.QFormLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QFormLayout.fieldGrowthPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.formAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.getItemPosition": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getLayoutPosition": ('PySide2.QtWidgets.QLayout', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getWidgetPosition": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QFormLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QFormLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QFormLayout.insertRow": [('int', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('int', 'str', 'PySide2.QtWidgets.QLayout'), ('int', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.invalidate": (),
-    "PySide2.QtWidgets.QFormLayout.itemAt": [('int',), ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole')],
-    "PySide2.QtWidgets.QFormLayout.labelAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.labelForField": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFormLayout.minimumSize": (),
-    "PySide2.QtWidgets.QFormLayout.removeRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QFormLayout.rowCount": (),
-    "PySide2.QtWidgets.QFormLayout.rowWrapPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.setFieldGrowthPolicy": ('PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setFormAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFormLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setItem": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QFormLayout.setLabelAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setLayout": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayout'),
-    "PySide2.QtWidgets.QFormLayout.setRowWrapPolicy": ('PySide2.QtWidgets.QFormLayout.RowWrapPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setWidget": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QFormLayout.sizeHint": (),
-    "PySide2.QtWidgets.QFormLayout.spacing": (),
-    "PySide2.QtWidgets.QFormLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QFormLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QFrame:
-# class PySide2.QtWidgets.QFrame.Shadow:
-# class PySide2.QtWidgets.QFrame.Shape:
-# class PySide2.QtWidgets.QFrame.StyleMask:
-    "PySide2.QtWidgets.QFrame.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QFrame.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.drawFrame": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.frameRect": (),
-    "PySide2.QtWidgets.QFrame.frameShadow": (),
-    "PySide2.QtWidgets.QFrame.frameShape": (),
-    "PySide2.QtWidgets.QFrame.frameStyle": (),
-    "PySide2.QtWidgets.QFrame.frameWidth": (),
-    "PySide2.QtWidgets.QFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QFrame.lineWidth": (),
-    "PySide2.QtWidgets.QFrame.midLineWidth": (),
-    "PySide2.QtWidgets.QFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFrame.setFrameRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFrame.setFrameShadow": ('PySide2.QtWidgets.QFrame.Shadow',),
-    "PySide2.QtWidgets.QFrame.setFrameShape": ('PySide2.QtWidgets.QFrame.Shape',),
-    "PySide2.QtWidgets.QFrame.setFrameStyle": ('int',),
-    "PySide2.QtWidgets.QFrame.setLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.setMidLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.sizeHint": (),
-# class PySide2.QtWidgets.QGesture:
-# class PySide2.QtWidgets.QGesture.GestureCancelPolicy:
-    "PySide2.QtWidgets.QGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGesture.gestureCancelPolicy": (),
-    "PySide2.QtWidgets.QGesture.gestureType": (),
-    "PySide2.QtWidgets.QGesture.hasHotSpot": (),
-    "PySide2.QtWidgets.QGesture.hotSpot": (),
-    "PySide2.QtWidgets.QGesture.setGestureCancelPolicy": ('PySide2.QtWidgets.QGesture.GestureCancelPolicy',),
-    "PySide2.QtWidgets.QGesture.setHotSpot": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGesture.state": (),
-    "PySide2.QtWidgets.QGesture.unsetHotSpot": (),
-# class PySide2.QtWidgets.QGestureEvent:
-    "PySide2.QtWidgets.QGestureEvent.__init__": ('typing.Sequence[PySide2.QtWidgets.QGesture]',),
-    "PySide2.QtWidgets.QGestureEvent.accept": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.activeGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.canceledGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.gesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGestureEvent.gestures": (),
-    "PySide2.QtWidgets.QGestureEvent.ignore": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.isAccepted": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.mapToGraphicsScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGestureEvent.setAccepted": [('PySide2.QtCore.Qt.GestureType', 'bool'), ('PySide2.QtWidgets.QGesture', 'bool'), ('bool',)],
-    "PySide2.QtWidgets.QGestureEvent.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGestureEvent.widget": (),
-# class PySide2.QtWidgets.QGestureRecognizer:
-# class PySide2.QtWidgets.QGestureRecognizer.Result:
-# class PySide2.QtWidgets.QGestureRecognizer.ResultFlag:
-    "PySide2.QtWidgets.QGestureRecognizer.__init__": (),
-    "PySide2.QtWidgets.QGestureRecognizer.create": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGestureRecognizer.recognize": ('PySide2.QtWidgets.QGesture', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGestureRecognizer.registerRecognizer": ('PySide2.QtWidgets.QGestureRecognizer',),
-    "PySide2.QtWidgets.QGestureRecognizer.reset": ('PySide2.QtWidgets.QGesture',),
-    "PySide2.QtWidgets.QGestureRecognizer.unregisterRecognizer": ('PySide2.QtCore.Qt.GestureType',),
-# class PySide2.QtWidgets.QGraphicsAnchor:
-    "PySide2.QtWidgets.QGraphicsAnchor.setSizePolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QGraphicsAnchor.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchor.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.spacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.unsetSpacing": (),
-# class PySide2.QtWidgets.QGraphicsAnchorLayout:
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Orientations'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addCornerAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.anchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsBlurEffect:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHint:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints:
-    "PySide2.QtWidgets.QGraphicsBlurEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurHints": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurHints": ('PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurRadius": ('float',),
-# class PySide2.QtWidgets.QGraphicsColorizeEffect:
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setStrength": ('float',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.strength": (),
-# class PySide2.QtWidgets.QGraphicsDropShadowEffect:
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.offset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setBlurRadius": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setOffset": [('PySide2.QtCore.QPointF',), ('float',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setXOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setYOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.xOffset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.yOffset": (),
-# class PySide2.QtWidgets.QGraphicsEffect:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlag:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlags:
-# class PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode:
-    "PySide2.QtWidgets.QGraphicsEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.drawSource": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsEffect.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceBoundingRect": ('PySide2.QtCore.Qt.CoordinateSystem',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceChanged": ('PySide2.QtWidgets.QGraphicsEffect.ChangeFlags',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceIsPixmap": (),
-    "PySide2.QtWidgets.QGraphicsEffect.sourcePixmap": ('PySide2.QtCore.Qt.CoordinateSystem', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode'),
-    "PySide2.QtWidgets.QGraphicsEffect.update": (),
-    "PySide2.QtWidgets.QGraphicsEffect.updateBoundingRect": (),
-# class PySide2.QtWidgets.QGraphicsEllipseItem:
-    "PySide2.QtWidgets.QGraphicsEllipseItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setSpanAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setStartAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.spanAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.startAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.type": (),
-# class PySide2.QtWidgets.QGraphicsGridLayout:
-    "PySide2.QtWidgets.QGraphicsGridLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.addItem": [('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnPreferredWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.itemAt": [('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowPreferredHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnFixedWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMaximumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMinimumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnPreferredWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowFixedHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMaximumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMinimumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowPreferredHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsItem:
-# class PySide2.QtWidgets.QGraphicsItem.CacheMode:
-# class PySide2.QtWidgets.QGraphicsItem.Extension:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags:
-# class PySide2.QtWidgets.QGraphicsItem.PanelModality:
-    "PySide2.QtWidgets.QGraphicsItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.acceptDrops": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptHoverEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptTouchEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptedMouseButtons": (),
-    "PySide2.QtWidgets.QGraphicsItem.addToIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.advance": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegion": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegionGranularity": (),
-    "PySide2.QtWidgets.QGraphicsItem.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsItem.childItems": (),
-    "PySide2.QtWidgets.QGraphicsItem.childrenBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.clipPath": (),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidingItems": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsItem.commonAncestorItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.cursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.data": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.deviceTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.effectiveOpacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsItem.filtersChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.flags": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusProxy": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusScopeItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.graphicsEffect": (),
-    "PySide2.QtWidgets.QGraphicsItem.group": (),
-    "PySide2.QtWidgets.QGraphicsItem.handlesChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.hide": (),
-    "PySide2.QtWidgets.QGraphicsItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodHints": (),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsItem.installSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isActive": (),
-    "PySide2.QtWidgets.QGraphicsItem.isAncestorOf": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isBlockedByModalPanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isClipped": (),
-    "PySide2.QtWidgets.QGraphicsItem.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsItem.isObscured": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isPanel": (),
-    "PySide2.QtWidgets.QGraphicsItem.isSelected": (),
-    "PySide2.QtWidgets.QGraphicsItem.isUnderMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisible": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisibleTo": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.isWindow": (),
-    "PySide2.QtWidgets.QGraphicsItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.itemTransform": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mapFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.matrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.moveBy": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItem.opacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItem.panel": (),
-    "PySide2.QtWidgets.QGraphicsItem.panelModality": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.pos": (),
-    "PySide2.QtWidgets.QGraphicsItem.prepareGeometryChange": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeFromIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.rotation": (),
-    "PySide2.QtWidgets.QGraphicsItem.scale": (),
-    "PySide2.QtWidgets.QGraphicsItem.scene": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsItem.sceneMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.scroll": ('float', 'float', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsItem.setActive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setBoundingRegionGranularity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setCacheMode": ('PySide2.QtWidgets.QGraphicsItem.CacheMode', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QGraphicsItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QGraphicsItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFiltersChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFlag": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setFlags": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocusProxy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QGraphicsItem.setGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsItem.setHandlesChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QGraphicsItem.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setPanelModality": ('PySide2.QtWidgets.QGraphicsItem.PanelModality',),
-    "PySide2.QtWidgets.QGraphicsItem.setParentItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setPos": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setRotation": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QGraphicsItem.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setTransformOriginPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setTransformations": ('typing.Sequence[PySide2.QtWidgets.QGraphicsTransform]',),
-    "PySide2.QtWidgets.QGraphicsItem.setVisible": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setX": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setY": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setZValue": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsItem.show": (),
-    "PySide2.QtWidgets.QGraphicsItem.stackBefore": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.toGraphicsObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.toolTip": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.transform": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformOriginPoint": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformations": (),
-    "PySide2.QtWidgets.QGraphicsItem.type": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.unsetCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.updateMicroFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.window": (),
-    "PySide2.QtWidgets.QGraphicsItem.x": (),
-    "PySide2.QtWidgets.QGraphicsItem.y": (),
-    "PySide2.QtWidgets.QGraphicsItem.zValue": (),
-# class PySide2.QtWidgets.QGraphicsItemAnimation:
-    "PySide2.QtWidgets.QGraphicsItemAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.afterAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.beforeAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.clear": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.item": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.matrixAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.reset": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.scaleList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setPosAt": ('float', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setRotationAt": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setScaleAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setShearAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTimeLine": ('PySide2.QtCore.QTimeLine',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTranslationAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.shearList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.timeLine": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.transformAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.translationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.xTranslationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.yTranslationAt": ('float',),
-# class PySide2.QtWidgets.QGraphicsItemGroup:
-    "PySide2.QtWidgets.QGraphicsItemGroup.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.addToGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItemGroup.removeFromGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.type": (),
-# class PySide2.QtWidgets.QGraphicsLayout:
-    "PySide2.QtWidgets.QGraphicsLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.activate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.addChildLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayout.instantInvalidatePropagation": (),
-    "PySide2.QtWidgets.QGraphicsLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.isActivated": (),
-    "PySide2.QtWidgets.QGraphicsLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.setContentsMargins": ('float', 'float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsLayout.setInstantInvalidatePropagation": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayout.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QGraphicsLayoutItem:
-    "PySide2.QtWidgets.QGraphicsLayoutItem.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'bool'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.contentsRect": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.effectiveSizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.graphicsItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.isLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.ownedByLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.parentLayoutItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGraphicsItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setOwnedByLayout": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setParentLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.updateGeometry": (),
-# class PySide2.QtWidgets.QGraphicsLineItem:
-    "PySide2.QtWidgets.QGraphicsLineItem.__init__": [('PySide2.QtCore.QLineF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsLineItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsLineItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsLineItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLineItem.line": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsLineItem.pen": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.setLine": [('PySide2.QtCore.QLineF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLineItem.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtWidgets.QGraphicsLineItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.type": (),
-# class PySide2.QtWidgets.QGraphicsLinearLayout:
-    "PySide2.QtWidgets.QGraphicsLinearLayout.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QGraphicsLayoutItem'), ('PySide2.QtWidgets.QGraphicsLayoutItem',)],
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.dump": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertItem": ('int', 'PySide2.QtWidgets.QGraphicsLayoutItem'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.orientation": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setItemSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setStretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.spacing": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.stretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-# class PySide2.QtWidgets.QGraphicsObject:
-    "PySide2.QtWidgets.QGraphicsObject.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsObject.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QGraphicsObject.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGraphicsObject.updateMicroFocus": (),
-# class PySide2.QtWidgets.QGraphicsOpacityEffect:
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacity": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacityMask": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacityMask": ('PySide2.QtGui.QBrush',),
-# class PySide2.QtWidgets.QGraphicsPathItem:
-    "PySide2.QtWidgets.QGraphicsPathItem.__init__": [('PySide2.QtGui.QPainterPath', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPathItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPathItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPathItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPathItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPathItem.path": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.setPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QGraphicsPathItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPixmapItem:
-# class PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode:
-    "PySide2.QtWidgets.QGraphicsPixmapItem.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.offset": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.pixmap": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setOffset": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setShapeMode": ('PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setTransformationMode": ('PySide2.QtCore.Qt.TransformationMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shapeMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.transformationMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPolygonItem:
-    "PySide2.QtWidgets.QGraphicsPolygonItem.__init__": [('PySide2.QtGui.QPolygonF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPolygonItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.fillRule": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.polygon": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.type": (),
-# class PySide2.QtWidgets.QGraphicsProxyWidget:
-    "PySide2.QtWidgets.QGraphicsProxyWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.createProxyForChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.newProxyWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.subWidgetRect": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.widget": (),
-# class PySide2.QtWidgets.QGraphicsRectItem:
-    "PySide2.QtWidgets.QGraphicsRectItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsRectItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsRectItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsRectItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsRectItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsRectItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsRectItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.type": (),
-# class PySide2.QtWidgets.QGraphicsRotation:
-    "PySide2.QtWidgets.QGraphicsRotation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsRotation.angle": (),
-    "PySide2.QtWidgets.QGraphicsRotation.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsRotation.axis": (),
-    "PySide2.QtWidgets.QGraphicsRotation.origin": (),
-    "PySide2.QtWidgets.QGraphicsRotation.setAngle": ('float',),
-    "PySide2.QtWidgets.QGraphicsRotation.setAxis": [('PySide2.QtCore.Qt.Axis',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtWidgets.QGraphicsRotation.setOrigin": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtWidgets.QGraphicsScale:
-    "PySide2.QtWidgets.QGraphicsScale.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsScale.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsScale.origin": (),
-    "PySide2.QtWidgets.QGraphicsScale.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtWidgets.QGraphicsScale.setXScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setYScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setZScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.xScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.yScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.zScale": (),
-# class PySide2.QtWidgets.QGraphicsScene:
-# class PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayer:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayers:
-    "PySide2.QtWidgets.QGraphicsScene.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QGraphicsScene.activePanel": (),
-    "PySide2.QtWidgets.QGraphicsScene.activeWindow": (),
-    "PySide2.QtWidgets.QGraphicsScene.addEllipse": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.addLine": [('PySide2.QtCore.QLineF', 'PySide2.QtGui.QPen'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen')],
-    "PySide2.QtWidgets.QGraphicsScene.addPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsScene.addPolygon": ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addRect": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addSimpleText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsScene.advance": (),
-    "PySide2.QtWidgets.QGraphicsScene.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.bspTreeDepth": (),
-    "PySide2.QtWidgets.QGraphicsScene.clear": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearSelection": (),
-    "PySide2.QtWidgets.QGraphicsScene.collidingItems": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsScene.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.createItemGroup": ('typing.Sequence[PySide2.QtWidgets.QGraphicsItem]',),
-    "PySide2.QtWidgets.QGraphicsScene.destroyItemGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsScene.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.focusOnTouch": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.font": (),
-    "PySide2.QtWidgets.QGraphicsScene.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.height": (),
-    "PySide2.QtWidgets.QGraphicsScene.helpEvent": ('PySide2.QtWidgets.QGraphicsSceneHelpEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsScene.invalidate": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers')],
-    "PySide2.QtWidgets.QGraphicsScene.isActive": (),
-    "PySide2.QtWidgets.QGraphicsScene.isSortCacheEnabled": (),
-    "PySide2.QtWidgets.QGraphicsScene.itemAt": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTransform'), ('float', 'float', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemIndexMethod": (),
-    "PySide2.QtWidgets.QGraphicsScene.items": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.Qt.SortOrder',), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemsBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.minimumRenderSize": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseGrabberItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.palette": (),
-    "PySide2.QtWidgets.QGraphicsScene.removeItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.render": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'),
-    "PySide2.QtWidgets.QGraphicsScene.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectedItems": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectionArea": (),
-    "PySide2.QtWidgets.QGraphicsScene.sendEvent": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.setActivePanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.setActiveWindow": ('PySide2.QtWidgets.QGraphicsWidget',),
-    "PySide2.QtWidgets.QGraphicsScene.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setBspTreeDepth": ('int',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusOnTouch": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsScene.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setItemIndexMethod": ('PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod',),
-    "PySide2.QtWidgets.QGraphicsScene.setMinimumRenderSize": ('float',),
-    "PySide2.QtWidgets.QGraphicsScene.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsScene.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.setSelectionArea": [('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionOperation', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.setSortCacheEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStickyFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsScene.stickyFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.style": (),
-    "PySide2.QtWidgets.QGraphicsScene.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.views": (),
-    "PySide2.QtWidgets.QGraphicsScene.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.width": (),
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent:
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason:
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.reason": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setReason": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneDragDropEvent:
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.acceptProposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.dropAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.mimeData": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.possibleActions": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.proposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPossibleActions": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setProposedAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneEvent:
-    "PySide2.QtWidgets.QGraphicsSceneEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneEvent.widget": (),
-# class PySide2.QtWidgets.QGraphicsSceneHelpEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneHoverEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneMouseEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.button": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScenePos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.flags": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScenePos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setFlags": ('PySide2.QtCore.Qt.MouseEventFlags',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setSource": ('PySide2.QtCore.Qt.MouseEventSource',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneMoveEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.newPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.oldPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setNewPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setOldPos": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QGraphicsSceneResizeEvent:
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.newSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.oldSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setNewSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setOldSize": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtWidgets.QGraphicsSceneWheelEvent:
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.delta": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.orientation": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setDelta": ('int',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSimpleTextItem:
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setText": ('str',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.text": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTextItem:
-    "PySide2.QtWidgets.QGraphicsTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsTextItem.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsTextItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.defaultTextColor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.document": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.openExternalLinks": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsTextItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDefaultTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setHtml": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setPlainText": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.tabChangesFocus": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textCursor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textInteractionFlags": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textWidth": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toHtml": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toPlainText": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTransform:
-    "PySide2.QtWidgets.QGraphicsTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsTransform.update": (),
-# class PySide2.QtWidgets.QGraphicsView:
-# class PySide2.QtWidgets.QGraphicsView.CacheMode:
-# class PySide2.QtWidgets.QGraphicsView.CacheModeFlag:
-# class PySide2.QtWidgets.QGraphicsView.DragMode:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlag:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlags:
-# class PySide2.QtWidgets.QGraphicsView.ViewportAnchor:
-# class PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode:
-    "PySide2.QtWidgets.QGraphicsView.__init__": [('PySide2.QtWidgets.QGraphicsScene', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGraphicsView.alignment": (),
-    "PySide2.QtWidgets.QGraphicsView.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsView.centerOn": [('PySide2.QtCore.QPointF',), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragMode": (),
-    "PySide2.QtWidgets.QGraphicsView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawItems": ('PySide2.QtGui.QPainter', 'int', 'typing.Sequence[PySide2.QtWidgets.QGraphicsItem]', 'typing.Sequence[PySide2.QtWidgets.QStyleOptionGraphicsItem]'),
-    "PySide2.QtWidgets.QGraphicsView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QGraphicsView.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('PySide2.QtWidgets.QGraphicsItem', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.fitInView": [('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsView.invalidateScene": ('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'),
-    "PySide2.QtWidgets.QGraphicsView.isInteractive": (),
-    "PySide2.QtWidgets.QGraphicsView.isTransformed": (),
-    "PySide2.QtWidgets.QGraphicsView.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.items": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ItemSelectionMode')],
-    "PySide2.QtWidgets.QGraphicsView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.mapToScene": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('int', 'int'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.matrix": (),
-    "PySide2.QtWidgets.QGraphicsView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.optimizationFlags": (),
-    "PySide2.QtWidgets.QGraphicsView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGraphicsView.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.renderHints": (),
-    "PySide2.QtWidgets.QGraphicsView.resetCachedContent": (),
-    "PySide2.QtWidgets.QGraphicsView.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsView.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsView.rotate": ('float',),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandRect": (),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandSelectionMode": (),
-    "PySide2.QtWidgets.QGraphicsView.scale": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.scene": (),
-    "PySide2.QtWidgets.QGraphicsView.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsView.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QGraphicsView.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setCacheMode": ('PySide2.QtWidgets.QGraphicsView.CacheMode',),
-    "PySide2.QtWidgets.QGraphicsView.setDragMode": ('PySide2.QtWidgets.QGraphicsView.DragMode',),
-    "PySide2.QtWidgets.QGraphicsView.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setInteractive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlag": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlags": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlags',),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints',),
-    "PySide2.QtWidgets.QGraphicsView.setResizeAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setRubberBandSelectionMode": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsView.setScene": ('PySide2.QtWidgets.QGraphicsScene',),
-    "PySide2.QtWidgets.QGraphicsView.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setTransformationAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setViewportUpdateMode": ('PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode',),
-    "PySide2.QtWidgets.QGraphicsView.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsView.shear": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsView.sizeHint": (),
-    "PySide2.QtWidgets.QGraphicsView.transform": (),
-    "PySide2.QtWidgets.QGraphicsView.transformationAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.translate": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.updateScene": ('typing.Sequence[PySide2.QtCore.QRectF]',),
-    "PySide2.QtWidgets.QGraphicsView.updateSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.viewportTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.viewportUpdateMode": (),
-    "PySide2.QtWidgets.QGraphicsView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QGraphicsWidget:
-    "PySide2.QtWidgets.QGraphicsWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsWidget.actions": (),
-    "PySide2.QtWidgets.QGraphicsWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QGraphicsWidget.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QGraphicsWidget.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.close": (),
-    "PySide2.QtWidgets.QGraphicsWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QGraphicsWidget.focusWidget": (),
-    "PySide2.QtWidgets.QGraphicsWidget.font": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.grabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QGraphicsWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QGraphicsWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QGraphicsWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QGraphicsWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QGraphicsWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.layout": (),
-    "PySide2.QtWidgets.QGraphicsWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.moveEvent": ('PySide2.QtWidgets.QGraphicsSceneMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.paintWindowFrame": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.palette": (),
-    "PySide2.QtWidgets.QGraphicsWidget.polishEvent": (),
-    "PySide2.QtWidgets.QGraphicsWidget.propertyChange": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.rect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QGraphicsWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.resize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.setContentsMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QGraphicsWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsWidget.setGeometry": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setLayout": ('PySide2.QtWidgets.QGraphicsLayout',),
-    "PySide2.QtWidgets.QGraphicsWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QGraphicsWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsWidget.setTabOrder": ('PySide2.QtWidgets.QGraphicsWidget', 'PySide2.QtWidgets.QGraphicsWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFrameMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QGraphicsWidget.shape": (),
-    "PySide2.QtWidgets.QGraphicsWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.size": (),
-    "PySide2.QtWidgets.QGraphicsWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsWidget.style": (),
-    "PySide2.QtWidgets.QGraphicsWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QGraphicsWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFlags": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameSectionAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowTitle": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowType": (),
-# class PySide2.QtWidgets.QGridLayout:
-    "PySide2.QtWidgets.QGridLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGridLayout.addItem": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addLayout": [('PySide2.QtWidgets.QLayout', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QLayout', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.cellRect": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.columnStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.count": (),
-    "PySide2.QtWidgets.QGridLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QGridLayout.getItemPosition": ('int',),
-    "PySide2.QtWidgets.QGridLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QGridLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGridLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.itemAtPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.maximumSize": (),
-    "PySide2.QtWidgets.QGridLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.minimumSize": (),
-    "PySide2.QtWidgets.QGridLayout.originCorner": (),
-    "PySide2.QtWidgets.QGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGridLayout.rowStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setColumnMinimumWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setColumnStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setDefaultPositioning": ('int', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QGridLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QGridLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setOriginCorner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QGridLayout.setRowMinimumHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setRowStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.sizeHint": (),
-    "PySide2.QtWidgets.QGridLayout.spacing": (),
-    "PySide2.QtWidgets.QGridLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGroupBox:
-    "PySide2.QtWidgets.QGroupBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QGroupBox.alignment": (),
-    "PySide2.QtWidgets.QGroupBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QGroupBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGroupBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionGroupBox',),
-    "PySide2.QtWidgets.QGroupBox.isCheckable": (),
-    "PySide2.QtWidgets.QGroupBox.isChecked": (),
-    "PySide2.QtWidgets.QGroupBox.isFlat": (),
-    "PySide2.QtWidgets.QGroupBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QGroupBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGroupBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGroupBox.setAlignment": ('int',),
-    "PySide2.QtWidgets.QGroupBox.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setChecked": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setFlat": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setTitle": ('str',),
-    "PySide2.QtWidgets.QGroupBox.title": (),
-# class PySide2.QtWidgets.QHBoxLayout:
-    "PySide2.QtWidgets.QHBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QHeaderView:
-# class PySide2.QtWidgets.QHeaderView.ResizeMode:
-    "PySide2.QtWidgets.QHeaderView.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QHeaderView.cascadingSectionResizes": (),
-    "PySide2.QtWidgets.QHeaderView.count": (),
-    "PySide2.QtWidgets.QHeaderView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QHeaderView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QHeaderView.defaultAlignment": (),
-    "PySide2.QtWidgets.QHeaderView.defaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.doItemsLayout": (),
-    "PySide2.QtWidgets.QHeaderView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.headerDataChanged": ('PySide2.QtCore.Qt.Orientation', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.hiddenSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.hideSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.highlightSections": (),
-    "PySide2.QtWidgets.QHeaderView.horizontalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QHeaderView.initStyleOption": [('PySide2.QtWidgets.QStyleOptionFrame',), ('PySide2.QtWidgets.QStyleOptionHeader',)],
-    "PySide2.QtWidgets.QHeaderView.initialize": (),
-    "PySide2.QtWidgets.QHeaderView.initializeSections": [(), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.isFirstSectionMovable": (),
-    "PySide2.QtWidgets.QHeaderView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.isSectionHidden": ('int',),
-    "PySide2.QtWidgets.QHeaderView.isSortIndicatorShown": (),
-    "PySide2.QtWidgets.QHeaderView.length": (),
-    "PySide2.QtWidgets.QHeaderView.logicalIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.logicalIndexAt": [('PySide2.QtCore.QPoint',), ('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.maximumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.minimumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QHeaderView.moveSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.offset": (),
-    "PySide2.QtWidgets.QHeaderView.orientation": (),
-    "PySide2.QtWidgets.QHeaderView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QHeaderView.paintSection": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtWidgets.QHeaderView.reset": (),
-    "PySide2.QtWidgets.QHeaderView.resetDefaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.resizeContentsPrecision": (),
-    "PySide2.QtWidgets.QHeaderView.resizeSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.resizeSections": [(), ('PySide2.QtWidgets.QHeaderView.ResizeMode',)],
-    "PySide2.QtWidgets.QHeaderView.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QHeaderView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.saveState": (),
-    "PySide2.QtWidgets.QHeaderView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QHeaderView.sectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionResizeMode": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeFromContents": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeHint": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionViewportPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsClickable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsHidden": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsMovable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsMoved": (),
-    "PySide2.QtWidgets.QHeaderView.setCascadingSectionResizes": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setFirstSectionMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setHighlightSections": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setMaximumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setMinimumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QHeaderView.setOffset": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToSectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setResizeContentsPrecision": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setSectionHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QHeaderView.setSectionResizeMode": [('PySide2.QtWidgets.QHeaderView.ResizeMode',), ('int', 'PySide2.QtWidgets.QHeaderView.ResizeMode')],
-    "PySide2.QtWidgets.QHeaderView.setSectionsClickable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSectionsMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicator": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setStretchLastSection": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setVisible": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.showSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sizeHint": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorOrder": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.swapSections": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.updateGeometries": (),
-    "PySide2.QtWidgets.QHeaderView.updateSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.verticalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.visualIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualIndexAt": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QInputDialog:
-# class PySide2.QtWidgets.QInputDialog.InputDialogOption:
-# class PySide2.QtWidgets.QInputDialog.InputMode:
-    "PySide2.QtWidgets.QInputDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.cancelButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.comboBoxItems": (),
-    "PySide2.QtWidgets.QInputDialog.done": ('int',),
-    "PySide2.QtWidgets.QInputDialog.doubleDecimals": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleStep": (),
-    "PySide2.QtWidgets.QInputDialog.doubleValue": (),
-    "PySide2.QtWidgets.QInputDialog.getDouble": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags', 'float')],
-    "PySide2.QtWidgets.QInputDialog.getInt": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.getItem": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'typing.Sequence[str]', 'int', 'bool', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getMultiLineText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QLineEdit.EchoMode', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.inputMode": (),
-    "PySide2.QtWidgets.QInputDialog.intMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.intMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.intStep": (),
-    "PySide2.QtWidgets.QInputDialog.intValue": (),
-    "PySide2.QtWidgets.QInputDialog.isComboBoxEditable": (),
-    "PySide2.QtWidgets.QInputDialog.labelText": (),
-    "PySide2.QtWidgets.QInputDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.okButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QInputDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxEditable": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleDecimals": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMaximum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMinimum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleRange": ('float', 'float'),
-    "PySide2.QtWidgets.QInputDialog.setDoubleStep": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleValue": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setInputMode": ('PySide2.QtWidgets.QInputDialog.InputMode',),
-    "PySide2.QtWidgets.QInputDialog.setIntMaximum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntMinimum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntRange": ('int', 'int'),
-    "PySide2.QtWidgets.QInputDialog.setIntStep": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntValue": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOkButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption', 'bool'),
-    "PySide2.QtWidgets.QInputDialog.setTextEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QInputDialog.setTextValue": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.sizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.testOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption',),
-    "PySide2.QtWidgets.QInputDialog.textEchoMode": (),
-    "PySide2.QtWidgets.QInputDialog.textValue": (),
-# class PySide2.QtWidgets.QItemDelegate:
-    "PySide2.QtWidgets.QItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.decoration": ('PySide2.QtWidgets.QStyleOptionViewItem', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.doCheck": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.drawCheck": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QItemDelegate.drawDecoration": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QItemDelegate.drawDisplay": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.drawFocus": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QItemDelegate.hasClipping": (),
-    "PySide2.QtWidgets.QItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.rect": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QItemDelegate.selectedPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPalette', 'bool'),
-    "PySide2.QtWidgets.QItemDelegate.setClipping": ('bool',),
-    "PySide2.QtWidgets.QItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setOptions": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QStyleOptionViewItem'),
-    "PySide2.QtWidgets.QItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.textRectangle": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QFont', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QItemEditorCreatorBase:
-    "PySide2.QtWidgets.QItemEditorCreatorBase.__init__": (),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.valuePropertyName": (),
-# class PySide2.QtWidgets.QItemEditorFactory:
-    "PySide2.QtWidgets.QItemEditorFactory.__init__": (),
-    "PySide2.QtWidgets.QItemEditorFactory.createEditor": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QItemEditorFactory.defaultFactory": (),
-    "PySide2.QtWidgets.QItemEditorFactory.registerEditor": ('int', 'PySide2.QtWidgets.QItemEditorCreatorBase'),
-    "PySide2.QtWidgets.QItemEditorFactory.setDefaultFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemEditorFactory.valuePropertyName": ('int',),
-# class PySide2.QtWidgets.QKeyEventTransition:
-    "PySide2.QtWidgets.QKeyEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QKeyEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.key": (),
-    "PySide2.QtWidgets.QKeyEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QKeyEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.setKey": ('int',),
-    "PySide2.QtWidgets.QKeyEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QKeySequenceEdit:
-    "PySide2.QtWidgets.QKeySequenceEdit.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QKeySequenceEdit.clear": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keySequence": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.setKeySequence": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QKeySequenceEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QLCDNumber:
-# class PySide2.QtWidgets.QLCDNumber.Mode:
-# class PySide2.QtWidgets.QLCDNumber.SegmentStyle:
-    "PySide2.QtWidgets.QLCDNumber.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLCDNumber.checkOverflow": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLCDNumber.digitCount": (),
-    "PySide2.QtWidgets.QLCDNumber.display": [('float',), ('int',), ('str',)],
-    "PySide2.QtWidgets.QLCDNumber.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLCDNumber.intValue": (),
-    "PySide2.QtWidgets.QLCDNumber.mode": (),
-    "PySide2.QtWidgets.QLCDNumber.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLCDNumber.segmentStyle": (),
-    "PySide2.QtWidgets.QLCDNumber.setBinMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDecMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDigitCount": ('int',),
-    "PySide2.QtWidgets.QLCDNumber.setHexMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setMode": ('PySide2.QtWidgets.QLCDNumber.Mode',),
-    "PySide2.QtWidgets.QLCDNumber.setOctMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setSegmentStyle": ('PySide2.QtWidgets.QLCDNumber.SegmentStyle',),
-    "PySide2.QtWidgets.QLCDNumber.setSmallDecimalPoint": ('bool',),
-    "PySide2.QtWidgets.QLCDNumber.sizeHint": (),
-    "PySide2.QtWidgets.QLCDNumber.smallDecimalPoint": (),
-    "PySide2.QtWidgets.QLCDNumber.value": (),
-# class PySide2.QtWidgets.QLabel:
-    "PySide2.QtWidgets.QLabel.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QLabel.alignment": (),
-    "PySide2.QtWidgets.QLabel.buddy": (),
-    "PySide2.QtWidgets.QLabel.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.clear": (),
-    "PySide2.QtWidgets.QLabel.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLabel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QLabel.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.hasScaledContents": (),
-    "PySide2.QtWidgets.QLabel.hasSelectedText": (),
-    "PySide2.QtWidgets.QLabel.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLabel.indent": (),
-    "PySide2.QtWidgets.QLabel.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLabel.margin": (),
-    "PySide2.QtWidgets.QLabel.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLabel.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.movie": (),
-    "PySide2.QtWidgets.QLabel.openExternalLinks": (),
-    "PySide2.QtWidgets.QLabel.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLabel.picture": (),
-    "PySide2.QtWidgets.QLabel.pixmap": (),
-    "PySide2.QtWidgets.QLabel.selectedText": (),
-    "PySide2.QtWidgets.QLabel.selectionStart": (),
-    "PySide2.QtWidgets.QLabel.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLabel.setBuddy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLabel.setIndent": ('int',),
-    "PySide2.QtWidgets.QLabel.setMargin": ('int',),
-    "PySide2.QtWidgets.QLabel.setMovie": ('PySide2.QtGui.QMovie',),
-    "PySide2.QtWidgets.QLabel.setNum": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLabel.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QLabel.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtWidgets.QLabel.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QLabel.setScaledContents": ('bool',),
-    "PySide2.QtWidgets.QLabel.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLabel.setText": ('str',),
-    "PySide2.QtWidgets.QLabel.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QLabel.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QLabel.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QLabel.sizeHint": (),
-    "PySide2.QtWidgets.QLabel.text": (),
-    "PySide2.QtWidgets.QLabel.textFormat": (),
-    "PySide2.QtWidgets.QLabel.textInteractionFlags": (),
-    "PySide2.QtWidgets.QLabel.wordWrap": (),
-# class PySide2.QtWidgets.QLayout:
-# class PySide2.QtWidgets.QLayout.SizeConstraint:
-    "PySide2.QtWidgets.QLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.activate": (),
-    "PySide2.QtWidgets.QLayout.addChildLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.addChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.adoptLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.alignmentRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QLayout.closestAcceptableSize": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QLayout.contentsMargins": (),
-    "PySide2.QtWidgets.QLayout.contentsRect": (),
-    "PySide2.QtWidgets.QLayout.controlTypes": (),
-    "PySide2.QtWidgets.QLayout.count": (),
-    "PySide2.QtWidgets.QLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QLayout.geometry": (),
-    "PySide2.QtWidgets.QLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QLayout.indexOf": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.invalidate": (),
-    "PySide2.QtWidgets.QLayout.isEmpty": (),
-    "PySide2.QtWidgets.QLayout.isEnabled": (),
-    "PySide2.QtWidgets.QLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QLayout.layout": (),
-    "PySide2.QtWidgets.QLayout.margin": (),
-    "PySide2.QtWidgets.QLayout.maximumSize": (),
-    "PySide2.QtWidgets.QLayout.menuBar": (),
-    "PySide2.QtWidgets.QLayout.minimumSize": (),
-    "PySide2.QtWidgets.QLayout.parentWidget": (),
-    "PySide2.QtWidgets.QLayout.removeItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.replaceWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.FindChildOptions'),
-    "PySide2.QtWidgets.QLayout.setAlignment": [('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtWidgets.QLayout', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QLayout.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLayout.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.setMargin": ('int',),
-    "PySide2.QtWidgets.QLayout.setMenuBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.setSizeConstraint": ('PySide2.QtWidgets.QLayout.SizeConstraint',),
-    "PySide2.QtWidgets.QLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QLayout.sizeConstraint": (),
-    "PySide2.QtWidgets.QLayout.spacing": (),
-    "PySide2.QtWidgets.QLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QLayout.totalHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayout.totalMaximumSize": (),
-    "PySide2.QtWidgets.QLayout.totalMinimumSize": (),
-    "PySide2.QtWidgets.QLayout.totalSizeHint": (),
-    "PySide2.QtWidgets.QLayout.update": (),
-    "PySide2.QtWidgets.QLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QLayoutItem:
-    "PySide2.QtWidgets.QLayoutItem.__init__": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.alignment": (),
-    "PySide2.QtWidgets.QLayoutItem.controlTypes": (),
-    "PySide2.QtWidgets.QLayoutItem.expandingDirections": (),
-    "PySide2.QtWidgets.QLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QLayoutItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QLayoutItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.invalidate": (),
-    "PySide2.QtWidgets.QLayoutItem.isEmpty": (),
-    "PySide2.QtWidgets.QLayoutItem.layout": (),
-    "PySide2.QtWidgets.QLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayoutItem.sizeHint": (),
-    "PySide2.QtWidgets.QLayoutItem.spacerItem": (),
-    "PySide2.QtWidgets.QLayoutItem.widget": (),
-# class PySide2.QtWidgets.QLineEdit:
-# class PySide2.QtWidgets.QLineEdit.ActionPosition:
-# class PySide2.QtWidgets.QLineEdit.EchoMode:
-    "PySide2.QtWidgets.QLineEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLineEdit.addAction": [('PySide2.QtGui.QIcon', 'PySide2.QtWidgets.QLineEdit.ActionPosition'), ('PySide2.QtWidgets.QAction',), ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QLineEdit.ActionPosition')],
-    "PySide2.QtWidgets.QLineEdit.alignment": (),
-    "PySide2.QtWidgets.QLineEdit.backspace": (),
-    "PySide2.QtWidgets.QLineEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.clear": (),
-    "PySide2.QtWidgets.QLineEdit.completer": (),
-    "PySide2.QtWidgets.QLineEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLineEdit.copy": (),
-    "PySide2.QtWidgets.QLineEdit.createStandardContextMenu": (),
-    "PySide2.QtWidgets.QLineEdit.cursorBackward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorForward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorMoveStyle": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPosition": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPositionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QLineEdit.cursorRect": (),
-    "PySide2.QtWidgets.QLineEdit.cursorWordBackward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cursorWordForward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cut": (),
-    "PySide2.QtWidgets.QLineEdit.del_": (),
-    "PySide2.QtWidgets.QLineEdit.deselect": (),
-    "PySide2.QtWidgets.QLineEdit.displayText": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QLineEdit.echoMode": (),
-    "PySide2.QtWidgets.QLineEdit.end": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.getTextMargins": (),
-    "PySide2.QtWidgets.QLineEdit.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QLineEdit.hasFrame": (),
-    "PySide2.QtWidgets.QLineEdit.hasSelectedText": (),
-    "PySide2.QtWidgets.QLineEdit.home": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QLineEdit.inputMask": (),
-    "PySide2.QtWidgets.QLineEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QLineEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QLineEdit.insert": ('str',),
-    "PySide2.QtWidgets.QLineEdit.isClearButtonEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.isModified": (),
-    "PySide2.QtWidgets.QLineEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QLineEdit.isRedoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.isUndoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLineEdit.maxLength": (),
-    "PySide2.QtWidgets.QLineEdit.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLineEdit.paste": (),
-    "PySide2.QtWidgets.QLineEdit.placeholderText": (),
-    "PySide2.QtWidgets.QLineEdit.redo": (),
-    "PySide2.QtWidgets.QLineEdit.selectAll": (),
-    "PySide2.QtWidgets.QLineEdit.selectedText": (),
-    "PySide2.QtWidgets.QLineEdit.selectionEnd": (),
-    "PySide2.QtWidgets.QLineEdit.selectionLength": (),
-    "PySide2.QtWidgets.QLineEdit.selectionStart": (),
-    "PySide2.QtWidgets.QLineEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLineEdit.setClearButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QLineEdit.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtWidgets.QLineEdit.setCursorPosition": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QLineEdit.setFrame": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setInputMask": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setMaxLength": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setModified": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLineEdit.setText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setTextMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLineEdit.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QLineEdit.sizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.text": (),
-    "PySide2.QtWidgets.QLineEdit.textMargins": (),
-    "PySide2.QtWidgets.QLineEdit.undo": (),
-    "PySide2.QtWidgets.QLineEdit.validator": (),
-# class PySide2.QtWidgets.QListView:
-# class PySide2.QtWidgets.QListView.Flow:
-# class PySide2.QtWidgets.QListView.LayoutMode:
-# class PySide2.QtWidgets.QListView.Movement:
-# class PySide2.QtWidgets.QListView.ResizeMode:
-# class PySide2.QtWidgets.QListView.ViewMode:
-    "PySide2.QtWidgets.QListView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListView.batchSize": (),
-    "PySide2.QtWidgets.QListView.clearPropertyFlags": (),
-    "PySide2.QtWidgets.QListView.contentsSize": (),
-    "PySide2.QtWidgets.QListView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QListView.doItemsLayout": (),
-    "PySide2.QtWidgets.QListView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QListView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QListView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListView.flow": (),
-    "PySide2.QtWidgets.QListView.gridSize": (),
-    "PySide2.QtWidgets.QListView.horizontalOffset": (),
-    "PySide2.QtWidgets.QListView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QListView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QListView.isSelectionRectVisible": (),
-    "PySide2.QtWidgets.QListView.isWrapping": (),
-    "PySide2.QtWidgets.QListView.itemAlignment": (),
-    "PySide2.QtWidgets.QListView.layoutMode": (),
-    "PySide2.QtWidgets.QListView.modelColumn": (),
-    "PySide2.QtWidgets.QListView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QListView.movement": (),
-    "PySide2.QtWidgets.QListView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QListView.rectForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.reset": (),
-    "PySide2.QtWidgets.QListView.resizeContents": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QListView.resizeMode": (),
-    "PySide2.QtWidgets.QListView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListView.selectedIndexes": (),
-    "PySide2.QtWidgets.QListView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QListView.setBatchSize": ('int',),
-    "PySide2.QtWidgets.QListView.setFlow": ('PySide2.QtWidgets.QListView.Flow',),
-    "PySide2.QtWidgets.QListView.setGridSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListView.setItemAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QListView.setLayoutMode": ('PySide2.QtWidgets.QListView.LayoutMode',),
-    "PySide2.QtWidgets.QListView.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QListView.setMovement": ('PySide2.QtWidgets.QListView.Movement',),
-    "PySide2.QtWidgets.QListView.setPositionForIndex": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.setResizeMode": ('PySide2.QtWidgets.QListView.ResizeMode',),
-    "PySide2.QtWidgets.QListView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QListView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QListView.setSelectionRectVisible": ('bool',),
-    "PySide2.QtWidgets.QListView.setSpacing": ('int',),
-    "PySide2.QtWidgets.QListView.setUniformItemSizes": ('bool',),
-    "PySide2.QtWidgets.QListView.setViewMode": ('PySide2.QtWidgets.QListView.ViewMode',),
-    "PySide2.QtWidgets.QListView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QListView.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QListView.spacing": (),
-    "PySide2.QtWidgets.QListView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QListView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QListView.uniformItemSizes": (),
-    "PySide2.QtWidgets.QListView.updateGeometries": (),
-    "PySide2.QtWidgets.QListView.verticalOffset": (),
-    "PySide2.QtWidgets.QListView.viewMode": (),
-    "PySide2.QtWidgets.QListView.viewOptions": (),
-    "PySide2.QtWidgets.QListView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QListView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QListView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QListView.wordWrap": (),
-# class PySide2.QtWidgets.QListWidget:
-    "PySide2.QtWidgets.QListWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListWidget.addItem": [('PySide2.QtWidgets.QListWidgetItem',), ('str',)],
-    "PySide2.QtWidgets.QListWidget.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QListWidget.clear": (),
-    "PySide2.QtWidgets.QListWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.count": (),
-    "PySide2.QtWidgets.QListWidget.currentItem": (),
-    "PySide2.QtWidgets.QListWidget.currentRow": (),
-    "PySide2.QtWidgets.QListWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListWidget.dropMimeData": ('int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QListWidget.editItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QListWidget.indexFromItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.insertItem": [('int', 'PySide2.QtWidgets.QListWidgetItem'), ('int', 'str')],
-    "PySide2.QtWidgets.QListWidget.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QListWidget.isItemHidden": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isItemSelected": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QListWidget.item": ('int',),
-    "PySide2.QtWidgets.QListWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QListWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListWidget.itemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QListWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QListWidgetItem]',),
-    "PySide2.QtWidgets.QListWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QListWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.removeItemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.row": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.scrollToItem": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListWidget.selectedItems": (),
-    "PySide2.QtWidgets.QListWidget.setCurrentItem": [('PySide2.QtWidgets.QListWidgetItem',), ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setCurrentRow": [('int',), ('int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setItemHidden": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemSelected": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemWidget": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QListWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QListWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QListWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QListWidget.sortItems": ('PySide2.QtCore.Qt.SortOrder',),
-    "PySide2.QtWidgets.QListWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QListWidget.takeItem": ('int',),
-    "PySide2.QtWidgets.QListWidget.visualItemRect": ('PySide2.QtWidgets.QListWidgetItem',),
-# class PySide2.QtWidgets.QListWidgetItem:
-# class PySide2.QtWidgets.QListWidgetItem.ItemType:
-    "PySide2.QtWidgets.QListWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidgetItem',), ('str', 'PySide2.QtWidgets.QListWidget', 'int')],
-    "PySide2.QtWidgets.QListWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.background": (),
-    "PySide2.QtWidgets.QListWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QListWidgetItem.clone": (),
-    "PySide2.QtWidgets.QListWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.flags": (),
-    "PySide2.QtWidgets.QListWidgetItem.font": (),
-    "PySide2.QtWidgets.QListWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QListWidgetItem.icon": (),
-    "PySide2.QtWidgets.QListWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QListWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QListWidgetItem.listWidget": (),
-    "PySide2.QtWidgets.QListWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QListWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QListWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QListWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QListWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QListWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QListWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.text": (),
-    "PySide2.QtWidgets.QListWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QListWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.type": (),
-    "PySide2.QtWidgets.QListWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QListWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QMainWindow:
-# class PySide2.QtWidgets.QMainWindow.DockOption:
-# class PySide2.QtWidgets.QMainWindow.DockOptions:
-    "PySide2.QtWidgets.QMainWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMainWindow.addDockWidget": [('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget'), ('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtWidgets.QMainWindow.addToolBar": [('PySide2.QtCore.Qt.ToolBarArea', 'PySide2.QtWidgets.QToolBar'), ('PySide2.QtWidgets.QToolBar',), ('str',)],
-    "PySide2.QtWidgets.QMainWindow.addToolBarBreak": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QMainWindow.centralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMainWindow.corner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMainWindow.createPopupMenu": (),
-    "PySide2.QtWidgets.QMainWindow.dockOptions": (),
-    "PySide2.QtWidgets.QMainWindow.dockWidgetArea": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.documentMode": (),
-    "PySide2.QtWidgets.QMainWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMainWindow.iconSize": (),
-    "PySide2.QtWidgets.QMainWindow.insertToolBar": ('PySide2.QtWidgets.QToolBar', 'PySide2.QtWidgets.QToolBar'),
-    "PySide2.QtWidgets.QMainWindow.insertToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.isAnimated": (),
-    "PySide2.QtWidgets.QMainWindow.isDockNestingEnabled": (),
-    "PySide2.QtWidgets.QMainWindow.isSeparator": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMainWindow.menuBar": (),
-    "PySide2.QtWidgets.QMainWindow.menuWidget": (),
-    "PySide2.QtWidgets.QMainWindow.removeDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBar": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.resizeDocks": ('typing.Sequence[PySide2.QtWidgets.QDockWidget]', 'typing.Sequence[int]', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.restoreDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.restoreState": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QMainWindow.saveState": ('int',),
-    "PySide2.QtWidgets.QMainWindow.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setCentralWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setCorner": ('PySide2.QtCore.Qt.Corner', 'PySide2.QtCore.Qt.DockWidgetArea'),
-    "PySide2.QtWidgets.QMainWindow.setDockNestingEnabled": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setDockOptions": ('PySide2.QtWidgets.QMainWindow.DockOptions',),
-    "PySide2.QtWidgets.QMainWindow.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QMainWindow.setMenuBar": ('PySide2.QtWidgets.QMenuBar',),
-    "PySide2.QtWidgets.QMainWindow.setMenuWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setStatusBar": ('PySide2.QtWidgets.QStatusBar',),
-    "PySide2.QtWidgets.QMainWindow.setTabPosition": ('PySide2.QtCore.Qt.DockWidgetAreas', 'PySide2.QtWidgets.QTabWidget.TabPosition'),
-    "PySide2.QtWidgets.QMainWindow.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMainWindow.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QMainWindow.setUnifiedTitleAndToolBarOnMac": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.splitDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.statusBar": (),
-    "PySide2.QtWidgets.QMainWindow.tabPosition": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QMainWindow.tabShape": (),
-    "PySide2.QtWidgets.QMainWindow.tabifiedDockWidgets": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.tabifyDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget'),
-    "PySide2.QtWidgets.QMainWindow.takeCentralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.toolBarArea": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolButtonStyle": (),
-    "PySide2.QtWidgets.QMainWindow.unifiedTitleAndToolBarOnMac": (),
-# class PySide2.QtWidgets.QMdiArea:
-# class PySide2.QtWidgets.QMdiArea.AreaOption:
-# class PySide2.QtWidgets.QMdiArea.AreaOptions:
-# class PySide2.QtWidgets.QMdiArea.ViewMode:
-# class PySide2.QtWidgets.QMdiArea.WindowOrder:
-    "PySide2.QtWidgets.QMdiArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.activateNextSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activatePreviousSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activationOrder": (),
-    "PySide2.QtWidgets.QMdiArea.activeSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.addSubWindow": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiArea.background": (),
-    "PySide2.QtWidgets.QMdiArea.cascadeSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiArea.closeActiveSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.closeAllSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.currentSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.documentMode": (),
-    "PySide2.QtWidgets.QMdiArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiArea.removeSubWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QMdiArea.setActivationOrder": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.setActiveSubWindow": ('PySide2.QtWidgets.QMdiSubWindow',),
-    "PySide2.QtWidgets.QMdiArea.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QMdiArea.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setOption": ('PySide2.QtWidgets.QMdiArea.AreaOption', 'bool'),
-    "PySide2.QtWidgets.QMdiArea.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QMdiArea.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMdiArea.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setTabsMovable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setViewMode": ('PySide2.QtWidgets.QMdiArea.ViewMode',),
-    "PySide2.QtWidgets.QMdiArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiArea.sizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.subWindowList": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.tabPosition": (),
-    "PySide2.QtWidgets.QMdiArea.tabShape": (),
-    "PySide2.QtWidgets.QMdiArea.tabsClosable": (),
-    "PySide2.QtWidgets.QMdiArea.tabsMovable": (),
-    "PySide2.QtWidgets.QMdiArea.testOption": ('PySide2.QtWidgets.QMdiArea.AreaOption',),
-    "PySide2.QtWidgets.QMdiArea.tileSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiArea.viewMode": (),
-    "PySide2.QtWidgets.QMdiArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QMdiSubWindow:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOption:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOptions:
-    "PySide2.QtWidgets.QMdiSubWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiSubWindow.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiSubWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.isShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardPageStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardSingleStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedButtonsWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedSystemMenuIconWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mdiArea": (),
-    "PySide2.QtWidgets.QMdiSubWindow.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardPageStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardSingleStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption', 'bool'),
-    "PySide2.QtWidgets.QMdiSubWindow.setSystemMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QMdiSubWindow.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiSubWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.showShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.showSystemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.sizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.systemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.testOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption',),
-    "PySide2.QtWidgets.QMdiSubWindow.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.widget": (),
-# class PySide2.QtWidgets.QMenu:
-    "PySide2.QtWidgets.QMenu.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenu.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenu.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.activeAction": (),
-    "PySide2.QtWidgets.QMenu.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtGui.QIcon', 'str', 'object', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('str', 'object', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtWidgets.QMenu.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSection": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSeparator": (),
-    "PySide2.QtWidgets.QMenu.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.clear": (),
-    "PySide2.QtWidgets.QMenu.columnCount": (),
-    "PySide2.QtWidgets.QMenu.defaultAction": (),
-    "PySide2.QtWidgets.QMenu.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.exec_": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'), ('typing.Sequence[PySide2.QtWidgets.QAction]', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QMenu.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMenu.hideTearOffMenu": (),
-    "PySide2.QtWidgets.QMenu.icon": (),
-    "PySide2.QtWidgets.QMenu.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenu.insertSection": [('PySide2.QtWidgets.QAction', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction', 'str')],
-    "PySide2.QtWidgets.QMenu.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.isEmpty": (),
-    "PySide2.QtWidgets.QMenu.isTearOffEnabled": (),
-    "PySide2.QtWidgets.QMenu.isTearOffMenuVisible": (),
-    "PySide2.QtWidgets.QMenu.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenu.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.menuAction": (),
-    "PySide2.QtWidgets.QMenu.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenu.popup": ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.separatorsCollapsible": (),
-    "PySide2.QtWidgets.QMenu.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QMenu.setSeparatorsCollapsible": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTearOffEnabled": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTitle": ('str',),
-    "PySide2.QtWidgets.QMenu.setToolTipsVisible": ('bool',),
-    "PySide2.QtWidgets.QMenu.showTearOffMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QMenu.sizeHint": (),
-    "PySide2.QtWidgets.QMenu.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMenu.title": (),
-    "PySide2.QtWidgets.QMenu.toolTipsVisible": (),
-    "PySide2.QtWidgets.QMenu.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QMenuBar:
-    "PySide2.QtWidgets.QMenuBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMenuBar.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenuBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenuBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.activeAction": (),
-    "PySide2.QtWidgets.QMenuBar.addAction": [('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'object')],
-    "PySide2.QtWidgets.QMenuBar.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenuBar.addSeparator": (),
-    "PySide2.QtWidgets.QMenuBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.clear": (),
-    "PySide2.QtWidgets.QMenuBar.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMenuBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMenuBar.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QMenuBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenuBar.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenuBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.isDefaultUp": (),
-    "PySide2.QtWidgets.QMenuBar.isNativeMenuBar": (),
-    "PySide2.QtWidgets.QMenuBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenuBar.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenuBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMenuBar.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QMenuBar.setDefaultUp": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setNativeMenuBar": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setVisible": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.sizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QMessageBox:
-# class PySide2.QtWidgets.QMessageBox.ButtonRole:
-# class PySide2.QtWidgets.QMessageBox.Icon:
-# class PySide2.QtWidgets.QMessageBox.StandardButton:
-# class PySide2.QtWidgets.QMessageBox.StandardButtons:
-    "PySide2.QtWidgets.QMessageBox.__init__": [('PySide2.QtWidgets.QMessageBox.Icon', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QMessageBox.about": ('PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QMessageBox.aboutQt": ('PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtWidgets.QMessageBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QMessageBox.ButtonRole'), ('PySide2.QtWidgets.QMessageBox.StandardButton',), ('str', 'PySide2.QtWidgets.QMessageBox.ButtonRole')],
-    "PySide2.QtWidgets.QMessageBox.button": ('PySide2.QtWidgets.QMessageBox.StandardButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonText": ('int',),
-    "PySide2.QtWidgets.QMessageBox.buttons": (),
-    "PySide2.QtWidgets.QMessageBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.checkBox": (),
-    "PySide2.QtWidgets.QMessageBox.clickedButton": (),
-    "PySide2.QtWidgets.QMessageBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMessageBox.critical": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.defaultButton": (),
-    "PySide2.QtWidgets.QMessageBox.detailedText": (),
-    "PySide2.QtWidgets.QMessageBox.escapeButton": (),
-    "PySide2.QtWidgets.QMessageBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.icon": (),
-    "PySide2.QtWidgets.QMessageBox.iconPixmap": (),
-    "PySide2.QtWidgets.QMessageBox.information": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.informativeText": (),
-    "PySide2.QtWidgets.QMessageBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMessageBox.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QMessageBox.question": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMessageBox.setButtonText": ('int', 'str'),
-    "PySide2.QtWidgets.QMessageBox.setCheckBox": ('PySide2.QtWidgets.QCheckBox',),
-    "PySide2.QtWidgets.QMessageBox.setDefaultButton": [('PySide2.QtWidgets.QMessageBox.StandardButton',), ('PySide2.QtWidgets.QPushButton',)],
-    "PySide2.QtWidgets.QMessageBox.setDetailedText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setEscapeButton": [('PySide2.QtWidgets.QAbstractButton',), ('PySide2.QtWidgets.QMessageBox.StandardButton',)],
-    "PySide2.QtWidgets.QMessageBox.setIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.setIconPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QMessageBox.setInformativeText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setStandardButtons": ('PySide2.QtWidgets.QMessageBox.StandardButtons',),
-    "PySide2.QtWidgets.QMessageBox.setText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QMessageBox.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QMessageBox.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QMessageBox.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QMessageBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMessageBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.standardButtons": (),
-    "PySide2.QtWidgets.QMessageBox.standardIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.text": (),
-    "PySide2.QtWidgets.QMessageBox.textFormat": (),
-    "PySide2.QtWidgets.QMessageBox.textInteractionFlags": (),
-    "PySide2.QtWidgets.QMessageBox.warning": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-# class PySide2.QtWidgets.QMouseEventTransition:
-    "PySide2.QtWidgets.QMouseEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QMouseEventTransition.button": (),
-    "PySide2.QtWidgets.QMouseEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.hitTestPath": (),
-    "PySide2.QtWidgets.QMouseEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QMouseEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QMouseEventTransition.setHitTestPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QMouseEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QOpenGLWidget:
-# class PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior:
-    "PySide2.QtWidgets.QOpenGLWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QOpenGLWidget.context": (),
-    "PySide2.QtWidgets.QOpenGLWidget.defaultFramebufferObject": (),
-    "PySide2.QtWidgets.QOpenGLWidget.doneCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.format": (),
-    "PySide2.QtWidgets.QOpenGLWidget.grabFramebuffer": (),
-    "PySide2.QtWidgets.QOpenGLWidget.initializeGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.isValid": (),
-    "PySide2.QtWidgets.QOpenGLWidget.makeCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEngine": (),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtWidgets.QOpenGLWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtWidgets.QOpenGLWidget.setTextureFormat": ('int',),
-    "PySide2.QtWidgets.QOpenGLWidget.setUpdateBehavior": ('PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior',),
-    "PySide2.QtWidgets.QOpenGLWidget.textureFormat": (),
-    "PySide2.QtWidgets.QOpenGLWidget.updateBehavior": (),
-# class PySide2.QtWidgets.QPanGesture:
-    "PySide2.QtWidgets.QPanGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPanGesture.acceleration": (),
-    "PySide2.QtWidgets.QPanGesture.delta": (),
-    "PySide2.QtWidgets.QPanGesture.lastOffset": (),
-    "PySide2.QtWidgets.QPanGesture.offset": (),
-    "PySide2.QtWidgets.QPanGesture.setAcceleration": ('float',),
-    "PySide2.QtWidgets.QPanGesture.setLastOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPanGesture.setOffset": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QPinchGesture:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlag:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlags:
-    "PySide2.QtWidgets.QPinchGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPinchGesture.centerPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.changeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.lastCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.lastRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.lastScaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.rotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.scaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.setCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setLastCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setLastRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setLastScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setStartCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.startCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.totalChangeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.totalRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.totalScaleFactor": (),
-# class PySide2.QtWidgets.QPlainTextDocumentLayout:
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentSize": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.ensureBlockLayout": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.pageCount": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.requestUpdate": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.setCursorWidth": ('int',),
-# class PySide2.QtWidgets.QPlainTextEdit:
-# class PySide2.QtWidgets.QPlainTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QPlainTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPlainTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendHtml": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.backgroundVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingGeometry": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerOnScroll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.clear": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contentOffset": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.copy": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QPlainTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QPlainTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cut": (),
-    "PySide2.QtWidgets.QPlainTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.document": (),
-    "PySide2.QtWidgets.QPlainTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QPlainTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QPlainTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QPlainTextEdit.firstVisibleBlock": (),
-    "PySide2.QtWidgets.QPlainTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.getPaintContext": (),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QPlainTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QPlainTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QPlainTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QPlainTextEdit.maximumBlockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QPlainTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.paste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QPlainTextEdit.redo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QPlainTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.setBackgroundVisible": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCenterOnScroll": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QPlainTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QPlainTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.setMaximumBlockCount": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QPlainTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QPlainTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.undo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QProgressBar:
-# class PySide2.QtWidgets.QProgressBar.Direction:
-    "PySide2.QtWidgets.QProgressBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QProgressBar.alignment": (),
-    "PySide2.QtWidgets.QProgressBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressBar.format": (),
-    "PySide2.QtWidgets.QProgressBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionProgressBar',),
-    "PySide2.QtWidgets.QProgressBar.invertedAppearance": (),
-    "PySide2.QtWidgets.QProgressBar.isTextVisible": (),
-    "PySide2.QtWidgets.QProgressBar.maximum": (),
-    "PySide2.QtWidgets.QProgressBar.minimum": (),
-    "PySide2.QtWidgets.QProgressBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.orientation": (),
-    "PySide2.QtWidgets.QProgressBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QProgressBar.reset": (),
-    "PySide2.QtWidgets.QProgressBar.resetFormat": (),
-    "PySide2.QtWidgets.QProgressBar.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QProgressBar.setFormat": ('str',),
-    "PySide2.QtWidgets.QProgressBar.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QProgressBar.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressBar.setTextDirection": ('PySide2.QtWidgets.QProgressBar.Direction',),
-    "PySide2.QtWidgets.QProgressBar.setTextVisible": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressBar.sizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.text": (),
-    "PySide2.QtWidgets.QProgressBar.textDirection": (),
-    "PySide2.QtWidgets.QProgressBar.value": (),
-# class PySide2.QtWidgets.QProgressDialog:
-    "PySide2.QtWidgets.QProgressDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'str', 'int', 'int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QProgressDialog.autoClose": (),
-    "PySide2.QtWidgets.QProgressDialog.autoReset": (),
-    "PySide2.QtWidgets.QProgressDialog.cancel": (),
-    "PySide2.QtWidgets.QProgressDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QProgressDialog.forceShow": (),
-    "PySide2.QtWidgets.QProgressDialog.labelText": (),
-    "PySide2.QtWidgets.QProgressDialog.maximum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimumDuration": (),
-    "PySide2.QtWidgets.QProgressDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QProgressDialog.reset": (),
-    "PySide2.QtWidgets.QProgressDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoClose": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoReset": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setBar": ('PySide2.QtWidgets.QProgressBar',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButton": ('PySide2.QtWidgets.QPushButton',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setLabel": ('PySide2.QtWidgets.QLabel',),
-    "PySide2.QtWidgets.QProgressDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimumDuration": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressDialog.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QProgressDialog.sizeHint": (),
-    "PySide2.QtWidgets.QProgressDialog.value": (),
-    "PySide2.QtWidgets.QProgressDialog.wasCanceled": (),
-# class PySide2.QtWidgets.QProxyStyle:
-    "PySide2.QtWidgets.QProxyStyle.__init__": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QProxyStyle.baseStyle": (),
-    "PySide2.QtWidgets.QProxyStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QProxyStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProxyStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QProxyStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QProxyStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QProxyStyle.setBaseStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QProxyStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardPalette": (),
-    "PySide2.QtWidgets.QProxyStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QProxyStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QPushButton:
-    "PySide2.QtWidgets.QPushButton.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPushButton.autoDefault": (),
-    "PySide2.QtWidgets.QPushButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPushButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QPushButton.isDefault": (),
-    "PySide2.QtWidgets.QPushButton.isFlat": (),
-    "PySide2.QtWidgets.QPushButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPushButton.menu": (),
-    "PySide2.QtWidgets.QPushButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QPushButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPushButton.setAutoDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setFlat": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QPushButton.showMenu": (),
-    "PySide2.QtWidgets.QPushButton.sizeHint": (),
-# class PySide2.QtWidgets.QRadioButton:
-    "PySide2.QtWidgets.QRadioButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QRadioButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRadioButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QRadioButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QRadioButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QRadioButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QRadioButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRadioButton.sizeHint": (),
-# class PySide2.QtWidgets.QRubberBand:
-# class PySide2.QtWidgets.QRubberBand.Shape:
-    "PySide2.QtWidgets.QRubberBand.__init__": ('PySide2.QtWidgets.QRubberBand.Shape', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QRubberBand.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.initStyleOption": ('PySide2.QtWidgets.QStyleOptionRubberBand',),
-    "PySide2.QtWidgets.QRubberBand.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QRubberBand.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRubberBand.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QRubberBand.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.shape": (),
-    "PySide2.QtWidgets.QRubberBand.showEvent": ('PySide2.QtGui.QShowEvent',),
-# class PySide2.QtWidgets.QScrollArea:
-    "PySide2.QtWidgets.QScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.alignment": (),
-    "PySide2.QtWidgets.QScrollArea.ensureVisible": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.ensureWidgetVisible": ('PySide2.QtWidgets.QWidget', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QScrollArea.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QScrollArea.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.setWidgetResizable": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.takeWidget": (),
-    "PySide2.QtWidgets.QScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.widget": (),
-    "PySide2.QtWidgets.QScrollArea.widgetResizable": (),
-# class PySide2.QtWidgets.QScrollBar:
-    "PySide2.QtWidgets.QScrollBar.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QScrollBar.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QScrollBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QScrollBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QScrollBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QScrollBar.sizeHint": (),
-    "PySide2.QtWidgets.QScrollBar.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QScrollBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QScroller:
-# class PySide2.QtWidgets.QScroller.Input:
-# class PySide2.QtWidgets.QScroller.ScrollerGestureType:
-# class PySide2.QtWidgets.QScroller.State:
-    "PySide2.QtWidgets.QScroller.activeScrollers": (),
-    "PySide2.QtWidgets.QScroller.ensureVisible": [('PySide2.QtCore.QRectF', 'float', 'float'), ('PySide2.QtCore.QRectF', 'float', 'float', 'int')],
-    "PySide2.QtWidgets.QScroller.finalPosition": (),
-    "PySide2.QtWidgets.QScroller.grabGesture": ('PySide2.QtCore.QObject', 'PySide2.QtWidgets.QScroller.ScrollerGestureType'),
-    "PySide2.QtWidgets.QScroller.grabbedGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.handleInput": ('PySide2.QtWidgets.QScroller.Input', 'PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtWidgets.QScroller.hasScroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.pixelPerMeter": (),
-    "PySide2.QtWidgets.QScroller.resendPrepareEvent": (),
-    "PySide2.QtWidgets.QScroller.scrollTo": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtWidgets.QScroller.scroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.scrollerProperties": (),
-    "PySide2.QtWidgets.QScroller.setScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScroller.setSnapPositionsX": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.setSnapPositionsY": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.state": (),
-    "PySide2.QtWidgets.QScroller.stop": (),
-    "PySide2.QtWidgets.QScroller.target": (),
-    "PySide2.QtWidgets.QScroller.ungrabGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.velocity": (),
-# class PySide2.QtWidgets.QScrollerProperties:
-# class PySide2.QtWidgets.QScrollerProperties.FrameRates:
-# class PySide2.QtWidgets.QScrollerProperties.OvershootPolicy:
-# class PySide2.QtWidgets.QScrollerProperties.ScrollMetric:
-    "PySide2.QtWidgets.QScrollerProperties.__init__": [(), ('PySide2.QtWidgets.QScrollerProperties',)],
-    "PySide2.QtWidgets.QScrollerProperties.__copy__": (),
-    "PySide2.QtWidgets.QScrollerProperties.scrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric',),
-    "PySide2.QtWidgets.QScrollerProperties.setDefaultScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScrollerProperties.setScrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric', 'typing.Any'),
-    "PySide2.QtWidgets.QScrollerProperties.unsetDefaultScrollerProperties": (),
-# class PySide2.QtWidgets.QShortcut:
-    "PySide2.QtWidgets.QShortcut.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'typing.Callable', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QShortcut.autoRepeat": (),
-    "PySide2.QtWidgets.QShortcut.context": (),
-    "PySide2.QtWidgets.QShortcut.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QShortcut.id": (),
-    "PySide2.QtWidgets.QShortcut.isEnabled": (),
-    "PySide2.QtWidgets.QShortcut.key": (),
-    "PySide2.QtWidgets.QShortcut.parentWidget": (),
-    "PySide2.QtWidgets.QShortcut.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QShortcut.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setKey": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QShortcut.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QShortcut.whatsThis": (),
-# class PySide2.QtWidgets.QSizeGrip:
-    "PySide2.QtWidgets.QSizeGrip.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSizeGrip.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSizeGrip.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QSizeGrip.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QSizeGrip.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSizeGrip.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSizeGrip.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QSizeGrip.sizeHint": (),
-# class PySide2.QtWidgets.QSizePolicy:
-# class PySide2.QtWidgets.QSizePolicy.ControlType:
-# class PySide2.QtWidgets.QSizePolicy.ControlTypes:
-# class PySide2.QtWidgets.QSizePolicy.Policy:
-# class PySide2.QtWidgets.QSizePolicy.PolicyFlag:
-    "PySide2.QtWidgets.QSizePolicy.__init__": [(), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QSizePolicy.__copy__": (),
-    "PySide2.QtWidgets.QSizePolicy.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.controlType": (),
-    "PySide2.QtWidgets.QSizePolicy.expandingDirections": (),
-    "PySide2.QtWidgets.QSizePolicy.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QSizePolicy.hasWidthForHeight": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalStretch": (),
-    "PySide2.QtWidgets.QSizePolicy.retainSizeWhenHidden": (),
-    "PySide2.QtWidgets.QSizePolicy.setControlType": ('PySide2.QtWidgets.QSizePolicy.ControlType',),
-    "PySide2.QtWidgets.QSizePolicy.setHeightForWidth": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setRetainSizeWhenHidden": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setWidthForHeight": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.transpose": (),
-    "PySide2.QtWidgets.QSizePolicy.transposed": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalStretch": (),
-# class PySide2.QtWidgets.QSlider:
-# class PySide2.QtWidgets.QSlider.TickPosition:
-    "PySide2.QtWidgets.QSlider.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSlider.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QSlider.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSlider.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSlider.setTickInterval": ('int',),
-    "PySide2.QtWidgets.QSlider.setTickPosition": ('PySide2.QtWidgets.QSlider.TickPosition',),
-    "PySide2.QtWidgets.QSlider.sizeHint": (),
-    "PySide2.QtWidgets.QSlider.tickInterval": (),
-    "PySide2.QtWidgets.QSlider.tickPosition": (),
-# class PySide2.QtWidgets.QSpacerItem:
-    "PySide2.QtWidgets.QSpacerItem.__init__": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.changeSize": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.expandingDirections": (),
-    "PySide2.QtWidgets.QSpacerItem.geometry": (),
-    "PySide2.QtWidgets.QSpacerItem.isEmpty": (),
-    "PySide2.QtWidgets.QSpacerItem.maximumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.minimumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QSpacerItem.sizeHint": (),
-    "PySide2.QtWidgets.QSpacerItem.sizePolicy": (),
-    "PySide2.QtWidgets.QSpacerItem.spacerItem": (),
-# class PySide2.QtWidgets.QSpinBox:
-    "PySide2.QtWidgets.QSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QSpinBox.displayIntegerBase": (),
-    "PySide2.QtWidgets.QSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QSpinBox.maximum": (),
-    "PySide2.QtWidgets.QSpinBox.minimum": (),
-    "PySide2.QtWidgets.QSpinBox.prefix": (),
-    "PySide2.QtWidgets.QSpinBox.setDisplayIntegerBase": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMaximum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMinimum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QSpinBox.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QSpinBox.stepType": (),
-    "PySide2.QtWidgets.QSpinBox.suffix": (),
-    "PySide2.QtWidgets.QSpinBox.textFromValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QSpinBox.value": (),
-    "PySide2.QtWidgets.QSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QSplashScreen:
-    "PySide2.QtWidgets.QSplashScreen.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QSplashScreen.clearMessage": (),
-    "PySide2.QtWidgets.QSplashScreen.drawContents": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QSplashScreen.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplashScreen.finish": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplashScreen.message": (),
-    "PySide2.QtWidgets.QSplashScreen.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplashScreen.pixmap": (),
-    "PySide2.QtWidgets.QSplashScreen.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QSplashScreen.showMessage": ('str', 'int', 'PySide2.QtGui.QColor'),
-# class PySide2.QtWidgets.QSplitter:
-    "PySide2.QtWidgets.QSplitter.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSplitter.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.__rshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QSplitter.childrenCollapsible": (),
-    "PySide2.QtWidgets.QSplitter.closestLegalPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.count": (),
-    "PySide2.QtWidgets.QSplitter.createHandle": (),
-    "PySide2.QtWidgets.QSplitter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.getRange": ('int',),
-    "PySide2.QtWidgets.QSplitter.handle": ('int',),
-    "PySide2.QtWidgets.QSplitter.handleWidth": (),
-    "PySide2.QtWidgets.QSplitter.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.isCollapsible": ('int',),
-    "PySide2.QtWidgets.QSplitter.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSplitter.moveSplitter": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitter.orientation": (),
-    "PySide2.QtWidgets.QSplitter.refresh": (),
-    "PySide2.QtWidgets.QSplitter.replaceWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitter.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QSplitter.saveState": (),
-    "PySide2.QtWidgets.QSplitter.setChildrenCollapsible": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setCollapsible": ('int', 'bool'),
-    "PySide2.QtWidgets.QSplitter.setHandleWidth": ('int',),
-    "PySide2.QtWidgets.QSplitter.setOpaqueResize": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitter.setRubberBand": ('int',),
-    "PySide2.QtWidgets.QSplitter.setSizes": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QSplitter.setStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.sizeHint": (),
-    "PySide2.QtWidgets.QSplitter.sizes": (),
-    "PySide2.QtWidgets.QSplitter.widget": ('int',),
-# class PySide2.QtWidgets.QSplitterHandle:
-    "PySide2.QtWidgets.QSplitterHandle.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QSplitter'),
-    "PySide2.QtWidgets.QSplitterHandle.closestLegalPosition": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.moveSplitter": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitterHandle.orientation": (),
-    "PySide2.QtWidgets.QSplitterHandle.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitterHandle.sizeHint": (),
-    "PySide2.QtWidgets.QSplitterHandle.splitter": (),
-# class PySide2.QtWidgets.QStackedLayout:
-# class PySide2.QtWidgets.QStackedLayout.StackingMode:
-    "PySide2.QtWidgets.QStackedLayout.__init__": [(), ('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStackedLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QStackedLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.count": (),
-    "PySide2.QtWidgets.QStackedLayout.currentIndex": (),
-    "PySide2.QtWidgets.QStackedLayout.currentWidget": (),
-    "PySide2.QtWidgets.QStackedLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QStackedLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.minimumSize": (),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QStackedLayout.setStackingMode": ('PySide2.QtWidgets.QStackedLayout.StackingMode',),
-    "PySide2.QtWidgets.QStackedLayout.sizeHint": (),
-    "PySide2.QtWidgets.QStackedLayout.stackingMode": (),
-    "PySide2.QtWidgets.QStackedLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.widget": [(), ('int',)],
-# class PySide2.QtWidgets.QStackedWidget:
-    "PySide2.QtWidgets.QStackedWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.count": (),
-    "PySide2.QtWidgets.QStackedWidget.currentIndex": (),
-    "PySide2.QtWidgets.QStackedWidget.currentWidget": (),
-    "PySide2.QtWidgets.QStackedWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStackedWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedWidget.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.widget": ('int',),
-# class PySide2.QtWidgets.QStatusBar:
-    "PySide2.QtWidgets.QStatusBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.addPermanentWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.addWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.clearMessage": (),
-    "PySide2.QtWidgets.QStatusBar.currentMessage": (),
-    "PySide2.QtWidgets.QStatusBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStatusBar.hideOrShow": (),
-    "PySide2.QtWidgets.QStatusBar.insertPermanentWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QStatusBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QStatusBar.reformat": (),
-    "PySide2.QtWidgets.QStatusBar.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QStatusBar.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QStatusBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QStatusBar.showMessage": ('str', 'int'),
-# class PySide2.QtWidgets.QStyle:
-# class PySide2.QtWidgets.QStyle.ComplexControl:
-# class PySide2.QtWidgets.QStyle.ContentsType:
-# class PySide2.QtWidgets.QStyle.ControlElement:
-# class PySide2.QtWidgets.QStyle.PixelMetric:
-# class PySide2.QtWidgets.QStyle.PrimitiveElement:
-# class PySide2.QtWidgets.QStyle.RequestSoftwareInputPanel:
-# class PySide2.QtWidgets.QStyle.StandardPixmap:
-# class PySide2.QtWidgets.QStyle.State:
-# class PySide2.QtWidgets.QStyle.StateFlag:
-# class PySide2.QtWidgets.QStyle.StyleHint:
-# class PySide2.QtWidgets.QStyle.SubControl:
-# class PySide2.QtWidgets.QStyle.SubControls:
-# class PySide2.QtWidgets.QStyle.SubElement:
-    "PySide2.QtWidgets.QStyle.__init__": (),
-    "PySide2.QtWidgets.QStyle.alignedRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QStyle.combinedLayoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.proxy": (),
-    "PySide2.QtWidgets.QStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.sliderPositionFromValue": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.sliderValueFromPosition": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.standardPalette": (),
-    "PySide2.QtWidgets.QStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.visualAlignment": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QStyle.visualPos": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QStyle.visualRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QRect'),
-# class PySide2.QtWidgets.QStyleFactory:
-    "PySide2.QtWidgets.QStyleFactory.__init__": (),
-    "PySide2.QtWidgets.QStyleFactory.create": ('str',),
-    "PySide2.QtWidgets.QStyleFactory.keys": (),
-# class PySide2.QtWidgets.QStyleHintReturn:
-# class PySide2.QtWidgets.QStyleHintReturn.HintReturnType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturn.__init__": ('int', 'int'),
-# class PySide2.QtWidgets.QStyleHintReturnMask:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnMask.__init__": (),
-# class PySide2.QtWidgets.QStyleHintReturnVariant:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnVariant.__init__": (),
-# class PySide2.QtWidgets.QStyleOption:
-# class PySide2.QtWidgets.QStyleOption.OptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOption.__init__": [('PySide2.QtWidgets.QStyleOption',), ('int', 'int')],
-    "PySide2.QtWidgets.QStyleOption.init": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStyleOption.initFrom": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QStyleOptionButton:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeatures:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComboBox:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComboBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionComboBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComplex:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComplex.__init__": [('PySide2.QtWidgets.QStyleOptionComplex',), ('int', 'int')],
-# class PySide2.QtWidgets.QStyleOptionDockWidget:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionDockWidget.__init__": [(), ('PySide2.QtWidgets.QStyleOptionDockWidget',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFocusRect:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFocusRect.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFocusRect',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFrame:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeature:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeatures:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGraphicsItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.levelOfDetailFromTransform": ('PySide2.QtGui.QTransform',),
-# class PySide2.QtWidgets.QStyleOptionGroupBox:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGroupBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGroupBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionHeader:
-# class PySide2.QtWidgets.QStyleOptionHeader.SectionPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SortIndicator:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionHeader.__init__": [(), ('PySide2.QtWidgets.QStyleOptionHeader',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionMenuItem:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.CheckType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.MenuItemType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionMenuItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionMenuItem',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionProgressBar:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionProgressBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionProgressBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionRubberBand:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionRubberBand.__init__": [(), ('PySide2.QtWidgets.QStyleOptionRubberBand',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSizeGrip:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSizeGrip.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSizeGrip',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSlider:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSlider.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSlider',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSpinBox:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSpinBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSpinBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTab:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidget:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidgets:
-# class PySide2.QtWidgets.QStyleOptionTab.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeature:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeatures:
-# class PySide2.QtWidgets.QStyleOptionTab.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionTab.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTab',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabBarBase:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabBarBase.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabBarBase',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabWidgetFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTitleBar:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTitleBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTitleBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBar:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeature:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeatures:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBox:
-# class PySide2.QtWidgets.QStyleOptionToolBox.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBox.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolButton:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeatures:
-    "PySide2.QtWidgets.QStyleOptionToolButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionViewItem:
-# class PySide2.QtWidgets.QStyleOptionViewItem.Position:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeature:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeatures:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemPosition:
-    "PySide2.QtWidgets.QStyleOptionViewItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionViewItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionViewItem.__copy__": (),
-# class PySide2.QtWidgets.QStylePainter:
-    "PySide2.QtWidgets.QStylePainter.__init__": [(), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.begin": [('PySide2.QtGui.QPaintDevice',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex'),
-    "PySide2.QtWidgets.QStylePainter.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.drawItemPixmap": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStylePainter.drawItemText": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStylePainter.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.style": (),
-# class PySide2.QtWidgets.QStyledItemDelegate:
-    "PySide2.QtWidgets.QStyledItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QStyledItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.displayText": ('typing.Any', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtWidgets.QStyledItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QStyledItemDelegate.initStyleOption": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QStyledItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QStyledItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QSwipeGesture:
-# class PySide2.QtWidgets.QSwipeGesture.SwipeDirection:
-    "PySide2.QtWidgets.QSwipeGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QSwipeGesture.horizontalDirection": (),
-    "PySide2.QtWidgets.QSwipeGesture.setSwipeAngle": ('float',),
-    "PySide2.QtWidgets.QSwipeGesture.swipeAngle": (),
-    "PySide2.QtWidgets.QSwipeGesture.verticalDirection": (),
-# class PySide2.QtWidgets.QSystemTrayIcon:
-# class PySide2.QtWidgets.QSystemTrayIcon.ActivationReason:
-# class PySide2.QtWidgets.QSystemTrayIcon.MessageIcon:
-    "PySide2.QtWidgets.QSystemTrayIcon.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QSystemTrayIcon.contextMenu": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSystemTrayIcon.geometry": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.hide": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.icon": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isSystemTrayAvailable": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isVisible": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.setContextMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setToolTip": ('str',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSystemTrayIcon.show": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.showMessage": [('str', 'str', 'PySide2.QtGui.QIcon', 'int'), ('str', 'str', 'PySide2.QtWidgets.QSystemTrayIcon.MessageIcon', 'int')],
-    "PySide2.QtWidgets.QSystemTrayIcon.supportsMessages": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.toolTip": (),
-# class PySide2.QtWidgets.QTabBar:
-# class PySide2.QtWidgets.QTabBar.ButtonPosition:
-# class PySide2.QtWidgets.QTabBar.SelectionBehavior:
-# class PySide2.QtWidgets.QTabBar.Shape:
-    "PySide2.QtWidgets.QTabBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabBar.accessibleTabName": ('int',),
-    "PySide2.QtWidgets.QTabBar.addTab": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QTabBar.autoHide": (),
-    "PySide2.QtWidgets.QTabBar.changeCurrentOnDrag": (),
-    "PySide2.QtWidgets.QTabBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.count": (),
-    "PySide2.QtWidgets.QTabBar.currentIndex": (),
-    "PySide2.QtWidgets.QTabBar.documentMode": (),
-    "PySide2.QtWidgets.QTabBar.drawBase": (),
-    "PySide2.QtWidgets.QTabBar.elideMode": (),
-    "PySide2.QtWidgets.QTabBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.expanding": (),
-    "PySide2.QtWidgets.QTabBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QTabBar.iconSize": (),
-    "PySide2.QtWidgets.QTabBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTab', 'int'),
-    "PySide2.QtWidgets.QTabBar.insertTab": [('int', 'PySide2.QtGui.QIcon', 'str'), ('int', 'str')],
-    "PySide2.QtWidgets.QTabBar.isMovable": (),
-    "PySide2.QtWidgets.QTabBar.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabBar.minimumTabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.moveTab": ('int', 'int'),
-    "PySide2.QtWidgets.QTabBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabBar.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabBar.selectionBehaviorOnRemove": (),
-    "PySide2.QtWidgets.QTabBar.setAccessibleTabName": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setChangeCurrentOnDrag": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabBar.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setDrawBase": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabBar.setExpanding": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setSelectionBehaviorOnRemove": ('PySide2.QtWidgets.QTabBar.SelectionBehavior',),
-    "PySide2.QtWidgets.QTabBar.setShape": ('PySide2.QtWidgets.QTabBar.Shape',),
-    "PySide2.QtWidgets.QTabBar.setTabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTabBar.setTabData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTabBar.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabBar.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabBar.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTabBar.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabBar.shape": (),
-    "PySide2.QtWidgets.QTabBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabBar.sizeHint": (),
-    "PySide2.QtWidgets.QTabBar.tabAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTabBar.tabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition'),
-    "PySide2.QtWidgets.QTabBar.tabData": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabLayoutChange": (),
-    "PySide2.QtWidgets.QTabBar.tabRect": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabText": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabTextColor": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabsClosable": (),
-    "PySide2.QtWidgets.QTabBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTabBar.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QTabWidget:
-# class PySide2.QtWidgets.QTabWidget.TabPosition:
-# class PySide2.QtWidgets.QTabWidget.TabShape:
-    "PySide2.QtWidgets.QTabWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.addTab": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.clear": (),
-    "PySide2.QtWidgets.QTabWidget.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QTabWidget.count": (),
-    "PySide2.QtWidgets.QTabWidget.currentIndex": (),
-    "PySide2.QtWidgets.QTabWidget.currentWidget": (),
-    "PySide2.QtWidgets.QTabWidget.documentMode": (),
-    "PySide2.QtWidgets.QTabWidget.elideMode": (),
-    "PySide2.QtWidgets.QTabWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QTabWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QTabWidget.iconSize": (),
-    "PySide2.QtWidgets.QTabWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',),
-    "PySide2.QtWidgets.QTabWidget.insertTab": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.isMovable": (),
-    "PySide2.QtWidgets.QTabWidget.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabWidget.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabWidget.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QTabWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabWidget.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabWidget.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabBar": ('PySide2.QtWidgets.QTabBar',),
-    "PySide2.QtWidgets.QTabWidget.setTabBarAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabWidget.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabWidget.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QTabWidget.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QTabWidget.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabWidget.sizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.tabBar": (),
-    "PySide2.QtWidgets.QTabWidget.tabBarAutoHide": (),
-    "PySide2.QtWidgets.QTabWidget.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabPosition": (),
-    "PySide2.QtWidgets.QTabWidget.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabShape": (),
-    "PySide2.QtWidgets.QTabWidget.tabText": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabsClosable": (),
-    "PySide2.QtWidgets.QTabWidget.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabWidget.widget": ('int',),
-# class PySide2.QtWidgets.QTableView:
-    "PySide2.QtWidgets.QTableView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTableView.clearSpans": (),
-    "PySide2.QtWidgets.QTableView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTableView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTableView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTableView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTableView.gridStyle": (),
-    "PySide2.QtWidgets.QTableView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.hideRow": ('int',),
-    "PySide2.QtWidgets.QTableView.horizontalHeader": (),
-    "PySide2.QtWidgets.QTableView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTableView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTableView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isCornerButtonEnabled": (),
-    "PySide2.QtWidgets.QTableView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTableView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTableView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeColumnsToContents": (),
-    "PySide2.QtWidgets.QTableView.resizeRowToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeRowsToContents": (),
-    "PySide2.QtWidgets.QTableView.rowAt": ('int',),
-    "PySide2.QtWidgets.QTableView.rowCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowHeight": ('int',),
-    "PySide2.QtWidgets.QTableView.rowMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableView.selectColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.selectRow": ('int',),
-    "PySide2.QtWidgets.QTableView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTableView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTableView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setCornerButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setGridStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtWidgets.QTableView.setHorizontalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.setRowHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTableView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTableView.setShowGrid": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSpan": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.setVerticalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTableView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.showGrid": (),
-    "PySide2.QtWidgets.QTableView.showRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTableView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTableView.updateGeometries": (),
-    "PySide2.QtWidgets.QTableView.verticalHeader": (),
-    "PySide2.QtWidgets.QTableView.verticalOffset": (),
-    "PySide2.QtWidgets.QTableView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.viewOptions": (),
-    "PySide2.QtWidgets.QTableView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTableView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTableView.wordWrap": (),
-# class PySide2.QtWidgets.QTableWidget:
-    "PySide2.QtWidgets.QTableWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTableWidget.cellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.clear": (),
-    "PySide2.QtWidgets.QTableWidget.clearContents": (),
-    "PySide2.QtWidgets.QTableWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.column": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.columnCount": (),
-    "PySide2.QtWidgets.QTableWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTableWidget.currentItem": (),
-    "PySide2.QtWidgets.QTableWidget.currentRow": (),
-    "PySide2.QtWidgets.QTableWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTableWidget.dropMimeData": ('int', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTableWidget.editItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTableWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QTableWidget.horizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.indexFromItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.insertColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.insertRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.isItemSelected": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableWidget.item": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTableWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableWidget.itemPrototype": (),
-    "PySide2.QtWidgets.QTableWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTableWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTableWidgetItem]',),
-    "PySide2.QtWidgets.QTableWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTableWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.removeCellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.removeColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.removeRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.row": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.rowCount": (),
-    "PySide2.QtWidgets.QTableWidget.scrollToItem": ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTableWidget.selectedRanges": (),
-    "PySide2.QtWidgets.QTableWidget.setCellWidget": ('int', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTableWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setCurrentCell": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setCurrentItem": [('PySide2.QtWidgets.QTableWidgetItem',), ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.setItem": ('int', 'int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setItemPrototype": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.setItemSelected": ('PySide2.QtWidgets.QTableWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableWidget.setRangeSelected": ('PySide2.QtWidgets.QTableWidgetSelectionRange', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setRowCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTableWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTableWidget.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.takeItem": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.verticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualItemRect": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.visualRow": ('int',),
-# class PySide2.QtWidgets.QTableWidgetItem:
-# class PySide2.QtWidgets.QTableWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTableWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'int'), ('PySide2.QtWidgets.QTableWidgetItem',), ('int',), ('str', 'int')],
-    "PySide2.QtWidgets.QTableWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.background": (),
-    "PySide2.QtWidgets.QTableWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QTableWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTableWidgetItem.column": (),
-    "PySide2.QtWidgets.QTableWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTableWidgetItem.font": (),
-    "PySide2.QtWidgets.QTableWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QTableWidgetItem.icon": (),
-    "PySide2.QtWidgets.QTableWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTableWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.row": (),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QTableWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTableWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTableWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTableWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTableWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QTableWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.tableWidget": (),
-    "PySide2.QtWidgets.QTableWidgetItem.text": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.type": (),
-    "PySide2.QtWidgets.QTableWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QTableWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTableWidgetSelectionRange:
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__init__": [(), ('PySide2.QtWidgets.QTableWidgetSelectionRange',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__copy__": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.bottomRow": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.columnCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.leftColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rightColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rowCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.topRow": (),
-# class PySide2.QtWidgets.QTapAndHoldGesture:
-    "PySide2.QtWidgets.QTapAndHoldGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.position": (),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setTimeout": ('int',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.timeout": (),
-# class PySide2.QtWidgets.QTapGesture:
-    "PySide2.QtWidgets.QTapGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapGesture.position": (),
-    "PySide2.QtWidgets.QTapGesture.setPosition": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QTextBrowser:
-    "PySide2.QtWidgets.QTextBrowser.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTextBrowser.backward": (),
-    "PySide2.QtWidgets.QTextBrowser.backwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.clearHistory": (),
-    "PySide2.QtWidgets.QTextBrowser.doSetSource": ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType'),
-    "PySide2.QtWidgets.QTextBrowser.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextBrowser.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextBrowser.forward": (),
-    "PySide2.QtWidgets.QTextBrowser.forwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.historyTitle": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.historyUrl": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.home": (),
-    "PySide2.QtWidgets.QTextBrowser.isBackwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.isForwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextBrowser.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextBrowser.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.openExternalLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.openLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextBrowser.reload": (),
-    "PySide2.QtWidgets.QTextBrowser.searchPaths": (),
-    "PySide2.QtWidgets.QTextBrowser.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setOpenLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTextBrowser.setSource": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType')],
-    "PySide2.QtWidgets.QTextBrowser.source": (),
-    "PySide2.QtWidgets.QTextBrowser.sourceType": (),
-# class PySide2.QtWidgets.QTextEdit:
-# class PySide2.QtWidgets.QTextEdit.AutoFormatting:
-# class PySide2.QtWidgets.QTextEdit.AutoFormattingFlag:
-# class PySide2.QtWidgets.QTextEdit.ExtraSelection:
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__init__": [(), ('PySide2.QtWidgets.QTextEdit.ExtraSelection',)],
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__copy__": (),
-# class PySide2.QtWidgets.QTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTextEdit.acceptRichText": (),
-    "PySide2.QtWidgets.QTextEdit.alignment": (),
-    "PySide2.QtWidgets.QTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.append": ('str',),
-    "PySide2.QtWidgets.QTextEdit.autoFormatting": (),
-    "PySide2.QtWidgets.QTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.clear": (),
-    "PySide2.QtWidgets.QTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QTextEdit.copy": (),
-    "PySide2.QtWidgets.QTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QTextEdit.currentFont": (),
-    "PySide2.QtWidgets.QTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QTextEdit.cut": (),
-    "PySide2.QtWidgets.QTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.document": (),
-    "PySide2.QtWidgets.QTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.fontFamily": (),
-    "PySide2.QtWidgets.QTextEdit.fontItalic": (),
-    "PySide2.QtWidgets.QTextEdit.fontPointSize": (),
-    "PySide2.QtWidgets.QTextEdit.fontUnderline": (),
-    "PySide2.QtWidgets.QTextEdit.fontWeight": (),
-    "PySide2.QtWidgets.QTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.insertHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.lineWrapColumnOrWidth": (),
-    "PySide2.QtWidgets.QTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextEdit.paste": (),
-    "PySide2.QtWidgets.QTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QTextEdit.redo": (),
-    "PySide2.QtWidgets.QTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTextEdit.scrollToAnchor": ('str',),
-    "PySide2.QtWidgets.QTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QTextEdit.setAcceptRichText": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QTextEdit.setAutoFormatting": ('PySide2.QtWidgets.QTextEdit.AutoFormatting',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QTextEdit.setFontFamily": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setFontItalic": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontPointSize": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setFontUnderline": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontWeight": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapColumnOrWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QTextEdit.setMarkdown": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setTextBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QTextEdit.textBackgroundColor": (),
-    "PySide2.QtWidgets.QTextEdit.textColor": (),
-    "PySide2.QtWidgets.QTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTextEdit.toHtml": (),
-    "PySide2.QtWidgets.QTextEdit.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtWidgets.QTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QTextEdit.undo": (),
-    "PySide2.QtWidgets.QTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QTileRules:
-    "PySide2.QtWidgets.QTileRules.__init__": [('PySide2.QtCore.Qt.TileRule',), ('PySide2.QtCore.Qt.TileRule', 'PySide2.QtCore.Qt.TileRule'), ('PySide2.QtWidgets.QTileRules',)],
-    "PySide2.QtWidgets.QTileRules.__copy__": (),
-# class PySide2.QtWidgets.QTimeEdit:
-    "PySide2.QtWidgets.QTimeEdit.__init__": [('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QToolBar:
-    "PySide2.QtWidgets.QToolBar.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QToolBar.actionAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QToolBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QToolBar.addSeparator": (),
-    "PySide2.QtWidgets.QToolBar.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBar.allowedAreas": (),
-    "PySide2.QtWidgets.QToolBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.clear": (),
-    "PySide2.QtWidgets.QToolBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.iconSize": (),
-    "PySide2.QtWidgets.QToolBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolBar',),
-    "PySide2.QtWidgets.QToolBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.insertWidget": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QToolBar.isAreaAllowed": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QToolBar.isFloatable": (),
-    "PySide2.QtWidgets.QToolBar.isFloating": (),
-    "PySide2.QtWidgets.QToolBar.isMovable": (),
-    "PySide2.QtWidgets.QToolBar.orientation": (),
-    "PySide2.QtWidgets.QToolBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolBar.setAllowedAreas": ('PySide2.QtCore.Qt.ToolBarAreas',),
-    "PySide2.QtWidgets.QToolBar.setFloatable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QToolBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QToolBar.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolBar.toggleViewAction": (),
-    "PySide2.QtWidgets.QToolBar.toolButtonStyle": (),
-    "PySide2.QtWidgets.QToolBar.widgetForAction": ('PySide2.QtWidgets.QAction',),
-# class PySide2.QtWidgets.QToolBox:
-    "PySide2.QtWidgets.QToolBox.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QToolBox.addItem": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.count": (),
-    "PySide2.QtWidgets.QToolBox.currentIndex": (),
-    "PySide2.QtWidgets.QToolBox.currentWidget": (),
-    "PySide2.QtWidgets.QToolBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.insertItem": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.isItemEnabled": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemInserted": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemRemoved": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemText": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemToolTip": ('int',),
-    "PySide2.QtWidgets.QToolBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.setItemEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QToolBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QToolBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.setItemToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QToolBox.widget": ('int',),
-# class PySide2.QtWidgets.QToolButton:
-# class PySide2.QtWidgets.QToolButton.ToolButtonPopupMode:
-    "PySide2.QtWidgets.QToolButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolButton.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolButton.arrowType": (),
-    "PySide2.QtWidgets.QToolButton.autoRaise": (),
-    "PySide2.QtWidgets.QToolButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.defaultAction": (),
-    "PySide2.QtWidgets.QToolButton.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QToolButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolButton',),
-    "PySide2.QtWidgets.QToolButton.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.menu": (),
-    "PySide2.QtWidgets.QToolButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QToolButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.nextCheckState": (),
-    "PySide2.QtWidgets.QToolButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolButton.popupMode": (),
-    "PySide2.QtWidgets.QToolButton.setArrowType": ('PySide2.QtCore.Qt.ArrowType',),
-    "PySide2.QtWidgets.QToolButton.setAutoRaise": ('bool',),
-    "PySide2.QtWidgets.QToolButton.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QToolButton.setPopupMode": ('PySide2.QtWidgets.QToolButton.ToolButtonPopupMode',),
-    "PySide2.QtWidgets.QToolButton.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolButton.showMenu": (),
-    "PySide2.QtWidgets.QToolButton.sizeHint": (),
-    "PySide2.QtWidgets.QToolButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QToolButton.toolButtonStyle": (),
-# class PySide2.QtWidgets.QToolTip:
-    "PySide2.QtWidgets.QToolTip.font": (),
-    "PySide2.QtWidgets.QToolTip.hideText": (),
-    "PySide2.QtWidgets.QToolTip.isVisible": (),
-    "PySide2.QtWidgets.QToolTip.palette": (),
-    "PySide2.QtWidgets.QToolTip.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QToolTip.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QToolTip.showText": [('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect', 'int')],
-    "PySide2.QtWidgets.QToolTip.text": (),
-# class PySide2.QtWidgets.QTreeView:
-    "PySide2.QtWidgets.QTreeView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeView.allColumnsShowFocus": (),
-    "PySide2.QtWidgets.QTreeView.autoExpandDelay": (),
-    "PySide2.QtWidgets.QTreeView.collapse": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.collapseAll": (),
-    "PySide2.QtWidgets.QTreeView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnMoved": (),
-    "PySide2.QtWidgets.QTreeView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTreeView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QTreeView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTreeView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTreeView.drawBranches": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawRow": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawTree": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QRegion'),
-    "PySide2.QtWidgets.QTreeView.expand": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.expandAll": (),
-    "PySide2.QtWidgets.QTreeView.expandRecursively": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QTreeView.expandToDepth": ('int',),
-    "PySide2.QtWidgets.QTreeView.expandsOnDoubleClick": (),
-    "PySide2.QtWidgets.QTreeView.header": (),
-    "PySide2.QtWidgets.QTreeView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTreeView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTreeView.indentation": (),
-    "PySide2.QtWidgets.QTreeView.indexAbove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTreeView.indexBelow": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexRowSizeHint": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isAnimated": (),
-    "PySide2.QtWidgets.QTreeView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTreeView.isExpanded": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isHeaderHidden": (),
-    "PySide2.QtWidgets.QTreeView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isRowHidden": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTreeView.itemsExpandable": (),
-    "PySide2.QtWidgets.QTreeView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTreeView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QTreeView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTreeView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTreeView.reexpand": (),
-    "PySide2.QtWidgets.QTreeView.reset": (),
-    "PySide2.QtWidgets.QTreeView.resetIndentation": (),
-    "PySide2.QtWidgets.QTreeView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTreeView.rootIsDecorated": (),
-    "PySide2.QtWidgets.QTreeView.rowHeight": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeView.selectAll": (),
-    "PySide2.QtWidgets.QTreeView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTreeView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTreeView.setAllColumnsShowFocus": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAutoExpandDelay": ('int',),
-    "PySide2.QtWidgets.QTreeView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.setExpanded": ('PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setExpandsOnDoubleClick": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTreeView.setHeaderHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setIndentation": ('int',),
-    "PySide2.QtWidgets.QTreeView.setItemsExpandable": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.setRootIsDecorated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setRowHidden": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTreeView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setTreePosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.setUniformRowHeights": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTreeView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTreeView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTreeView.treePosition": (),
-    "PySide2.QtWidgets.QTreeView.uniformRowHeights": (),
-    "PySide2.QtWidgets.QTreeView.updateGeometries": (),
-    "PySide2.QtWidgets.QTreeView.verticalOffset": (),
-    "PySide2.QtWidgets.QTreeView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QTreeView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTreeView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTreeView.wordWrap": (),
-# class PySide2.QtWidgets.QTreeWidget:
-    "PySide2.QtWidgets.QTreeWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItems": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.clear": (),
-    "PySide2.QtWidgets.QTreeWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.collapseItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.currentItem": (),
-    "PySide2.QtWidgets.QTreeWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTreeWidget.dropMimeData": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTreeWidget.editItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeWidget.expandItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.headerItem": (),
-    "PySide2.QtWidgets.QTreeWidget.indexFromItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.indexOfTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItem": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItems": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidget.invisibleRootItem": (),
-    "PySide2.QtWidgets.QTreeWidget.isFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemAbove": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemBelow": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeWidget.itemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTreeWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTreeWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.removeItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.scrollToItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTreeWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.setCurrentItem": [('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTreeWidget.setFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabel": ('str',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTreeWidget.setItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTreeWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeWidget.sortColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTreeWidget.takeTopLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItemCount": (),
-    "PySide2.QtWidgets.QTreeWidget.visualItemRect": ('PySide2.QtWidgets.QTreeWidgetItem',),
-# class PySide2.QtWidgets.QTreeWidgetItem:
-# class PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy:
-# class PySide2.QtWidgets.QTreeWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTreeWidgetItem.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'typing.Sequence[str]', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'typing.Sequence[str]', 'int'), ('int',), ('typing.Sequence[str]', 'int')],
-    "PySide2.QtWidgets.QTreeWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChildren": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidgetItem.background": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.backgroundColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.checkState": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.child": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.childCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.childIndicatorPolicy": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.data": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.emitDataChanged": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.font": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.foreground": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.icon": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.indexOfChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChild": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChildren": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidgetItem.isDisabled": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isExpanded": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isFirstColumnSpanned": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.parent": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.removeChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackgroundColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setCheckState": ('int', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setChildIndicatorPolicy": ('PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setData": ('int', 'int', 'typing.Any'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setExpanded": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFirstColumnSpanned": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFont": ('int', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setForeground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSizeHint": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setStatusTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setText": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextAlignment": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.sizeHint": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidgetItem.statusTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChild": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChildren": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.text": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textAlignment": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.toolTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.treeWidget": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.type": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.whatsThis": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTreeWidgetItemIterator:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlag:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags:
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItemIterator',)],
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__copy__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iadd__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__isub__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iter__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.value": (),
-# class PySide2.QtWidgets.QUndoCommand:
-    "PySide2.QtWidgets.QUndoCommand.__init__": [('PySide2.QtWidgets.QUndoCommand',), ('str', 'PySide2.QtWidgets.QUndoCommand')],
-    "PySide2.QtWidgets.QUndoCommand.actionText": (),
-    "PySide2.QtWidgets.QUndoCommand.child": ('int',),
-    "PySide2.QtWidgets.QUndoCommand.childCount": (),
-    "PySide2.QtWidgets.QUndoCommand.id": (),
-    "PySide2.QtWidgets.QUndoCommand.isObsolete": (),
-    "PySide2.QtWidgets.QUndoCommand.mergeWith": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoCommand.redo": (),
-    "PySide2.QtWidgets.QUndoCommand.setObsolete": ('bool',),
-    "PySide2.QtWidgets.QUndoCommand.setText": ('str',),
-    "PySide2.QtWidgets.QUndoCommand.text": (),
-    "PySide2.QtWidgets.QUndoCommand.undo": (),
-# class PySide2.QtWidgets.QUndoGroup:
-    "PySide2.QtWidgets.QUndoGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoGroup.activeStack": (),
-    "PySide2.QtWidgets.QUndoGroup.addStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.canRedo": (),
-    "PySide2.QtWidgets.QUndoGroup.canUndo": (),
-    "PySide2.QtWidgets.QUndoGroup.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.isClean": (),
-    "PySide2.QtWidgets.QUndoGroup.redo": (),
-    "PySide2.QtWidgets.QUndoGroup.redoText": (),
-    "PySide2.QtWidgets.QUndoGroup.removeStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.setActiveStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.stacks": (),
-    "PySide2.QtWidgets.QUndoGroup.undo": (),
-    "PySide2.QtWidgets.QUndoGroup.undoText": (),
-# class PySide2.QtWidgets.QUndoStack:
-    "PySide2.QtWidgets.QUndoStack.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoStack.beginMacro": ('str',),
-    "PySide2.QtWidgets.QUndoStack.canRedo": (),
-    "PySide2.QtWidgets.QUndoStack.canUndo": (),
-    "PySide2.QtWidgets.QUndoStack.cleanIndex": (),
-    "PySide2.QtWidgets.QUndoStack.clear": (),
-    "PySide2.QtWidgets.QUndoStack.command": ('int',),
-    "PySide2.QtWidgets.QUndoStack.count": (),
-    "PySide2.QtWidgets.QUndoStack.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.endMacro": (),
-    "PySide2.QtWidgets.QUndoStack.index": (),
-    "PySide2.QtWidgets.QUndoStack.isActive": (),
-    "PySide2.QtWidgets.QUndoStack.isClean": (),
-    "PySide2.QtWidgets.QUndoStack.push": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoStack.redo": (),
-    "PySide2.QtWidgets.QUndoStack.redoText": (),
-    "PySide2.QtWidgets.QUndoStack.resetClean": (),
-    "PySide2.QtWidgets.QUndoStack.setActive": ('bool',),
-    "PySide2.QtWidgets.QUndoStack.setClean": (),
-    "PySide2.QtWidgets.QUndoStack.setIndex": ('int',),
-    "PySide2.QtWidgets.QUndoStack.setUndoLimit": ('int',),
-    "PySide2.QtWidgets.QUndoStack.text": ('int',),
-    "PySide2.QtWidgets.QUndoStack.undo": (),
-    "PySide2.QtWidgets.QUndoStack.undoLimit": (),
-    "PySide2.QtWidgets.QUndoStack.undoText": (),
-# class PySide2.QtWidgets.QUndoView:
-    "PySide2.QtWidgets.QUndoView.__init__": [('PySide2.QtWidgets.QUndoGroup', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QUndoStack', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QUndoView.cleanIcon": (),
-    "PySide2.QtWidgets.QUndoView.emptyLabel": (),
-    "PySide2.QtWidgets.QUndoView.group": (),
-    "PySide2.QtWidgets.QUndoView.setCleanIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QUndoView.setEmptyLabel": ('str',),
-    "PySide2.QtWidgets.QUndoView.setGroup": ('PySide2.QtWidgets.QUndoGroup',),
-    "PySide2.QtWidgets.QUndoView.setStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoView.stack": (),
-# class PySide2.QtWidgets.QVBoxLayout:
-    "PySide2.QtWidgets.QVBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QWhatsThis:
-    "PySide2.QtWidgets.QWhatsThis.createAction": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWhatsThis.enterWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.hideText": (),
-    "PySide2.QtWidgets.QWhatsThis.inWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.leaveWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.showText": ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'),
-# class PySide2.QtWidgets.QWidget:
-# class PySide2.QtWidgets.QWidget.RenderFlag:
-# class PySide2.QtWidgets.QWidget.RenderFlags:
-    "PySide2.QtWidgets.QWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.acceptDrops": (),
-    "PySide2.QtWidgets.QWidget.accessibleDescription": (),
-    "PySide2.QtWidgets.QWidget.accessibleName": (),
-    "PySide2.QtWidgets.QWidget.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QWidget.actions": (),
-    "PySide2.QtWidgets.QWidget.activateWindow": (),
-    "PySide2.QtWidgets.QWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QWidget.adjustSize": (),
-    "PySide2.QtWidgets.QWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QWidget.backgroundRole": (),
-    "PySide2.QtWidgets.QWidget.backingStore": (),
-    "PySide2.QtWidgets.QWidget.baseSize": (),
-    "PySide2.QtWidgets.QWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.childAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.childrenRect": (),
-    "PySide2.QtWidgets.QWidget.childrenRegion": (),
-    "PySide2.QtWidgets.QWidget.clearFocus": (),
-    "PySide2.QtWidgets.QWidget.clearMask": (),
-    "PySide2.QtWidgets.QWidget.close": (),
-    "PySide2.QtWidgets.QWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QWidget.contentsMargins": (),
-    "PySide2.QtWidgets.QWidget.contentsRect": (),
-    "PySide2.QtWidgets.QWidget.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QWidget.contextMenuPolicy": (),
-    "PySide2.QtWidgets.QWidget.create": ('int', 'bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.createWinId": (),
-    "PySide2.QtWidgets.QWidget.createWindowContainer": ('PySide2.QtGui.QWindow', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.cursor": (),
-    "PySide2.QtWidgets.QWidget.destroy": ('bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.devType": (),
-    "PySide2.QtWidgets.QWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QWidget.effectiveWinId": (),
-    "PySide2.QtWidgets.QWidget.ensurePolished": (),
-    "PySide2.QtWidgets.QWidget.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.find": ('int',),
-    "PySide2.QtWidgets.QWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusNextChild": (),
-    "PySide2.QtWidgets.QWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QWidget.focusPreviousChild": (),
-    "PySide2.QtWidgets.QWidget.focusProxy": (),
-    "PySide2.QtWidgets.QWidget.focusWidget": (),
-    "PySide2.QtWidgets.QWidget.font": (),
-    "PySide2.QtWidgets.QWidget.fontInfo": (),
-    "PySide2.QtWidgets.QWidget.fontMetrics": (),
-    "PySide2.QtWidgets.QWidget.foregroundRole": (),
-    "PySide2.QtWidgets.QWidget.frameGeometry": (),
-    "PySide2.QtWidgets.QWidget.frameSize": (),
-    "PySide2.QtWidgets.QWidget.geometry": (),
-    "PySide2.QtWidgets.QWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QWidget.grab": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidget.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QWidget.grabKeyboard": (),
-    "PySide2.QtWidgets.QWidget.grabMouse": [(), ('PySide2.QtGui.QCursor',)],
-    "PySide2.QtWidgets.QWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QWidget.graphicsEffect": (),
-    "PySide2.QtWidgets.QWidget.graphicsProxyWidget": (),
-    "PySide2.QtWidgets.QWidget.hasFocus": (),
-    "PySide2.QtWidgets.QWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidget.hasMouseTracking": (),
-    "PySide2.QtWidgets.QWidget.hasTabletTracking": (),
-    "PySide2.QtWidgets.QWidget.height": (),
-    "PySide2.QtWidgets.QWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.hide": (),
-    "PySide2.QtWidgets.QWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QWidget.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QWidget.inputMethodHints": (),
-    "PySide2.QtWidgets.QWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QWidget.internalWinId": (),
-    "PySide2.QtWidgets.QWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QWidget.isAncestorOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabled": (),
-    "PySide2.QtWidgets.QWidget.isEnabledTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabledToTLW": (),
-    "PySide2.QtWidgets.QWidget.isFullScreen": (),
-    "PySide2.QtWidgets.QWidget.isHidden": (),
-    "PySide2.QtWidgets.QWidget.isLeftToRight": (),
-    "PySide2.QtWidgets.QWidget.isMaximized": (),
-    "PySide2.QtWidgets.QWidget.isMinimized": (),
-    "PySide2.QtWidgets.QWidget.isModal": (),
-    "PySide2.QtWidgets.QWidget.isRightToLeft": (),
-    "PySide2.QtWidgets.QWidget.isTopLevel": (),
-    "PySide2.QtWidgets.QWidget.isVisible": (),
-    "PySide2.QtWidgets.QWidget.isVisibleTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isWindow": (),
-    "PySide2.QtWidgets.QWidget.isWindowModified": (),
-    "PySide2.QtWidgets.QWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyboardGrabber": (),
-    "PySide2.QtWidgets.QWidget.layout": (),
-    "PySide2.QtWidgets.QWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QWidget.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.locale": (),
-    "PySide2.QtWidgets.QWidget.lower": (),
-    "PySide2.QtWidgets.QWidget.mapFrom": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapFromParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapTo": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapToParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mask": (),
-    "PySide2.QtWidgets.QWidget.maximumHeight": (),
-    "PySide2.QtWidgets.QWidget.maximumSize": (),
-    "PySide2.QtWidgets.QWidget.maximumWidth": (),
-    "PySide2.QtWidgets.QWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QWidget.minimumHeight": (),
-    "PySide2.QtWidgets.QWidget.minimumSize": (),
-    "PySide2.QtWidgets.QWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QWidget.minimumWidth": (),
-    "PySide2.QtWidgets.QWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseGrabber": (),
-    "PySide2.QtWidgets.QWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QWidget.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QWidget.nativeParentWidget": (),
-    "PySide2.QtWidgets.QWidget.nextInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.normalGeometry": (),
-    "PySide2.QtWidgets.QWidget.overrideWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.overrideWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.paintEngine": (),
-    "PySide2.QtWidgets.QWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWidget.palette": (),
-    "PySide2.QtWidgets.QWidget.parentWidget": (),
-    "PySide2.QtWidgets.QWidget.pos": (),
-    "PySide2.QtWidgets.QWidget.previousInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.raise_": (),
-    "PySide2.QtWidgets.QWidget.rect": (),
-    "PySide2.QtWidgets.QWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.releaseKeyboard": (),
-    "PySide2.QtWidgets.QWidget.releaseMouse": (),
-    "PySide2.QtWidgets.QWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags')],
-    "PySide2.QtWidgets.QWidget.repaint": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWidget.restoreGeometry": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QWidget.saveGeometry": (),
-    "PySide2.QtWidgets.QWidget.screen": (),
-    "PySide2.QtWidgets.QWidget.scroll": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QRect')],
-    "PySide2.QtWidgets.QWidget.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QWidget.setAccessibleDescription": ('str',),
-    "PySide2.QtWidgets.QWidget.setAccessibleName": ('str',),
-    "PySide2.QtWidgets.QWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QWidget.setBackgroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setBaseSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContextMenuPolicy": ('PySide2.QtCore.Qt.ContextMenuPolicy',),
-    "PySide2.QtWidgets.QWidget.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QWidget.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setFixedHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setFixedSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setFixedWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtWidgets.QWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QWidget.setFocusProxy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QWidget.setForegroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QWidget.setHidden": ('bool',),
-    "PySide2.QtWidgets.QWidget.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QWidget.setLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QWidget.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtWidgets.QWidget.setMask": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtWidgets.QWidget.setMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMaximumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMouseTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QWidget.setParent": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setSizeIncrement": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy')],
-    "PySide2.QtWidgets.QWidget.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QWidget.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QWidget.setTabOrder": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QWidget.setTabletTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setToolTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setToolTipDuration": ('int',),
-    "PySide2.QtWidgets.QWidget.setUpdatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFilePath": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtWidgets.QWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QWidget.setWindowIconText": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QWidget.setWindowModified": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWindowOpacity": ('float',),
-    "PySide2.QtWidgets.QWidget.setWindowRole": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QWidget.sharedPainter": (),
-    "PySide2.QtWidgets.QWidget.show": (),
-    "PySide2.QtWidgets.QWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QWidget.showFullScreen": (),
-    "PySide2.QtWidgets.QWidget.showMaximized": (),
-    "PySide2.QtWidgets.QWidget.showMinimized": (),
-    "PySide2.QtWidgets.QWidget.showNormal": (),
-    "PySide2.QtWidgets.QWidget.size": (),
-    "PySide2.QtWidgets.QWidget.sizeHint": (),
-    "PySide2.QtWidgets.QWidget.sizeIncrement": (),
-    "PySide2.QtWidgets.QWidget.sizePolicy": (),
-    "PySide2.QtWidgets.QWidget.stackUnder": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.statusTip": (),
-    "PySide2.QtWidgets.QWidget.style": (),
-    "PySide2.QtWidgets.QWidget.styleSheet": (),
-    "PySide2.QtWidgets.QWidget.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtWidgets.QWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QWidget.toolTip": (),
-    "PySide2.QtWidgets.QWidget.toolTipDuration": (),
-    "PySide2.QtWidgets.QWidget.topLevelWidget": (),
-    "PySide2.QtWidgets.QWidget.underMouse": (),
-    "PySide2.QtWidgets.QWidget.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QWidget.unsetCursor": (),
-    "PySide2.QtWidgets.QWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QWidget.unsetLocale": (),
-    "PySide2.QtWidgets.QWidget.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QWidget.updateMicroFocus": (),
-    "PySide2.QtWidgets.QWidget.updatesEnabled": (),
-    "PySide2.QtWidgets.QWidget.visibleRegion": (),
-    "PySide2.QtWidgets.QWidget.whatsThis": (),
-    "PySide2.QtWidgets.QWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QWidget.width": (),
-    "PySide2.QtWidgets.QWidget.winId": (),
-    "PySide2.QtWidgets.QWidget.window": (),
-    "PySide2.QtWidgets.QWidget.windowFilePath": (),
-    "PySide2.QtWidgets.QWidget.windowFlags": (),
-    "PySide2.QtWidgets.QWidget.windowHandle": (),
-    "PySide2.QtWidgets.QWidget.windowIcon": (),
-    "PySide2.QtWidgets.QWidget.windowIconText": (),
-    "PySide2.QtWidgets.QWidget.windowModality": (),
-    "PySide2.QtWidgets.QWidget.windowOpacity": (),
-    "PySide2.QtWidgets.QWidget.windowRole": (),
-    "PySide2.QtWidgets.QWidget.windowState": (),
-    "PySide2.QtWidgets.QWidget.windowTitle": (),
-    "PySide2.QtWidgets.QWidget.windowType": (),
-    "PySide2.QtWidgets.QWidget.x": (),
-    "PySide2.QtWidgets.QWidget.y": (),
-# class PySide2.QtWidgets.QWidgetAction:
-    "PySide2.QtWidgets.QWidgetAction.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWidgetAction.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.createdWidgets": (),
-    "PySide2.QtWidgets.QWidgetAction.defaultWidget": (),
-    "PySide2.QtWidgets.QWidgetAction.deleteWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidgetAction.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QWidgetAction.releaseWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.requestWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.setDefaultWidget": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QWidgetItem:
-    "PySide2.QtWidgets.QWidgetItem.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetItem.controlTypes": (),
-    "PySide2.QtWidgets.QWidgetItem.expandingDirections": (),
-    "PySide2.QtWidgets.QWidgetItem.geometry": (),
-    "PySide2.QtWidgets.QWidgetItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidgetItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidgetItem.isEmpty": (),
-    "PySide2.QtWidgets.QWidgetItem.maximumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.minimumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QWidgetItem.widget": (),
-# class PySide2.QtWidgets.QWizard:
-# class PySide2.QtWidgets.QWizard.WizardButton:
-# class PySide2.QtWidgets.QWizard.WizardOption:
-# class PySide2.QtWidgets.QWizard.WizardOptions:
-# class PySide2.QtWidgets.QWizard.WizardPixmap:
-# class PySide2.QtWidgets.QWizard.WizardStyle:
-    "PySide2.QtWidgets.QWizard.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWizard.addPage": ('PySide2.QtWidgets.QWizardPage',),
-    "PySide2.QtWidgets.QWizard.back": (),
-    "PySide2.QtWidgets.QWizard.button": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.cleanupPage": ('int',),
-    "PySide2.QtWidgets.QWizard.currentId": (),
-    "PySide2.QtWidgets.QWizard.currentPage": (),
-    "PySide2.QtWidgets.QWizard.done": ('int',),
-    "PySide2.QtWidgets.QWizard.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWizard.field": ('str',),
-    "PySide2.QtWidgets.QWizard.hasVisitedPage": ('int',),
-    "PySide2.QtWidgets.QWizard.initializePage": ('int',),
-    "PySide2.QtWidgets.QWizard.nextId": (),
-    "PySide2.QtWidgets.QWizard.options": (),
-    "PySide2.QtWidgets.QWizard.page": ('int',),
-    "PySide2.QtWidgets.QWizard.pageIds": (),
-    "PySide2.QtWidgets.QWizard.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWizard.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizard.removePage": ('int',),
-    "PySide2.QtWidgets.QWizard.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWizard.restart": (),
-    "PySide2.QtWidgets.QWizard.setButton": ('PySide2.QtWidgets.QWizard.WizardButton', 'PySide2.QtWidgets.QAbstractButton'),
-    "PySide2.QtWidgets.QWizard.setButtonLayout": ('typing.Sequence[PySide2.QtWidgets.QWizard.WizardButton]',),
-    "PySide2.QtWidgets.QWizard.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizard.setDefaultProperty": ('str', 'str', 'str'),
-    "PySide2.QtWidgets.QWizard.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizard.setOption": ('PySide2.QtWidgets.QWizard.WizardOption', 'bool'),
-    "PySide2.QtWidgets.QWizard.setOptions": ('PySide2.QtWidgets.QWizard.WizardOptions',),
-    "PySide2.QtWidgets.QWizard.setPage": ('int', 'PySide2.QtWidgets.QWizardPage'),
-    "PySide2.QtWidgets.QWizard.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizard.setSideWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizard.setStartId": ('int',),
-    "PySide2.QtWidgets.QWizard.setSubTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWizard.setWizardStyle": ('PySide2.QtWidgets.QWizard.WizardStyle',),
-    "PySide2.QtWidgets.QWizard.sideWidget": (),
-    "PySide2.QtWidgets.QWizard.sizeHint": (),
-    "PySide2.QtWidgets.QWizard.startId": (),
-    "PySide2.QtWidgets.QWizard.subTitleFormat": (),
-    "PySide2.QtWidgets.QWizard.testOption": ('PySide2.QtWidgets.QWizard.WizardOption',),
-    "PySide2.QtWidgets.QWizard.titleFormat": (),
-    "PySide2.QtWidgets.QWizard.validateCurrentPage": (),
-    "PySide2.QtWidgets.QWizard.visitedPages": (),
-    "PySide2.QtWidgets.QWizard.wizardStyle": (),
-# class PySide2.QtWidgets.QWizardPage:
-    "PySide2.QtWidgets.QWizardPage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizardPage.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizardPage.cleanupPage": (),
-    "PySide2.QtWidgets.QWizardPage.field": ('str',),
-    "PySide2.QtWidgets.QWizardPage.initializePage": (),
-    "PySide2.QtWidgets.QWizardPage.isCommitPage": (),
-    "PySide2.QtWidgets.QWizardPage.isComplete": (),
-    "PySide2.QtWidgets.QWizardPage.isFinalPage": (),
-    "PySide2.QtWidgets.QWizardPage.nextId": (),
-    "PySide2.QtWidgets.QWizardPage.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizardPage.registerField": ('str', 'PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setCommitPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizardPage.setFinalPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizardPage.setSubTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.setTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.subTitle": (),
-    "PySide2.QtWidgets.QWizardPage.title": (),
-    "PySide2.QtWidgets.QWizardPage.validatePage": (),
-    "PySide2.QtWidgets.QWizardPage.wizard": (),
-    }) if "PySide2.QtWidgets" in sys.modules else None
-# Module PySide2.QtPrintSupport
-sig_dict.update({
-# class PySide2.QtPrintSupport.QAbstractPrintDialog:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange:
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.__init__": ('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.addEnabledOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.enabledOptions": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.fromPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.isOptionEnabled": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.maxPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.minPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printRange": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printer": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setEnabledOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setMinMax": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setOptionTabs": ('typing.Sequence[PySide2.QtWidgets.QWidget]',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setPrintRange": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.toPage": (),
-# class PySide2.QtPrintSupport.QPageSetupDialog:
-    "PySide2.QtPrintSupport.QPageSetupDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPageSetupDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPageSetupDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPageSetupDialog.printer": (),
-# class PySide2.QtPrintSupport.QPrintDialog:
-    "PySide2.QtPrintSupport.QPrintDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPrintDialog.accept": (),
-    "PySide2.QtPrintSupport.QPrintDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPrintDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintDialog.options": (),
-    "PySide2.QtPrintSupport.QPrintDialog.setOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption', 'bool'),
-    "PySide2.QtPrintSupport.QPrintDialog.setOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QPrintDialog.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintDialog.testOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-# class PySide2.QtPrintSupport.QPrintEngine:
-# class PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey:
-    "PySide2.QtPrintSupport.QPrintEngine.__init__": (),
-    "PySide2.QtPrintSupport.QPrintEngine.abort": (),
-    "PySide2.QtPrintSupport.QPrintEngine.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrintEngine.newPage": (),
-    "PySide2.QtPrintSupport.QPrintEngine.printerState": (),
-    "PySide2.QtPrintSupport.QPrintEngine.property": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey',),
-    "PySide2.QtPrintSupport.QPrintEngine.setProperty": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey', 'typing.Any'),
-# class PySide2.QtPrintSupport.QPrintPreviewDialog:
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.printer": (),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintPreviewWidget:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode:
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.currentPage": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitInView": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitToWidth": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.orientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.pageCount": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.print_": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setAllPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setCurrentPage": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setFacingPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setLandscapeOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setPortraitOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setSinglePageViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setViewMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomFactor": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.updatePreview": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.viewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomFactor": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomIn": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomOut": ('float',),
-# class PySide2.QtPrintSupport.QPrinter:
-# class PySide2.QtPrintSupport.QPrinter.ColorMode:
-# class PySide2.QtPrintSupport.QPrinter.DuplexMode:
-# class PySide2.QtPrintSupport.QPrinter.Orientation:
-# class PySide2.QtPrintSupport.QPrinter.OutputFormat:
-# class PySide2.QtPrintSupport.QPrinter.PageOrder:
-# class PySide2.QtPrintSupport.QPrinter.PaperSource:
-# class PySide2.QtPrintSupport.QPrinter.PrintRange:
-# class PySide2.QtPrintSupport.QPrinter.PrinterMode:
-# class PySide2.QtPrintSupport.QPrinter.PrinterState:
-# class PySide2.QtPrintSupport.QPrinter.Unit:
-    "PySide2.QtPrintSupport.QPrinter.__init__": [('PySide2.QtPrintSupport.QPrinter.PrinterMode',), ('PySide2.QtPrintSupport.QPrinterInfo', 'PySide2.QtPrintSupport.QPrinter.PrinterMode')],
-    "PySide2.QtPrintSupport.QPrinter.abort": (),
-    "PySide2.QtPrintSupport.QPrinter.actualNumCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.collateCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.colorMode": (),
-    "PySide2.QtPrintSupport.QPrinter.copyCount": (),
-    "PySide2.QtPrintSupport.QPrinter.creator": (),
-    "PySide2.QtPrintSupport.QPrinter.devType": (),
-    "PySide2.QtPrintSupport.QPrinter.docName": (),
-    "PySide2.QtPrintSupport.QPrinter.doubleSidedPrinting": (),
-    "PySide2.QtPrintSupport.QPrinter.duplex": (),
-    "PySide2.QtPrintSupport.QPrinter.fontEmbeddingEnabled": (),
-    "PySide2.QtPrintSupport.QPrinter.fromPage": (),
-    "PySide2.QtPrintSupport.QPrinter.fullPage": (),
-    "PySide2.QtPrintSupport.QPrinter.getPageMargins": ('PySide2.QtPrintSupport.QPrinter.Unit',),
-    "PySide2.QtPrintSupport.QPrinter.isValid": (),
-    "PySide2.QtPrintSupport.QPrinter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrinter.newPage": (),
-    "PySide2.QtPrintSupport.QPrinter.numCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.orientation": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFileName": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFormat": (),
-    "PySide2.QtPrintSupport.QPrinter.pageOrder": (),
-    "PySide2.QtPrintSupport.QPrinter.pageRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.pageSize": (),
-    "PySide2.QtPrintSupport.QPrinter.paintEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.paperName": (),
-    "PySide2.QtPrintSupport.QPrinter.paperRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSize": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSource": (),
-    "PySide2.QtPrintSupport.QPrinter.pdfVersion": (),
-    "PySide2.QtPrintSupport.QPrinter.printEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.printProgram": (),
-    "PySide2.QtPrintSupport.QPrinter.printRange": (),
-    "PySide2.QtPrintSupport.QPrinter.printerName": (),
-    "PySide2.QtPrintSupport.QPrinter.printerState": (),
-    "PySide2.QtPrintSupport.QPrinter.resolution": (),
-    "PySide2.QtPrintSupport.QPrinter.setCollateCopies": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setColorMode": ('PySide2.QtPrintSupport.QPrinter.ColorMode',),
-    "PySide2.QtPrintSupport.QPrinter.setCopyCount": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setCreator": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDocName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDoubleSidedPrinting": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setDuplex": ('PySide2.QtPrintSupport.QPrinter.DuplexMode',),
-    "PySide2.QtPrintSupport.QPrinter.setEngines": ('PySide2.QtPrintSupport.QPrintEngine', 'PySide2.QtGui.QPaintEngine'),
-    "PySide2.QtPrintSupport.QPrinter.setFontEmbeddingEnabled": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QPrinter.setFullPage": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtPrintSupport.QPrinter.setNumCopies": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFileName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFormat": ('PySide2.QtPrintSupport.QPrinter.OutputFormat',),
-    "PySide2.QtPrintSupport.QPrinter.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float', 'PySide2.QtPrintSupport.QPrinter.Unit')],
-    "PySide2.QtPrintSupport.QPrinter.setPageOrder": ('PySide2.QtPrintSupport.QPrinter.PageOrder',),
-    "PySide2.QtPrintSupport.QPrinter.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperSize": [('PySide2.QtCore.QSizeF', 'PySide2.QtPrintSupport.QPrinter.Unit'), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPaperSource": ('PySide2.QtPrintSupport.QPrinter.PaperSource',),
-    "PySide2.QtPrintSupport.QPrinter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintProgram": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintRange": ('PySide2.QtPrintSupport.QPrinter.PrintRange',),
-    "PySide2.QtPrintSupport.QPrinter.setPrinterName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setResolution": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setWinPageSize": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinter.supportsMultipleCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.toPage": (),
-    "PySide2.QtPrintSupport.QPrinter.winPageSize": (),
-# class PySide2.QtPrintSupport.QPrinterInfo:
-    "PySide2.QtPrintSupport.QPrinterInfo.__init__": [(), ('PySide2.QtPrintSupport.QPrinter',), ('PySide2.QtPrintSupport.QPrinterInfo',)],
-    "PySide2.QtPrintSupport.QPrinterInfo.__copy__": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinterNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinters": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultColorMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultDuplexMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinter": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinterName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.description": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isDefault": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isNull": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isRemote": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.location": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.makeAndModel": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.maximumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.minimumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerInfo": ('str',),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.state": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedColorModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedDuplexModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPageSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPaperSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedSizesWithNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportsCustomPageSizes": (),
-    }) if "PySide2.QtPrintSupport" in sys.modules else None
-# Module PySide2.QtSql
-sig_dict.update({
-# class PySide2.QtSql.QSql:
-# class PySide2.QtSql.QSql.Location:
-# class PySide2.QtSql.QSql.NumericalPrecisionPolicy:
-# class PySide2.QtSql.QSql.ParamType:
-# class PySide2.QtSql.QSql.ParamTypeFlag:
-# class PySide2.QtSql.QSql.TableType:
-# class PySide2.QtSql.QSqlDatabase:
-    "PySide2.QtSql.QSqlDatabase.__init__": [(), ('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlDriver',), ('str',)],
-    "PySide2.QtSql.QSqlDatabase.__copy__": (),
-    "PySide2.QtSql.QSqlDatabase.addDatabase": [('PySide2.QtSql.QSqlDriver', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.cloneDatabase": [('PySide2.QtSql.QSqlDatabase', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.close": (),
-    "PySide2.QtSql.QSqlDatabase.commit": (),
-    "PySide2.QtSql.QSqlDatabase.connectOptions": (),
-    "PySide2.QtSql.QSqlDatabase.connectionName": (),
-    "PySide2.QtSql.QSqlDatabase.connectionNames": (),
-    "PySide2.QtSql.QSqlDatabase.contains": ('str',),
-    "PySide2.QtSql.QSqlDatabase.database": ('str', 'bool'),
-    "PySide2.QtSql.QSqlDatabase.databaseName": (),
-    "PySide2.QtSql.QSqlDatabase.driver": (),
-    "PySide2.QtSql.QSqlDatabase.driverName": (),
-    "PySide2.QtSql.QSqlDatabase.drivers": (),
-    "PySide2.QtSql.QSqlDatabase.exec_": ('str',),
-    "PySide2.QtSql.QSqlDatabase.hostName": (),
-    "PySide2.QtSql.QSqlDatabase.isDriverAvailable": ('str',),
-    "PySide2.QtSql.QSqlDatabase.isOpen": (),
-    "PySide2.QtSql.QSqlDatabase.isOpenError": (),
-    "PySide2.QtSql.QSqlDatabase.isValid": (),
-    "PySide2.QtSql.QSqlDatabase.lastError": (),
-    "PySide2.QtSql.QSqlDatabase.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDatabase.open": [(), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.password": (),
-    "PySide2.QtSql.QSqlDatabase.port": (),
-    "PySide2.QtSql.QSqlDatabase.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDatabase.record": ('str',),
-    "PySide2.QtSql.QSqlDatabase.registerSqlDriver": ('str', 'PySide2.QtSql.QSqlDriverCreatorBase'),
-    "PySide2.QtSql.QSqlDatabase.removeDatabase": ('str',),
-    "PySide2.QtSql.QSqlDatabase.rollback": (),
-    "PySide2.QtSql.QSqlDatabase.setConnectOptions": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setDatabaseName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setHostName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDatabase.setPassword": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setPort": ('int',),
-    "PySide2.QtSql.QSqlDatabase.setUserName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDatabase.transaction": (),
-    "PySide2.QtSql.QSqlDatabase.userName": (),
-# class PySide2.QtSql.QSqlDriver:
-# class PySide2.QtSql.QSqlDriver.DbmsType:
-# class PySide2.QtSql.QSqlDriver.DriverFeature:
-# class PySide2.QtSql.QSqlDriver.IdentifierType:
-# class PySide2.QtSql.QSqlDriver.NotificationSource:
-# class PySide2.QtSql.QSqlDriver.StatementType:
-    "PySide2.QtSql.QSqlDriver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlDriver.beginTransaction": (),
-    "PySide2.QtSql.QSqlDriver.cancelQuery": (),
-    "PySide2.QtSql.QSqlDriver.close": (),
-    "PySide2.QtSql.QSqlDriver.commitTransaction": (),
-    "PySide2.QtSql.QSqlDriver.createResult": (),
-    "PySide2.QtSql.QSqlDriver.dbmsType": (),
-    "PySide2.QtSql.QSqlDriver.escapeIdentifier": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.formatValue": ('PySide2.QtSql.QSqlField', 'bool'),
-    "PySide2.QtSql.QSqlDriver.hasFeature": ('PySide2.QtSql.QSqlDriver.DriverFeature',),
-    "PySide2.QtSql.QSqlDriver.isIdentifierEscaped": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.isOpen": (),
-    "PySide2.QtSql.QSqlDriver.isOpenError": (),
-    "PySide2.QtSql.QSqlDriver.lastError": (),
-    "PySide2.QtSql.QSqlDriver.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDriver.open": ('str', 'str', 'str', 'str', 'int', 'str'),
-    "PySide2.QtSql.QSqlDriver.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDriver.record": ('str',),
-    "PySide2.QtSql.QSqlDriver.rollbackTransaction": (),
-    "PySide2.QtSql.QSqlDriver.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlDriver.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDriver.setOpen": ('bool',),
-    "PySide2.QtSql.QSqlDriver.setOpenError": ('bool',),
-    "PySide2.QtSql.QSqlDriver.sqlStatement": ('PySide2.QtSql.QSqlDriver.StatementType', 'str', 'PySide2.QtSql.QSqlRecord', 'bool'),
-    "PySide2.QtSql.QSqlDriver.stripDelimiters": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.subscribeToNotification": ('str',),
-    "PySide2.QtSql.QSqlDriver.subscribedToNotifications": (),
-    "PySide2.QtSql.QSqlDriver.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDriver.unsubscribeFromNotification": ('str',),
-# class PySide2.QtSql.QSqlDriverCreatorBase:
-    "PySide2.QtSql.QSqlDriverCreatorBase.__init__": (),
-    "PySide2.QtSql.QSqlDriverCreatorBase.createObject": (),
-# class PySide2.QtSql.QSqlError:
-# class PySide2.QtSql.QSqlError.ErrorType:
-    "PySide2.QtSql.QSqlError.__init__": [('PySide2.QtSql.QSqlError',), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'int'), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'str')],
-    "PySide2.QtSql.QSqlError.__copy__": (),
-    "PySide2.QtSql.QSqlError.databaseText": (),
-    "PySide2.QtSql.QSqlError.driverText": (),
-    "PySide2.QtSql.QSqlError.isValid": (),
-    "PySide2.QtSql.QSqlError.nativeErrorCode": (),
-    "PySide2.QtSql.QSqlError.number": (),
-    "PySide2.QtSql.QSqlError.setDatabaseText": ('str',),
-    "PySide2.QtSql.QSqlError.setDriverText": ('str',),
-    "PySide2.QtSql.QSqlError.setNumber": ('int',),
-    "PySide2.QtSql.QSqlError.setType": ('PySide2.QtSql.QSqlError.ErrorType',),
-    "PySide2.QtSql.QSqlError.swap": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlError.text": (),
-    "PySide2.QtSql.QSqlError.type": (),
-# class PySide2.QtSql.QSqlField:
-# class PySide2.QtSql.QSqlField.RequiredStatus:
-    "PySide2.QtSql.QSqlField.__init__": [('PySide2.QtSql.QSqlField',), ('str', 'type'), ('str', 'type', 'str')],
-    "PySide2.QtSql.QSqlField.__copy__": (),
-    "PySide2.QtSql.QSqlField.clear": (),
-    "PySide2.QtSql.QSqlField.defaultValue": (),
-    "PySide2.QtSql.QSqlField.isAutoValue": (),
-    "PySide2.QtSql.QSqlField.isGenerated": (),
-    "PySide2.QtSql.QSqlField.isNull": (),
-    "PySide2.QtSql.QSqlField.isReadOnly": (),
-    "PySide2.QtSql.QSqlField.isValid": (),
-    "PySide2.QtSql.QSqlField.length": (),
-    "PySide2.QtSql.QSqlField.name": (),
-    "PySide2.QtSql.QSqlField.precision": (),
-    "PySide2.QtSql.QSqlField.requiredStatus": (),
-    "PySide2.QtSql.QSqlField.setAutoValue": ('bool',),
-    "PySide2.QtSql.QSqlField.setDefaultValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.setGenerated": ('bool',),
-    "PySide2.QtSql.QSqlField.setLength": ('int',),
-    "PySide2.QtSql.QSqlField.setName": ('str',),
-    "PySide2.QtSql.QSqlField.setPrecision": ('int',),
-    "PySide2.QtSql.QSqlField.setReadOnly": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequired": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequiredStatus": ('PySide2.QtSql.QSqlField.RequiredStatus',),
-    "PySide2.QtSql.QSqlField.setSqlType": ('int',),
-    "PySide2.QtSql.QSqlField.setTableName": ('str',),
-    "PySide2.QtSql.QSqlField.setType": ('type',),
-    "PySide2.QtSql.QSqlField.setValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.tableName": (),
-    "PySide2.QtSql.QSqlField.type": (),
-    "PySide2.QtSql.QSqlField.typeID": (),
-    "PySide2.QtSql.QSqlField.value": (),
-# class PySide2.QtSql.QSqlIndex:
-    "PySide2.QtSql.QSqlIndex.__init__": [('PySide2.QtSql.QSqlIndex',), ('str', 'str')],
-    "PySide2.QtSql.QSqlIndex.__copy__": (),
-    "PySide2.QtSql.QSqlIndex.append": [('PySide2.QtSql.QSqlField',), ('PySide2.QtSql.QSqlField', 'bool')],
-    "PySide2.QtSql.QSqlIndex.cursorName": (),
-    "PySide2.QtSql.QSqlIndex.isDescending": ('int',),
-    "PySide2.QtSql.QSqlIndex.name": (),
-    "PySide2.QtSql.QSqlIndex.setCursorName": ('str',),
-    "PySide2.QtSql.QSqlIndex.setDescending": ('int', 'bool'),
-    "PySide2.QtSql.QSqlIndex.setName": ('str',),
-# class PySide2.QtSql.QSqlQuery:
-# class PySide2.QtSql.QSqlQuery.BatchExecutionMode:
-    "PySide2.QtSql.QSqlQuery.__init__": [('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlQuery',), ('PySide2.QtSql.QSqlResult',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-    "PySide2.QtSql.QSqlQuery.__copy__": (),
-    "PySide2.QtSql.QSqlQuery.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlQuery.at": (),
-    "PySide2.QtSql.QSqlQuery.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlQuery.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.boundValues": (),
-    "PySide2.QtSql.QSqlQuery.clear": (),
-    "PySide2.QtSql.QSqlQuery.driver": (),
-    "PySide2.QtSql.QSqlQuery.execBatch": ('PySide2.QtSql.QSqlQuery.BatchExecutionMode',),
-    "PySide2.QtSql.QSqlQuery.exec_": [(), ('str',)],
-    "PySide2.QtSql.QSqlQuery.executedQuery": (),
-    "PySide2.QtSql.QSqlQuery.finish": (),
-    "PySide2.QtSql.QSqlQuery.first": (),
-    "PySide2.QtSql.QSqlQuery.isActive": (),
-    "PySide2.QtSql.QSqlQuery.isForwardOnly": (),
-    "PySide2.QtSql.QSqlQuery.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.isSelect": (),
-    "PySide2.QtSql.QSqlQuery.isValid": (),
-    "PySide2.QtSql.QSqlQuery.last": (),
-    "PySide2.QtSql.QSqlQuery.lastError": (),
-    "PySide2.QtSql.QSqlQuery.lastInsertId": (),
-    "PySide2.QtSql.QSqlQuery.lastQuery": (),
-    "PySide2.QtSql.QSqlQuery.nextResult": (),
-    "PySide2.QtSql.QSqlQuery.numRowsAffected": (),
-    "PySide2.QtSql.QSqlQuery.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlQuery.prepare": ('str',),
-    "PySide2.QtSql.QSqlQuery.previous": (),
-    "PySide2.QtSql.QSqlQuery.record": (),
-    "PySide2.QtSql.QSqlQuery.result": (),
-    "PySide2.QtSql.QSqlQuery.seek": ('int', 'bool'),
-    "PySide2.QtSql.QSqlQuery.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlQuery.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlQuery.size": (),
-    "PySide2.QtSql.QSqlQuery.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlQueryModel:
-    "PySide2.QtSql.QSqlQueryModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.clear": (),
-    "PySide2.QtSql.QSqlQueryModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.endInsertColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endInsertRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.lastError": (),
-    "PySide2.QtSql.QSqlQueryModel.query": (),
-    "PySide2.QtSql.QSqlQueryModel.queryChange": (),
-    "PySide2.QtSql.QSqlQueryModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlQueryModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.roleNames": (),
-    "PySide2.QtSql.QSqlQueryModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlQueryModel.setQuery": [('PySide2.QtSql.QSqlQuery',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-# class PySide2.QtSql.QSqlRecord:
-    "PySide2.QtSql.QSqlRecord.__init__": [(), ('PySide2.QtSql.QSqlRecord',)],
-    "PySide2.QtSql.QSqlRecord.__copy__": (),
-    "PySide2.QtSql.QSqlRecord.append": ('PySide2.QtSql.QSqlField',),
-    "PySide2.QtSql.QSqlRecord.clear": (),
-    "PySide2.QtSql.QSqlRecord.clearValues": (),
-    "PySide2.QtSql.QSqlRecord.contains": ('str',),
-    "PySide2.QtSql.QSqlRecord.count": (),
-    "PySide2.QtSql.QSqlRecord.field": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.fieldName": ('int',),
-    "PySide2.QtSql.QSqlRecord.indexOf": ('str',),
-    "PySide2.QtSql.QSqlRecord.insert": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.isEmpty": (),
-    "PySide2.QtSql.QSqlRecord.isGenerated": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.keyValues": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRecord.remove": ('int',),
-    "PySide2.QtSql.QSqlRecord.replace": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.setGenerated": [('int', 'bool'), ('str', 'bool')],
-    "PySide2.QtSql.QSqlRecord.setNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.setValue": [('int', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtSql.QSqlRecord.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlRelation:
-    "PySide2.QtSql.QSqlRelation.__init__": [(), ('PySide2.QtSql.QSqlRelation',), ('str', 'str', 'str')],
-    "PySide2.QtSql.QSqlRelation.__copy__": (),
-    "PySide2.QtSql.QSqlRelation.displayColumn": (),
-    "PySide2.QtSql.QSqlRelation.indexColumn": (),
-    "PySide2.QtSql.QSqlRelation.isValid": (),
-    "PySide2.QtSql.QSqlRelation.swap": ('PySide2.QtSql.QSqlRelation',),
-    "PySide2.QtSql.QSqlRelation.tableName": (),
-# class PySide2.QtSql.QSqlRelationalDelegate:
-    "PySide2.QtSql.QSqlRelationalDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlRelationalDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtSql.QSqlRelationalTableModel:
-# class PySide2.QtSql.QSqlRelationalTableModel.JoinMode:
-    "PySide2.QtSql.QSqlRelationalTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlRelationalTableModel.clear": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRelationalTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.relation": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.relationModel": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.select": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setJoinMode": ('PySide2.QtSql.QSqlRelationalTableModel.JoinMode',),
-    "PySide2.QtSql.QSqlRelationalTableModel.setRelation": ('int', 'PySide2.QtSql.QSqlRelation'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlRelationalTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-# class PySide2.QtSql.QSqlResult:
-# class PySide2.QtSql.QSqlResult.BindingSyntax:
-    "PySide2.QtSql.QSqlResult.__init__": ('PySide2.QtSql.QSqlDriver',),
-    "PySide2.QtSql.QSqlResult.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlResult.at": (),
-    "PySide2.QtSql.QSqlResult.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlResult.bindValueType": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.bindingSyntax": (),
-    "PySide2.QtSql.QSqlResult.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.boundValueCount": (),
-    "PySide2.QtSql.QSqlResult.boundValueName": ('int',),
-    "PySide2.QtSql.QSqlResult.boundValues": (),
-    "PySide2.QtSql.QSqlResult.clear": (),
-    "PySide2.QtSql.QSqlResult.data": ('int',),
-    "PySide2.QtSql.QSqlResult.detachFromResultSet": (),
-    "PySide2.QtSql.QSqlResult.driver": (),
-    "PySide2.QtSql.QSqlResult.execBatch": ('bool',),
-    "PySide2.QtSql.QSqlResult.exec_": (),
-    "PySide2.QtSql.QSqlResult.executedQuery": (),
-    "PySide2.QtSql.QSqlResult.fetch": ('int',),
-    "PySide2.QtSql.QSqlResult.fetchFirst": (),
-    "PySide2.QtSql.QSqlResult.fetchLast": (),
-    "PySide2.QtSql.QSqlResult.fetchNext": (),
-    "PySide2.QtSql.QSqlResult.fetchPrevious": (),
-    "PySide2.QtSql.QSqlResult.handle": (),
-    "PySide2.QtSql.QSqlResult.hasOutValues": (),
-    "PySide2.QtSql.QSqlResult.isActive": (),
-    "PySide2.QtSql.QSqlResult.isForwardOnly": (),
-    "PySide2.QtSql.QSqlResult.isNull": ('int',),
-    "PySide2.QtSql.QSqlResult.isSelect": (),
-    "PySide2.QtSql.QSqlResult.isValid": (),
-    "PySide2.QtSql.QSqlResult.lastError": (),
-    "PySide2.QtSql.QSqlResult.lastInsertId": (),
-    "PySide2.QtSql.QSqlResult.lastQuery": (),
-    "PySide2.QtSql.QSqlResult.nextResult": (),
-    "PySide2.QtSql.QSqlResult.numRowsAffected": (),
-    "PySide2.QtSql.QSqlResult.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlResult.prepare": ('str',),
-    "PySide2.QtSql.QSqlResult.record": (),
-    "PySide2.QtSql.QSqlResult.reset": ('str',),
-    "PySide2.QtSql.QSqlResult.resetBindCount": (),
-    "PySide2.QtSql.QSqlResult.savePrepare": ('str',),
-    "PySide2.QtSql.QSqlResult.setActive": ('bool',),
-    "PySide2.QtSql.QSqlResult.setAt": ('int',),
-    "PySide2.QtSql.QSqlResult.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlResult.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlResult.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlResult.setQuery": ('str',),
-    "PySide2.QtSql.QSqlResult.setSelect": ('bool',),
-    "PySide2.QtSql.QSqlResult.size": (),
-# class PySide2.QtSql.QSqlTableModel:
-# class PySide2.QtSql.QSqlTableModel.EditStrategy:
-    "PySide2.QtSql.QSqlTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlTableModel.clear": (),
-    "PySide2.QtSql.QSqlTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlTableModel.database": (),
-    "PySide2.QtSql.QSqlTableModel.deleteRowFromTable": ('int',),
-    "PySide2.QtSql.QSqlTableModel.editStrategy": (),
-    "PySide2.QtSql.QSqlTableModel.fieldIndex": ('str',),
-    "PySide2.QtSql.QSqlTableModel.filter": (),
-    "PySide2.QtSql.QSqlTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlTableModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.insertRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlTableModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.isDirty": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtSql.QSqlTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlTableModel.primaryKey": (),
-    "PySide2.QtSql.QSqlTableModel.primaryValues": ('int',),
-    "PySide2.QtSql.QSqlTableModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.revert": (),
-    "PySide2.QtSql.QSqlTableModel.revertAll": (),
-    "PySide2.QtSql.QSqlTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.select": (),
-    "PySide2.QtSql.QSqlTableModel.selectRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlTableModel.setEditStrategy": ('PySide2.QtSql.QSqlTableModel.EditStrategy',),
-    "PySide2.QtSql.QSqlTableModel.setFilter": ('str',),
-    "PySide2.QtSql.QSqlTableModel.setPrimaryKey": ('PySide2.QtSql.QSqlIndex',),
-    "PySide2.QtSql.QSqlTableModel.setQuery": ('PySide2.QtSql.QSqlQuery',),
-    "PySide2.QtSql.QSqlTableModel.setRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.setSort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlTableModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.submit": (),
-    "PySide2.QtSql.QSqlTableModel.submitAll": (),
-    "PySide2.QtSql.QSqlTableModel.tableName": (),
-    "PySide2.QtSql.QSqlTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-    }) if "PySide2.QtSql" in sys.modules else None
-# Module PySide2.QtNetwork
-sig_dict.update({
-# class PySide2.QtNetwork.QAbstractNetworkCache:
-    "PySide2.QtNetwork.QAbstractNetworkCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.cacheSize": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.clear": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QAbstractSocket:
-# class PySide2.QtNetwork.QAbstractSocket.BindFlag:
-# class PySide2.QtNetwork.QAbstractSocket.BindMode:
-# class PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol:
-# class PySide2.QtNetwork.QAbstractSocket.PauseMode:
-# class PySide2.QtNetwork.QAbstractSocket.PauseModes:
-# class PySide2.QtNetwork.QAbstractSocket.SocketError:
-# class PySide2.QtNetwork.QAbstractSocket.SocketOption:
-# class PySide2.QtNetwork.QAbstractSocket.SocketState:
-# class PySide2.QtNetwork.QAbstractSocket.SocketType:
-    "PySide2.QtNetwork.QAbstractSocket.__init__": ('PySide2.QtNetwork.QAbstractSocket.SocketType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QAbstractSocket.abort": (),
-    "PySide2.QtNetwork.QAbstractSocket.atEnd": (),
-    "PySide2.QtNetwork.QAbstractSocket.bind": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtNetwork.QAbstractSocket.BindMode'), ('int', 'PySide2.QtNetwork.QAbstractSocket.BindMode')],
-    "PySide2.QtNetwork.QAbstractSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QAbstractSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QAbstractSocket.canReadLine": (),
-    "PySide2.QtNetwork.QAbstractSocket.close": (),
-    "PySide2.QtNetwork.QAbstractSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QAbstractSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QAbstractSocket.error": (),
-    "PySide2.QtNetwork.QAbstractSocket.flush": (),
-    "PySide2.QtNetwork.QAbstractSocket.isSequential": (),
-    "PySide2.QtNetwork.QAbstractSocket.isValid": (),
-    "PySide2.QtNetwork.QAbstractSocket.localAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.localPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.pauseMode": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerName": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.protocolTag": (),
-    "PySide2.QtNetwork.QAbstractSocket.proxy": (),
-    "PySide2.QtNetwork.QAbstractSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QAbstractSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.readLineData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.resume": (),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerName": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QAbstractSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketError": ('PySide2.QtNetwork.QAbstractSocket.SocketError',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketState": ('PySide2.QtNetwork.QAbstractSocket.SocketState',),
-    "PySide2.QtNetwork.QAbstractSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QAbstractSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QAbstractSocket.socketType": (),
-    "PySide2.QtNetwork.QAbstractSocket.state": (),
-    "PySide2.QtNetwork.QAbstractSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QAuthenticator:
-    "PySide2.QtNetwork.QAuthenticator.__init__": [(), ('PySide2.QtNetwork.QAuthenticator',)],
-    "PySide2.QtNetwork.QAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QAuthenticator.isNull": (),
-    "PySide2.QtNetwork.QAuthenticator.option": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.options": (),
-    "PySide2.QtNetwork.QAuthenticator.password": (),
-    "PySide2.QtNetwork.QAuthenticator.realm": (),
-    "PySide2.QtNetwork.QAuthenticator.setOption": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QAuthenticator.setPassword": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setRealm": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setUser": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.user": (),
-# class PySide2.QtNetwork.QDnsDomainNameRecord:
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__init__": [(), ('PySide2.QtNetwork.QDnsDomainNameRecord',)],
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.name": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.swap": ('PySide2.QtNetwork.QDnsDomainNameRecord',),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.value": (),
-# class PySide2.QtNetwork.QDnsHostAddressRecord:
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__init__": [(), ('PySide2.QtNetwork.QDnsHostAddressRecord',)],
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.name": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.swap": ('PySide2.QtNetwork.QDnsHostAddressRecord',),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.value": (),
-# class PySide2.QtNetwork.QDnsLookup:
-# class PySide2.QtNetwork.QDnsLookup.Error:
-# class PySide2.QtNetwork.QDnsLookup.Type:
-    "PySide2.QtNetwork.QDnsLookup.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtNetwork.QHostAddress', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QDnsLookup.abort": (),
-    "PySide2.QtNetwork.QDnsLookup.canonicalNameRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.error": (),
-    "PySide2.QtNetwork.QDnsLookup.errorString": (),
-    "PySide2.QtNetwork.QDnsLookup.hostAddressRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.isFinished": (),
-    "PySide2.QtNetwork.QDnsLookup.lookup": (),
-    "PySide2.QtNetwork.QDnsLookup.mailExchangeRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.name": (),
-    "PySide2.QtNetwork.QDnsLookup.nameServerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.nameserver": (),
-    "PySide2.QtNetwork.QDnsLookup.pointerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.serviceRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.setName": ('str',),
-    "PySide2.QtNetwork.QDnsLookup.setNameserver": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QDnsLookup.setType": ('PySide2.QtNetwork.QDnsLookup.Type',),
-    "PySide2.QtNetwork.QDnsLookup.textRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.type": (),
-# class PySide2.QtNetwork.QDnsMailExchangeRecord:
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__init__": [(), ('PySide2.QtNetwork.QDnsMailExchangeRecord',)],
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.exchange": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.name": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.preference": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.swap": ('PySide2.QtNetwork.QDnsMailExchangeRecord',),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.timeToLive": (),
-# class PySide2.QtNetwork.QDnsServiceRecord:
-    "PySide2.QtNetwork.QDnsServiceRecord.__init__": [(), ('PySide2.QtNetwork.QDnsServiceRecord',)],
-    "PySide2.QtNetwork.QDnsServiceRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.name": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.port": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.priority": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.swap": ('PySide2.QtNetwork.QDnsServiceRecord',),
-    "PySide2.QtNetwork.QDnsServiceRecord.target": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.weight": (),
-# class PySide2.QtNetwork.QDnsTextRecord:
-    "PySide2.QtNetwork.QDnsTextRecord.__init__": [(), ('PySide2.QtNetwork.QDnsTextRecord',)],
-    "PySide2.QtNetwork.QDnsTextRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsTextRecord.name": (),
-    "PySide2.QtNetwork.QDnsTextRecord.swap": ('PySide2.QtNetwork.QDnsTextRecord',),
-    "PySide2.QtNetwork.QDnsTextRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsTextRecord.values": (),
-# class PySide2.QtNetwork.QDtls:
-# class PySide2.QtNetwork.QDtls.HandshakeState:
-    "PySide2.QtNetwork.QDtls.__init__": ('PySide2.QtNetwork.QSslSocket.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QDtls.abortHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.decryptDatagram": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.doHandshake": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.dtlsConfiguration": (),
-    "PySide2.QtNetwork.QDtls.dtlsError": (),
-    "PySide2.QtNetwork.QDtls.dtlsErrorString": (),
-    "PySide2.QtNetwork.QDtls.handleTimeout": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.handshakeState": (),
-    "PySide2.QtNetwork.QDtls.ignoreVerificationErrors": ('typing.List[PySide2.QtNetwork.QSslError]',),
-    "PySide2.QtNetwork.QDtls.isConnectionEncrypted": (),
-    "PySide2.QtNetwork.QDtls.mtuHint": (),
-    "PySide2.QtNetwork.QDtls.peerAddress": (),
-    "PySide2.QtNetwork.QDtls.peerPort": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationErrors": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationName": (),
-    "PySide2.QtNetwork.QDtls.resumeHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sessionCipher": (),
-    "PySide2.QtNetwork.QDtls.sessionProtocol": (),
-    "PySide2.QtNetwork.QDtls.setDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QDtls.setMtuHint": ('int',),
-    "PySide2.QtNetwork.QDtls.setPeer": ('PySide2.QtNetwork.QHostAddress', 'int', 'str'),
-    "PySide2.QtNetwork.QDtls.setPeerVerificationName": ('str',),
-    "PySide2.QtNetwork.QDtls.shutdown": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sslMode": (),
-    "PySide2.QtNetwork.QDtls.writeDatagramEncrypted": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtNetwork.QDtlsError:
-# class PySide2.QtNetwork.QHostAddress:
-# class PySide2.QtNetwork.QHostAddress.ConversionMode:
-# class PySide2.QtNetwork.QHostAddress.ConversionModeFlag:
-# class PySide2.QtNetwork.QHostAddress.SpecialAddress:
-    "PySide2.QtNetwork.QHostAddress.__init__": [(), ('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.__copy__": (),
-    "PySide2.QtNetwork.QHostAddress.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.clear": (),
-    "PySide2.QtNetwork.QHostAddress.isBroadcast": (),
-    "PySide2.QtNetwork.QHostAddress.isEqual": ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QHostAddress.ConversionMode'),
-    "PySide2.QtNetwork.QHostAddress.isGlobal": (),
-    "PySide2.QtNetwork.QHostAddress.isInSubnet": [('PySide2.QtNetwork.QHostAddress', 'int'), ('typing.Tuple[PySide2.QtNetwork.QHostAddress, int]',)],
-    "PySide2.QtNetwork.QHostAddress.isLinkLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isLoopback": (),
-    "PySide2.QtNetwork.QHostAddress.isMulticast": (),
-    "PySide2.QtNetwork.QHostAddress.isNull": (),
-    "PySide2.QtNetwork.QHostAddress.isSiteLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isUniqueLocalUnicast": (),
-    "PySide2.QtNetwork.QHostAddress.parseSubnet": ('str',),
-    "PySide2.QtNetwork.QHostAddress.protocol": (),
-    "PySide2.QtNetwork.QHostAddress.scopeId": (),
-    "PySide2.QtNetwork.QHostAddress.setAddress": [('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.setScopeId": ('str',),
-    "PySide2.QtNetwork.QHostAddress.swap": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QHostAddress.toIPv4Address": (),
-    "PySide2.QtNetwork.QHostAddress.toIPv6Address": (),
-    "PySide2.QtNetwork.QHostAddress.toString": (),
-# class PySide2.QtNetwork.QHostInfo:
-# class PySide2.QtNetwork.QHostInfo.HostInfoError:
-    "PySide2.QtNetwork.QHostInfo.__init__": [('PySide2.QtNetwork.QHostInfo',), ('int',)],
-    "PySide2.QtNetwork.QHostInfo.__copy__": (),
-    "PySide2.QtNetwork.QHostInfo.abortHostLookup": ('int',),
-    "PySide2.QtNetwork.QHostInfo.addresses": (),
-    "PySide2.QtNetwork.QHostInfo.error": (),
-    "PySide2.QtNetwork.QHostInfo.errorString": (),
-    "PySide2.QtNetwork.QHostInfo.fromName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.hostName": (),
-    "PySide2.QtNetwork.QHostInfo.localDomainName": (),
-    "PySide2.QtNetwork.QHostInfo.localHostName": (),
-    "PySide2.QtNetwork.QHostInfo.lookupId": (),
-    "PySide2.QtNetwork.QHostInfo.setAddresses": ('typing.Sequence[PySide2.QtNetwork.QHostAddress]',),
-    "PySide2.QtNetwork.QHostInfo.setError": ('PySide2.QtNetwork.QHostInfo.HostInfoError',),
-    "PySide2.QtNetwork.QHostInfo.setErrorString": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setHostName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setLookupId": ('int',),
-    "PySide2.QtNetwork.QHostInfo.swap": ('PySide2.QtNetwork.QHostInfo',),
-# class PySide2.QtNetwork.QHstsPolicy:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlag:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlags:
-    "PySide2.QtNetwork.QHstsPolicy.__init__": [(), ('PySide2.QtCore.QDateTime', 'PySide2.QtNetwork.QHstsPolicy.PolicyFlags', 'str', 'PySide2.QtCore.QUrl.ParsingMode'), ('PySide2.QtNetwork.QHstsPolicy',)],
-    "PySide2.QtNetwork.QHstsPolicy.__copy__": (),
-    "PySide2.QtNetwork.QHstsPolicy.expiry": (),
-    "PySide2.QtNetwork.QHstsPolicy.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtNetwork.QHstsPolicy.includesSubDomains": (),
-    "PySide2.QtNetwork.QHstsPolicy.isExpired": (),
-    "PySide2.QtNetwork.QHstsPolicy.setExpiry": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QHstsPolicy.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtNetwork.QHstsPolicy.setIncludesSubDomains": ('bool',),
-    "PySide2.QtNetwork.QHstsPolicy.swap": ('PySide2.QtNetwork.QHstsPolicy',),
-# class PySide2.QtNetwork.QHttpMultiPart:
-# class PySide2.QtNetwork.QHttpMultiPart.ContentType:
-    "PySide2.QtNetwork.QHttpMultiPart.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QHttpMultiPart.ContentType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QHttpMultiPart.append": ('PySide2.QtNetwork.QHttpPart',),
-    "PySide2.QtNetwork.QHttpMultiPart.boundary": (),
-    "PySide2.QtNetwork.QHttpMultiPart.setBoundary": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpMultiPart.setContentType": ('PySide2.QtNetwork.QHttpMultiPart.ContentType',),
-# class PySide2.QtNetwork.QHttpPart:
-    "PySide2.QtNetwork.QHttpPart.__init__": [(), ('PySide2.QtNetwork.QHttpPart',)],
-    "PySide2.QtNetwork.QHttpPart.__copy__": (),
-    "PySide2.QtNetwork.QHttpPart.setBody": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpPart.setBodyDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QHttpPart.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QHttpPart.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QHttpPart.swap": ('PySide2.QtNetwork.QHttpPart',),
-# class PySide2.QtNetwork.QIPv6Address:
-    "PySide2.QtNetwork.QIPv6Address.__init__": [(), ('PySide2.QtNetwork.QIPv6Address',)],
-    "PySide2.QtNetwork.QIPv6Address.__copy__": (),
-# class PySide2.QtNetwork.QLocalServer:
-# class PySide2.QtNetwork.QLocalServer.SocketOption:
-# class PySide2.QtNetwork.QLocalServer.SocketOptions:
-    "PySide2.QtNetwork.QLocalServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalServer.close": (),
-    "PySide2.QtNetwork.QLocalServer.errorString": (),
-    "PySide2.QtNetwork.QLocalServer.fullServerName": (),
-    "PySide2.QtNetwork.QLocalServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QLocalServer.isListening": (),
-    "PySide2.QtNetwork.QLocalServer.listen": [('int',), ('str',)],
-    "PySide2.QtNetwork.QLocalServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QLocalServer.removeServer": ('str',),
-    "PySide2.QtNetwork.QLocalServer.serverError": (),
-    "PySide2.QtNetwork.QLocalServer.serverName": (),
-    "PySide2.QtNetwork.QLocalServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QLocalServer.setSocketOptions": ('PySide2.QtNetwork.QLocalServer.SocketOptions',),
-    "PySide2.QtNetwork.QLocalServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalServer.socketOptions": (),
-    "PySide2.QtNetwork.QLocalServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QLocalSocket:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketError:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketState:
-    "PySide2.QtNetwork.QLocalSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalSocket.abort": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QLocalSocket.canReadLine": (),
-    "PySide2.QtNetwork.QLocalSocket.close": (),
-    "PySide2.QtNetwork.QLocalSocket.connectToServer": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtNetwork.QLocalSocket.disconnectFromServer": (),
-    "PySide2.QtNetwork.QLocalSocket.error": (),
-    "PySide2.QtNetwork.QLocalSocket.flush": (),
-    "PySide2.QtNetwork.QLocalSocket.fullServerName": (),
-    "PySide2.QtNetwork.QLocalSocket.isSequential": (),
-    "PySide2.QtNetwork.QLocalSocket.isValid": (),
-    "PySide2.QtNetwork.QLocalSocket.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtNetwork.QLocalSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QLocalSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QLocalSocket.serverName": (),
-    "PySide2.QtNetwork.QLocalSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.setServerName": ('str',),
-    "PySide2.QtNetwork.QLocalSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QLocalSocket.LocalSocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QLocalSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalSocket.state": (),
-    "PySide2.QtNetwork.QLocalSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkAccessManager:
-# class PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility:
-# class PySide2.QtNetwork.QNetworkAccessManager.Operation:
-    "PySide2.QtNetwork.QNetworkAccessManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkAccessManager.activeConfiguration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.addStrictTransportSecurityHosts": ('typing.List[PySide2.QtNetwork.QHstsPolicy]',),
-    "PySide2.QtNetwork.QNetworkAccessManager.autoDeleteReplies": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.cache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearAccessCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearConnectionCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.configuration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHost": ('str', 'int'),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHostEncrypted": [('str', 'int', 'PySide2.QtNetwork.QSslConfiguration'), ('str', 'int', 'PySide2.QtNetwork.QSslConfiguration', 'str')],
-    "PySide2.QtNetwork.QNetworkAccessManager.cookieJar": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.createRequest": ('PySide2.QtNetwork.QNetworkAccessManager.Operation', 'PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtNetwork.QNetworkAccessManager.deleteResource": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.enableStrictTransportSecurityStore": ('bool', 'str'),
-    "PySide2.QtNetwork.QNetworkAccessManager.get": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.head": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityStoreEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.networkAccessible": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.post": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.proxy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.proxyFactory": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.put": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.redirectPolicy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.sendCustomRequest": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.setAutoDeleteReplies": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCache": ('PySide2.QtNetwork.QAbstractNetworkCache',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCookieJar": ('PySide2.QtNetwork.QNetworkCookieJar',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setNetworkAccessible": ('PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setRedirectPolicy": ('PySide2.QtNetwork.QNetworkRequest.RedirectPolicy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setStrictTransportSecurityEnabled": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.strictTransportSecurityHosts": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemes": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemesImplementation": (),
-# class PySide2.QtNetwork.QNetworkAddressEntry:
-# class PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus:
-    "PySide2.QtNetwork.QNetworkAddressEntry.__init__": [(), ('PySide2.QtNetwork.QNetworkAddressEntry',)],
-    "PySide2.QtNetwork.QNetworkAddressEntry.__copy__": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.broadcast": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.clearAddressLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.dnsEligibility": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.ip": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isLifetimeKnown": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isPermanent": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isTemporary": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.netmask": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.preferredLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.prefixLength": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setAddressLifetime": ('PySide2.QtCore.QDeadlineTimer', 'PySide2.QtCore.QDeadlineTimer'),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setBroadcast": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setDnsEligibility": ('PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setIp": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setNetmask": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setPrefixLength": ('int',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.swap": ('PySide2.QtNetwork.QNetworkAddressEntry',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.validityLifetime": (),
-# class PySide2.QtNetwork.QNetworkCacheMetaData:
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__init__": [(), ('PySide2.QtNetwork.QNetworkCacheMetaData',)],
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.attributes": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.isValid": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.lastModified": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.rawHeaders": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.saveToDisk": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setAttributes": ('typing.Dict[PySide2.QtNetwork.QNetworkRequest.Attribute, typing.Any]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setLastModified": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setRawHeaders": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setSaveToDisk": ('bool',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.swap": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.url": (),
-# class PySide2.QtNetwork.QNetworkConfiguration:
-# class PySide2.QtNetwork.QNetworkConfiguration.BearerType:
-# class PySide2.QtNetwork.QNetworkConfiguration.Purpose:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlag:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlags:
-# class PySide2.QtNetwork.QNetworkConfiguration.Type:
-    "PySide2.QtNetwork.QNetworkConfiguration.__init__": [(), ('PySide2.QtNetwork.QNetworkConfiguration',)],
-    "PySide2.QtNetwork.QNetworkConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerType": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeFamily": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeName": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.children": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.connectTimeout": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.identifier": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isRoamingAvailable": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isValid": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.name": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.purpose": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.setConnectTimeout": ('int',),
-    "PySide2.QtNetwork.QNetworkConfiguration.state": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.swap": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkConfiguration.type": (),
-# class PySide2.QtNetwork.QNetworkConfigurationManager:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capabilities:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capability:
-    "PySide2.QtNetwork.QNetworkConfigurationManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.allConfigurations": ('PySide2.QtNetwork.QNetworkConfiguration.StateFlags',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.capabilities": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.configurationFromIdentifier": ('str',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.defaultConfiguration": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.isOnline": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.updateConfigurations": (),
-# class PySide2.QtNetwork.QNetworkCookie:
-# class PySide2.QtNetwork.QNetworkCookie.RawForm:
-    "PySide2.QtNetwork.QNetworkCookie.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkCookie',)],
-    "PySide2.QtNetwork.QNetworkCookie.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCookie.domain": (),
-    "PySide2.QtNetwork.QNetworkCookie.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCookie.hasSameIdentifier": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.isHttpOnly": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSecure": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSessionCookie": (),
-    "PySide2.QtNetwork.QNetworkCookie.name": (),
-    "PySide2.QtNetwork.QNetworkCookie.normalize": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookie.parseCookies": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.path": (),
-    "PySide2.QtNetwork.QNetworkCookie.setDomain": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCookie.setHttpOnly": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.setPath": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setSecure": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setValue": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.swap": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.toRawForm": ('PySide2.QtNetwork.QNetworkCookie.RawForm',),
-    "PySide2.QtNetwork.QNetworkCookie.value": (),
-# class PySide2.QtNetwork.QNetworkCookieJar:
-    "PySide2.QtNetwork.QNetworkCookieJar.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkCookieJar.allCookies": (),
-    "PySide2.QtNetwork.QNetworkCookieJar.cookiesForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookieJar.deleteCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.insertCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setAllCookies": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setCookiesFromUrl": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtNetwork.QNetworkCookieJar.updateCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.validateCookie": ('PySide2.QtNetwork.QNetworkCookie', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtNetwork.QNetworkDatagram:
-    "PySide2.QtNetwork.QNetworkDatagram.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    "PySide2.QtNetwork.QNetworkDatagram.__copy__": (),
-    "PySide2.QtNetwork.QNetworkDatagram.clear": (),
-    "PySide2.QtNetwork.QNetworkDatagram.data": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.hopLimit": (),
-    "PySide2.QtNetwork.QNetworkDatagram.interfaceIndex": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isNull": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isValid": (),
-    "PySide2.QtNetwork.QNetworkDatagram.makeReply": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.senderAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.senderPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.setDestination": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.setHopLimit": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setInterfaceIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setSender": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.swap": ('PySide2.QtNetwork.QNetworkDatagram',),
-# class PySide2.QtNetwork.QNetworkDiskCache:
-    "PySide2.QtNetwork.QNetworkDiskCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheDirectory": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.clear": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.expire": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.fileMetaData": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QNetworkDiskCache.maximumCacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkDiskCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setCacheDirectory": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setMaximumCacheSize": ('int',),
-    "PySide2.QtNetwork.QNetworkDiskCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QNetworkInterface:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlag:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlags:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceType:
-    "PySide2.QtNetwork.QNetworkInterface.__init__": [(), ('PySide2.QtNetwork.QNetworkInterface',)],
-    "PySide2.QtNetwork.QNetworkInterface.__copy__": (),
-    "PySide2.QtNetwork.QNetworkInterface.addressEntries": (),
-    "PySide2.QtNetwork.QNetworkInterface.allAddresses": (),
-    "PySide2.QtNetwork.QNetworkInterface.allInterfaces": (),
-    "PySide2.QtNetwork.QNetworkInterface.flags": (),
-    "PySide2.QtNetwork.QNetworkInterface.hardwareAddress": (),
-    "PySide2.QtNetwork.QNetworkInterface.humanReadableName": (),
-    "PySide2.QtNetwork.QNetworkInterface.index": (),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceIndexFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceNameFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.isValid": (),
-    "PySide2.QtNetwork.QNetworkInterface.maximumTransmissionUnit": (),
-    "PySide2.QtNetwork.QNetworkInterface.name": (),
-    "PySide2.QtNetwork.QNetworkInterface.swap": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QNetworkInterface.type": (),
-# class PySide2.QtNetwork.QNetworkProxy:
-# class PySide2.QtNetwork.QNetworkProxy.Capabilities:
-# class PySide2.QtNetwork.QNetworkProxy.Capability:
-# class PySide2.QtNetwork.QNetworkProxy.ProxyType:
-    "PySide2.QtNetwork.QNetworkProxy.__init__": [(), ('PySide2.QtNetwork.QNetworkProxy',), ('PySide2.QtNetwork.QNetworkProxy.ProxyType', 'str', 'int', 'str', 'str')],
-    "PySide2.QtNetwork.QNetworkProxy.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxy.applicationProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.capabilities": (),
-    "PySide2.QtNetwork.QNetworkProxy.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkProxy.hostName": (),
-    "PySide2.QtNetwork.QNetworkProxy.isCachingProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.isTransparentProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.password": (),
-    "PySide2.QtNetwork.QNetworkProxy.port": (),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkProxy.setApplicationProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.setCapabilities": ('PySide2.QtNetwork.QNetworkProxy.Capabilities',),
-    "PySide2.QtNetwork.QNetworkProxy.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkProxy.setHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPassword": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxy.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkProxy.setType": ('PySide2.QtNetwork.QNetworkProxy.ProxyType',),
-    "PySide2.QtNetwork.QNetworkProxy.setUser": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.swap": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.type": (),
-    "PySide2.QtNetwork.QNetworkProxy.user": (),
-# class PySide2.QtNetwork.QNetworkProxyFactory:
-    "PySide2.QtNetwork.QNetworkProxyFactory.__init__": (),
-    "PySide2.QtNetwork.QNetworkProxyFactory.proxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.queryProxy": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setApplicationProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration": ('bool',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.systemProxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.usesSystemConfiguration": (),
-# class PySide2.QtNetwork.QNetworkProxyQuery:
-# class PySide2.QtNetwork.QNetworkProxyQuery.QueryType:
-    "PySide2.QtNetwork.QNetworkProxyQuery.__init__": [(), ('PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkProxyQuery',), ('int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType')],
-    "PySide2.QtNetwork.QNetworkProxyQuery.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.localPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.networkConfiguration": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerHostName": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.protocolTag": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.queryType": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setNetworkConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setQueryType": ('PySide2.QtNetwork.QNetworkProxyQuery.QueryType',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.swap": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.url": (),
-# class PySide2.QtNetwork.QNetworkReply:
-# class PySide2.QtNetwork.QNetworkReply.NetworkError:
-    "PySide2.QtNetwork.QNetworkReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkReply.abort": (),
-    "PySide2.QtNetwork.QNetworkReply.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute',),
-    "PySide2.QtNetwork.QNetworkReply.close": (),
-    "PySide2.QtNetwork.QNetworkReply.error": (),
-    "PySide2.QtNetwork.QNetworkReply.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrorsImplementation": ('typing.Sequence[PySide2.QtNetwork.QSslError]',),
-    "PySide2.QtNetwork.QNetworkReply.isFinished": (),
-    "PySide2.QtNetwork.QNetworkReply.isRunning": (),
-    "PySide2.QtNetwork.QNetworkReply.isSequential": (),
-    "PySide2.QtNetwork.QNetworkReply.manager": (),
-    "PySide2.QtNetwork.QNetworkReply.operation": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderPairs": (),
-    "PySide2.QtNetwork.QNetworkReply.readBufferSize": (),
-    "PySide2.QtNetwork.QNetworkReply.request": (),
-    "PySide2.QtNetwork.QNetworkReply.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setError": ('PySide2.QtNetwork.QNetworkReply.NetworkError', 'str'),
-    "PySide2.QtNetwork.QNetworkReply.setFinished": ('bool',),
-    "PySide2.QtNetwork.QNetworkReply.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setOperation": ('PySide2.QtNetwork.QNetworkAccessManager.Operation',),
-    "PySide2.QtNetwork.QNetworkReply.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkReply.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QNetworkReply.setRequest": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkReply.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkReply.sslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.url": (),
-    "PySide2.QtNetwork.QNetworkReply.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkRequest:
-# class PySide2.QtNetwork.QNetworkRequest.Attribute:
-# class PySide2.QtNetwork.QNetworkRequest.CacheLoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.KnownHeaders:
-# class PySide2.QtNetwork.QNetworkRequest.LoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.Priority:
-# class PySide2.QtNetwork.QNetworkRequest.RedirectPolicy:
-    "PySide2.QtNetwork.QNetworkRequest.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtNetwork.QNetworkRequest.__copy__": (),
-    "PySide2.QtNetwork.QNetworkRequest.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkRequest.maximumRedirectsAllowed": (),
-    "PySide2.QtNetwork.QNetworkRequest.originatingObject": (),
-    "PySide2.QtNetwork.QNetworkRequest.peerVerifyName": (),
-    "PySide2.QtNetwork.QNetworkRequest.priority": (),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkRequest.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setMaximumRedirectsAllowed": ('int',),
-    "PySide2.QtNetwork.QNetworkRequest.setOriginatingObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkRequest.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QNetworkRequest.setPriority": ('PySide2.QtNetwork.QNetworkRequest.Priority',),
-    "PySide2.QtNetwork.QNetworkRequest.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkRequest.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkRequest.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkRequest.swap": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkRequest.url": (),
-# class PySide2.QtNetwork.QNetworkSession:
-# class PySide2.QtNetwork.QNetworkSession.SessionError:
-# class PySide2.QtNetwork.QNetworkSession.State:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicies:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicy:
-    "PySide2.QtNetwork.QNetworkSession.__init__": ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QNetworkSession.accept": (),
-    "PySide2.QtNetwork.QNetworkSession.activeTime": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesReceived": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesWritten": (),
-    "PySide2.QtNetwork.QNetworkSession.close": (),
-    "PySide2.QtNetwork.QNetworkSession.configuration": (),
-    "PySide2.QtNetwork.QNetworkSession.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.error": (),
-    "PySide2.QtNetwork.QNetworkSession.errorString": (),
-    "PySide2.QtNetwork.QNetworkSession.ignore": (),
-    "PySide2.QtNetwork.QNetworkSession.interface": (),
-    "PySide2.QtNetwork.QNetworkSession.isOpen": (),
-    "PySide2.QtNetwork.QNetworkSession.migrate": (),
-    "PySide2.QtNetwork.QNetworkSession.open": (),
-    "PySide2.QtNetwork.QNetworkSession.reject": (),
-    "PySide2.QtNetwork.QNetworkSession.sessionProperty": ('str',),
-    "PySide2.QtNetwork.QNetworkSession.setSessionProperty": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkSession.state": (),
-    "PySide2.QtNetwork.QNetworkSession.stop": (),
-    "PySide2.QtNetwork.QNetworkSession.usagePolicies": (),
-    "PySide2.QtNetwork.QNetworkSession.waitForOpened": ('int',),
-# class PySide2.QtNetwork.QOcspCertificateStatus:
-# class PySide2.QtNetwork.QOcspResponse:
-    "PySide2.QtNetwork.QOcspResponse.__init__": [(), ('PySide2.QtNetwork.QOcspResponse',)],
-    "PySide2.QtNetwork.QOcspResponse.__copy__": (),
-    "PySide2.QtNetwork.QOcspResponse.certificateStatus": (),
-    "PySide2.QtNetwork.QOcspResponse.revocationReason": (),
-    "PySide2.QtNetwork.QOcspResponse.subject": (),
-    "PySide2.QtNetwork.QOcspResponse.swap": ('PySide2.QtNetwork.QOcspResponse',),
-# class PySide2.QtNetwork.QOcspRevocationReason:
-# class PySide2.QtNetwork.QPasswordDigestor:
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf1": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf2": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-# class PySide2.QtNetwork.QSsl:
-# class PySide2.QtNetwork.QSsl.AlternativeNameEntryType:
-# class PySide2.QtNetwork.QSsl.EncodingFormat:
-# class PySide2.QtNetwork.QSsl.KeyAlgorithm:
-# class PySide2.QtNetwork.QSsl.KeyType:
-# class PySide2.QtNetwork.QSsl.SslOption:
-# class PySide2.QtNetwork.QSsl.SslOptions:
-# class PySide2.QtNetwork.QSsl.SslProtocol:
-# class PySide2.QtNetwork.QSslCertificate:
-# class PySide2.QtNetwork.QSslCertificate.SubjectInfo:
-    "PySide2.QtNetwork.QSslCertificate.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtNetwork.QSslCertificate',)],
-    "PySide2.QtNetwork.QSslCertificate.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificate.clear": (),
-    "PySide2.QtNetwork.QSslCertificate.digest": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtNetwork.QSslCertificate.effectiveDate": (),
-    "PySide2.QtNetwork.QSslCertificate.expiryDate": (),
-    "PySide2.QtNetwork.QSslCertificate.extensions": (),
-    "PySide2.QtNetwork.QSslCertificate.fromData": ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromDevice": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromPath": ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'),
-    "PySide2.QtNetwork.QSslCertificate.handle": (),
-    "PySide2.QtNetwork.QSslCertificate.importPkcs12": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSslKey', 'PySide2.QtNetwork.QSslCertificate', 'typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QSslCertificate.isBlacklisted": (),
-    "PySide2.QtNetwork.QSslCertificate.isNull": (),
-    "PySide2.QtNetwork.QSslCertificate.isSelfSigned": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.issuerInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.publicKey": (),
-    "PySide2.QtNetwork.QSslCertificate.serialNumber": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectAlternativeNames": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.subjectInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.swap": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslCertificate.toDer": (),
-    "PySide2.QtNetwork.QSslCertificate.toPem": (),
-    "PySide2.QtNetwork.QSslCertificate.toText": (),
-    "PySide2.QtNetwork.QSslCertificate.verify": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'str'),
-    "PySide2.QtNetwork.QSslCertificate.version": (),
-# class PySide2.QtNetwork.QSslCertificateExtension:
-    "PySide2.QtNetwork.QSslCertificateExtension.__init__": [(), ('PySide2.QtNetwork.QSslCertificateExtension',)],
-    "PySide2.QtNetwork.QSslCertificateExtension.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isCritical": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isSupported": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.name": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.oid": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.swap": ('PySide2.QtNetwork.QSslCertificateExtension',),
-    "PySide2.QtNetwork.QSslCertificateExtension.value": (),
-# class PySide2.QtNetwork.QSslCipher:
-    "PySide2.QtNetwork.QSslCipher.__init__": [(), ('PySide2.QtNetwork.QSslCipher',), ('str',), ('str', 'PySide2.QtNetwork.QSsl.SslProtocol')],
-    "PySide2.QtNetwork.QSslCipher.__copy__": (),
-    "PySide2.QtNetwork.QSslCipher.authenticationMethod": (),
-    "PySide2.QtNetwork.QSslCipher.encryptionMethod": (),
-    "PySide2.QtNetwork.QSslCipher.isNull": (),
-    "PySide2.QtNetwork.QSslCipher.keyExchangeMethod": (),
-    "PySide2.QtNetwork.QSslCipher.name": (),
-    "PySide2.QtNetwork.QSslCipher.protocol": (),
-    "PySide2.QtNetwork.QSslCipher.protocolString": (),
-    "PySide2.QtNetwork.QSslCipher.supportedBits": (),
-    "PySide2.QtNetwork.QSslCipher.swap": ('PySide2.QtNetwork.QSslCipher',),
-    "PySide2.QtNetwork.QSslCipher.usedBits": (),
-# class PySide2.QtNetwork.QSslConfiguration:
-# class PySide2.QtNetwork.QSslConfiguration.NextProtocolNegotiationStatus:
-    "PySide2.QtNetwork.QSslConfiguration.__init__": [(), ('PySide2.QtNetwork.QSslConfiguration',)],
-    "PySide2.QtNetwork.QSslConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QSslConfiguration.allowedNextProtocols": (),
-    "PySide2.QtNetwork.QSslConfiguration.backendConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.caCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.ciphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultDtlsConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.diffieHellmanParameters": (),
-    "PySide2.QtNetwork.QSslConfiguration.dtlsCookieVerificationEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.ephemeralServerKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.isNull": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextNegotiatedProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextProtocolNegotiationStatus": (),
-    "PySide2.QtNetwork.QSslConfiguration.ocspStaplingEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslConfiguration.preSharedKeyIdentityHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.privateKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.protocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionCipher": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicket": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicketLifeTimeHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.setAllowedNextProtocols": ('typing.Sequence[PySide2.QtCore.QByteArray]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfiguration": ('typing.Dict[PySide2.QtCore.QByteArray, typing.Any]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfigurationOption": ('PySide2.QtCore.QByteArray', 'typing.Any'),
-    "PySide2.QtNetwork.QSslConfiguration.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDiffieHellmanParameters": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-    "PySide2.QtNetwork.QSslConfiguration.setDtlsCookieVerificationEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setOcspStaplingEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslConfiguration.setPreSharedKeyIdentityHint": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setPrivateKey": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslConfiguration.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslConfiguration.setSessionTicket": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setSslOption": ('PySide2.QtNetwork.QSsl.SslOption', 'bool'),
-    "PySide2.QtNetwork.QSslConfiguration.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.swap": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.testSslOption": ('PySide2.QtNetwork.QSsl.SslOption',),
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters:
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters.Error:
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__init__": [(), ('PySide2.QtNetwork.QSslDiffieHellmanParameters',)],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__copy__": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.defaultParameters": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.error": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.errorString": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.fromEncoded": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isEmpty": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isValid": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.swap": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-# class PySide2.QtNetwork.QSslError:
-# class PySide2.QtNetwork.QSslError.SslError:
-    "PySide2.QtNetwork.QSslError.__init__": [(), ('PySide2.QtNetwork.QSslError',), ('PySide2.QtNetwork.QSslError.SslError',), ('PySide2.QtNetwork.QSslError.SslError', 'PySide2.QtNetwork.QSslCertificate')],
-    "PySide2.QtNetwork.QSslError.__copy__": (),
-    "PySide2.QtNetwork.QSslError.certificate": (),
-    "PySide2.QtNetwork.QSslError.error": (),
-    "PySide2.QtNetwork.QSslError.errorString": (),
-    "PySide2.QtNetwork.QSslError.swap": ('PySide2.QtNetwork.QSslError',),
-# class PySide2.QtNetwork.QSslKey:
-    "PySide2.QtNetwork.QSslKey.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QSslKey',), ('int', 'PySide2.QtNetwork.QSsl.KeyType')],
-    "PySide2.QtNetwork.QSslKey.__copy__": (),
-    "PySide2.QtNetwork.QSslKey.algorithm": (),
-    "PySide2.QtNetwork.QSslKey.clear": (),
-    "PySide2.QtNetwork.QSslKey.handle": (),
-    "PySide2.QtNetwork.QSslKey.isNull": (),
-    "PySide2.QtNetwork.QSslKey.length": (),
-    "PySide2.QtNetwork.QSslKey.swap": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslKey.toDer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.toPem": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.type": (),
-# class PySide2.QtNetwork.QSslPreSharedKeyAuthenticator:
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__init__": [(), ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',)],
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identity": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identityHint": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumIdentityLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumPreSharedKeyLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.preSharedKey": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setIdentity": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setPreSharedKey": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.swap": ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',),
-# class PySide2.QtNetwork.QSslSocket:
-# class PySide2.QtNetwork.QSslSocket.PeerVerifyMode:
-# class PySide2.QtNetwork.QSslSocket.SslMode:
-    "PySide2.QtNetwork.QSslSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QSslSocket.abort": (),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.atEnd": (),
-    "PySide2.QtNetwork.QSslSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.caCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.canReadLine": (),
-    "PySide2.QtNetwork.QSslSocket.ciphers": (),
-    "PySide2.QtNetwork.QSslSocket.close": (),
-    "PySide2.QtNetwork.QSslSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.connectToHostEncrypted": [('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol'), ('str', 'int', 'str', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.defaultCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.defaultCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.flush": (),
-    "PySide2.QtNetwork.QSslSocket.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QSslSocket.isEncrypted": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.mode": (),
-    "PySide2.QtNetwork.QSslSocket.ocspResponses": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyName": (),
-    "PySide2.QtNetwork.QSslSocket.privateKey": (),
-    "PySide2.QtNetwork.QSslSocket.protocol": (),
-    "PySide2.QtNetwork.QSslSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QSslSocket.resume": (),
-    "PySide2.QtNetwork.QSslSocket.sessionCipher": (),
-    "PySide2.QtNetwork.QSslSocket.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslSocket.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setCiphers": [('str',), ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',)],
-    "PySide2.QtNetwork.QSslSocket.setDefaultCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setDefaultCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificate": [('PySide2.QtNetwork.QSslCertificate',), ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QSslSocket.setPrivateKey": [('PySide2.QtNetwork.QSslKey',), ('str', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtNetwork.QSslSocket.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QSslSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QSslSocket.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QSslSocket.sslConfiguration": (),
-    "PySide2.QtNetwork.QSslSocket.sslErrors": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.startClientEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.startServerEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.supportsSsl": (),
-    "PySide2.QtNetwork.QSslSocket.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForEncrypted": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QSslSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QTcpServer:
-    "PySide2.QtNetwork.QTcpServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QTcpServer.addPendingConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtNetwork.QTcpServer.close": (),
-    "PySide2.QtNetwork.QTcpServer.errorString": (),
-    "PySide2.QtNetwork.QTcpServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QTcpServer.isListening": (),
-    "PySide2.QtNetwork.QTcpServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QTcpServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QTcpServer.pauseAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.proxy": (),
-    "PySide2.QtNetwork.QTcpServer.resumeAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.serverAddress": (),
-    "PySide2.QtNetwork.QTcpServer.serverError": (),
-    "PySide2.QtNetwork.QTcpServer.serverPort": (),
-    "PySide2.QtNetwork.QTcpServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QTcpServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QTcpServer.setSocketDescriptor": ('int',),
-    "PySide2.QtNetwork.QTcpServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QTcpServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QTcpSocket:
-    "PySide2.QtNetwork.QTcpSocket.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtNetwork.QUdpSocket:
-    "PySide2.QtNetwork.QUdpSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QUdpSocket.hasPendingDatagrams": (),
-    "PySide2.QtNetwork.QUdpSocket.joinMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.leaveMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.multicastInterface": (),
-    "PySide2.QtNetwork.QUdpSocket.pendingDatagramSize": (),
-    "PySide2.QtNetwork.QUdpSocket.readDatagram": ('str', 'int', 'PySide2.QtNetwork.QHostAddress'),
-    "PySide2.QtNetwork.QUdpSocket.receiveDatagram": ('int',),
-    "PySide2.QtNetwork.QUdpSocket.setMulticastInterface": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QUdpSocket.writeDatagram": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    }) if "PySide2.QtNetwork" in sys.modules else None
-# Module PySide2.QtTest
-sig_dict.update({
-# class PySide2.QtTest.QTest:
-# class PySide2.QtTest.QTest.KeyAction:
-# class PySide2.QtTest.QTest.MouseAction:
-# class PySide2.QtTest.QTest.QBenchmarkMetric:
-# class PySide2.QtTest.QTest.QTouchEventSequence:
-    "PySide2.QtTest.QTest.QTouchEventSequence.commit": ('bool',),
-    "PySide2.QtTest.QTest.QTouchEventSequence.move": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.press": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.release": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.stationary": ('int',),
-# class PySide2.QtTest.QTest.TestFailMode:
-    "PySide2.QtTest.QTest.addColumnInternal": ('int', 'str'),
-    "PySide2.QtTest.QTest.asciiToKey": ('int',),
-    "PySide2.QtTest.QTest.compare_ptr_helper": ('int', 'int', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.compare_string_helper": ('str', 'str', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.createTouchDevice": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtTest.QTest.currentAppName": (),
-    "PySide2.QtTest.QTest.currentDataTag": (),
-    "PySide2.QtTest.QTest.currentTestFailed": (),
-    "PySide2.QtTest.QTest.currentTestFunction": (),
-    "PySide2.QtTest.QTest.ignoreMessage": [('PySide2.QtCore.QtMsgType', 'PySide2.QtCore.QRegularExpression'), ('PySide2.QtCore.QtMsgType', 'str')],
-    "PySide2.QtTest.QTest.keyClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyClicks": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'),
-    "PySide2.QtTest.QTest.keyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyPress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keySequence": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtTest.QTest.keyToAscii": ('PySide2.QtCore.Qt.Key',),
-    "PySide2.QtTest.QTest.mouseClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseDClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseEvent": [('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseMove": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mousePress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.qCleanup": (),
-    "PySide2.QtTest.QTest.qElementData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qExpectFail": ('str', 'str', 'PySide2.QtTest.QTest.TestFailMode', 'str', 'int'),
-    "PySide2.QtTest.QTest.qFindTestData": ('str', 'str', 'int', 'str'),
-    "PySide2.QtTest.QTest.qGlobalData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qRun": (),
-    "PySide2.QtTest.QTest.qSkip": ('str', 'str', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowActive": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowExposed": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.sendKeyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.setBenchmarkResult": ('float', 'PySide2.QtTest.QTest.QBenchmarkMetric'),
-    "PySide2.QtTest.QTest.setMainSourcePath": ('str', 'str'),
-    "PySide2.QtTest.QTest.simulateEvent": [('PySide2.QtGui.QWindow', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'), ('PySide2.QtWidgets.QWidget', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtTest.QTest.testObject": (),
-    "PySide2.QtTest.QTest.toPrettyCString": ('str', 'int'),
-    "PySide2.QtTest.QTest.touchEvent": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QTouchDevice', 'bool'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QTouchDevice', 'bool')],
-    }) if "PySide2.QtTest" in sys.modules else None
-# Module PySide2.QtConcurrent
-sig_dict.update({
-# class PySide2.QtConcurrent.QtConcurrent:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOption:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOptions:
-# class PySide2.QtConcurrent.QtConcurrent.ThreadFunctionResult:
-    }) if "PySide2.QtConcurrent" in sys.modules else None
-# Module PySide2.QtX11Extras
-sig_dict.update({
-# class PySide2.QtX11Extras.QX11Info:
-# class PySide2.QtX11Extras.QX11Info.PeekOption:
-# class PySide2.QtX11Extras.QX11Info.PeekOptions:
-    "PySide2.QtX11Extras.QX11Info.appDpiX": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appDpiY": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appRootWindow": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appScreen": (),
-    "PySide2.QtX11Extras.QX11Info.appTime": (),
-    "PySide2.QtX11Extras.QX11Info.appUserTime": (),
-    "PySide2.QtX11Extras.QX11Info.generatePeekerId": (),
-    "PySide2.QtX11Extras.QX11Info.getTimestamp": (),
-    "PySide2.QtX11Extras.QX11Info.isCompositingManagerRunning": ('int',),
-    "PySide2.QtX11Extras.QX11Info.isPlatformX11": (),
-    "PySide2.QtX11Extras.QX11Info.nextStartupId": (),
-    "PySide2.QtX11Extras.QX11Info.removePeekerId": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setAppTime": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setAppUserTime": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setNextStartupId": ('PySide2.QtCore.QByteArray',),
-    }) if "PySide2.QtX11Extras" in sys.modules else None
-# Module PySide2.QtXml
-sig_dict.update({
-# class PySide2.QtXml.QDomAttr:
-    "PySide2.QtXml.QDomAttr.__init__": [(), ('PySide2.QtXml.QDomAttr',)],
-    "PySide2.QtXml.QDomAttr.__copy__": (),
-    "PySide2.QtXml.QDomAttr.name": (),
-    "PySide2.QtXml.QDomAttr.nodeType": (),
-    "PySide2.QtXml.QDomAttr.ownerElement": (),
-    "PySide2.QtXml.QDomAttr.setValue": ('str',),
-    "PySide2.QtXml.QDomAttr.specified": (),
-    "PySide2.QtXml.QDomAttr.value": (),
-# class PySide2.QtXml.QDomCDATASection:
-    "PySide2.QtXml.QDomCDATASection.__init__": [(), ('PySide2.QtXml.QDomCDATASection',)],
-    "PySide2.QtXml.QDomCDATASection.__copy__": (),
-    "PySide2.QtXml.QDomCDATASection.nodeType": (),
-# class PySide2.QtXml.QDomCharacterData:
-    "PySide2.QtXml.QDomCharacterData.__init__": [(), ('PySide2.QtXml.QDomCharacterData',)],
-    "PySide2.QtXml.QDomCharacterData.__copy__": (),
-    "PySide2.QtXml.QDomCharacterData.appendData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.data": (),
-    "PySide2.QtXml.QDomCharacterData.deleteData": ('int', 'int'),
-    "PySide2.QtXml.QDomCharacterData.insertData": ('int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.length": (),
-    "PySide2.QtXml.QDomCharacterData.nodeType": (),
-    "PySide2.QtXml.QDomCharacterData.replaceData": ('int', 'int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.setData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.substringData": ('int', 'int'),
-# class PySide2.QtXml.QDomComment:
-    "PySide2.QtXml.QDomComment.__init__": [(), ('PySide2.QtXml.QDomComment',)],
-    "PySide2.QtXml.QDomComment.__copy__": (),
-    "PySide2.QtXml.QDomComment.nodeType": (),
-# class PySide2.QtXml.QDomDocument:
-    "PySide2.QtXml.QDomDocument.__init__": [(), ('PySide2.QtXml.QDomDocument',), ('PySide2.QtXml.QDomDocumentType',), ('str',)],
-    "PySide2.QtXml.QDomDocument.__copy__": (),
-    "PySide2.QtXml.QDomDocument.createAttribute": ('str',),
-    "PySide2.QtXml.QDomDocument.createAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createCDATASection": ('str',),
-    "PySide2.QtXml.QDomDocument.createComment": ('str',),
-    "PySide2.QtXml.QDomDocument.createDocumentFragment": (),
-    "PySide2.QtXml.QDomDocument.createElement": ('str',),
-    "PySide2.QtXml.QDomDocument.createElementNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createEntityReference": ('str',),
-    "PySide2.QtXml.QDomDocument.createProcessingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createTextNode": ('str',),
-    "PySide2.QtXml.QDomDocument.doctype": (),
-    "PySide2.QtXml.QDomDocument.documentElement": (),
-    "PySide2.QtXml.QDomDocument.elementById": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.implementation": (),
-    "PySide2.QtXml.QDomDocument.importNode": ('PySide2.QtXml.QDomNode', 'bool'),
-    "PySide2.QtXml.QDomDocument.nodeType": (),
-    "PySide2.QtXml.QDomDocument.setContent": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'bool'), ('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QIODevice', 'bool'), ('PySide2.QtXml.QXmlInputSource', 'PySide2.QtXml.QXmlReader'), ('PySide2.QtXml.QXmlInputSource', 'bool'), ('str',), ('str', 'bool')],
-    "PySide2.QtXml.QDomDocument.toByteArray": ('int',),
-    "PySide2.QtXml.QDomDocument.toString": ('int',),
-# class PySide2.QtXml.QDomDocumentFragment:
-    "PySide2.QtXml.QDomDocumentFragment.__init__": [(), ('PySide2.QtXml.QDomDocumentFragment',)],
-    "PySide2.QtXml.QDomDocumentFragment.__copy__": (),
-    "PySide2.QtXml.QDomDocumentFragment.nodeType": (),
-# class PySide2.QtXml.QDomDocumentType:
-    "PySide2.QtXml.QDomDocumentType.__init__": [(), ('PySide2.QtXml.QDomDocumentType',)],
-    "PySide2.QtXml.QDomDocumentType.__copy__": (),
-    "PySide2.QtXml.QDomDocumentType.entities": (),
-    "PySide2.QtXml.QDomDocumentType.internalSubset": (),
-    "PySide2.QtXml.QDomDocumentType.name": (),
-    "PySide2.QtXml.QDomDocumentType.nodeType": (),
-    "PySide2.QtXml.QDomDocumentType.notations": (),
-    "PySide2.QtXml.QDomDocumentType.publicId": (),
-    "PySide2.QtXml.QDomDocumentType.systemId": (),
-# class PySide2.QtXml.QDomElement:
-    "PySide2.QtXml.QDomElement.__init__": [(), ('PySide2.QtXml.QDomElement',)],
-    "PySide2.QtXml.QDomElement.__copy__": (),
-    "PySide2.QtXml.QDomElement.attribute": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNS": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNode": ('str',),
-    "PySide2.QtXml.QDomElement.attributeNodeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributes": (),
-    "PySide2.QtXml.QDomElement.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomElement.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.hasAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.hasAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.nodeType": (),
-    "PySide2.QtXml.QDomElement.removeAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.removeAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.removeAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttribute": [('str', 'float'), ('str', 'int'), ('str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNS": [('str', 'str', 'float'), ('str', 'str', 'int'), ('str', 'str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttributeNodeNS": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setTagName": ('str',),
-    "PySide2.QtXml.QDomElement.tagName": (),
-    "PySide2.QtXml.QDomElement.text": (),
-# class PySide2.QtXml.QDomEntity:
-    "PySide2.QtXml.QDomEntity.__init__": [(), ('PySide2.QtXml.QDomEntity',)],
-    "PySide2.QtXml.QDomEntity.__copy__": (),
-    "PySide2.QtXml.QDomEntity.nodeType": (),
-    "PySide2.QtXml.QDomEntity.notationName": (),
-    "PySide2.QtXml.QDomEntity.publicId": (),
-    "PySide2.QtXml.QDomEntity.systemId": (),
-# class PySide2.QtXml.QDomEntityReference:
-    "PySide2.QtXml.QDomEntityReference.__init__": [(), ('PySide2.QtXml.QDomEntityReference',)],
-    "PySide2.QtXml.QDomEntityReference.__copy__": (),
-    "PySide2.QtXml.QDomEntityReference.nodeType": (),
-# class PySide2.QtXml.QDomImplementation:
-# class PySide2.QtXml.QDomImplementation.InvalidDataPolicy:
-    "PySide2.QtXml.QDomImplementation.__init__": [(), ('PySide2.QtXml.QDomImplementation',)],
-    "PySide2.QtXml.QDomImplementation.__copy__": (),
-    "PySide2.QtXml.QDomImplementation.createDocument": ('str', 'str', 'PySide2.QtXml.QDomDocumentType'),
-    "PySide2.QtXml.QDomImplementation.createDocumentType": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomImplementation.hasFeature": ('str', 'str'),
-    "PySide2.QtXml.QDomImplementation.invalidDataPolicy": (),
-    "PySide2.QtXml.QDomImplementation.isNull": (),
-    "PySide2.QtXml.QDomImplementation.setInvalidDataPolicy": ('PySide2.QtXml.QDomImplementation.InvalidDataPolicy',),
-# class PySide2.QtXml.QDomNamedNodeMap:
-    "PySide2.QtXml.QDomNamedNodeMap.__init__": [(), ('PySide2.QtXml.QDomNamedNodeMap',)],
-    "PySide2.QtXml.QDomNamedNodeMap.__copy__": (),
-    "PySide2.QtXml.QDomNamedNodeMap.contains": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.count": (),
-    "PySide2.QtXml.QDomNamedNodeMap.isEmpty": (),
-    "PySide2.QtXml.QDomNamedNodeMap.item": ('int',),
-    "PySide2.QtXml.QDomNamedNodeMap.length": (),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItem": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItemNS": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.size": (),
-# class PySide2.QtXml.QDomNode:
-# class PySide2.QtXml.QDomNode.EncodingPolicy:
-# class PySide2.QtXml.QDomNode.NodeType:
-    "PySide2.QtXml.QDomNode.__init__": [(), ('PySide2.QtXml.QDomNode',)],
-    "PySide2.QtXml.QDomNode.__copy__": (),
-    "PySide2.QtXml.QDomNode.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtXml.QDomNode.appendChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.attributes": (),
-    "PySide2.QtXml.QDomNode.childNodes": (),
-    "PySide2.QtXml.QDomNode.clear": (),
-    "PySide2.QtXml.QDomNode.cloneNode": ('bool',),
-    "PySide2.QtXml.QDomNode.columnNumber": (),
-    "PySide2.QtXml.QDomNode.firstChild": (),
-    "PySide2.QtXml.QDomNode.firstChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.hasAttributes": (),
-    "PySide2.QtXml.QDomNode.hasChildNodes": (),
-    "PySide2.QtXml.QDomNode.insertAfter": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.insertBefore": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.isAttr": (),
-    "PySide2.QtXml.QDomNode.isCDATASection": (),
-    "PySide2.QtXml.QDomNode.isCharacterData": (),
-    "PySide2.QtXml.QDomNode.isComment": (),
-    "PySide2.QtXml.QDomNode.isDocument": (),
-    "PySide2.QtXml.QDomNode.isDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.isDocumentType": (),
-    "PySide2.QtXml.QDomNode.isElement": (),
-    "PySide2.QtXml.QDomNode.isEntity": (),
-    "PySide2.QtXml.QDomNode.isEntityReference": (),
-    "PySide2.QtXml.QDomNode.isNotation": (),
-    "PySide2.QtXml.QDomNode.isNull": (),
-    "PySide2.QtXml.QDomNode.isProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.isSupported": ('str', 'str'),
-    "PySide2.QtXml.QDomNode.isText": (),
-    "PySide2.QtXml.QDomNode.lastChild": (),
-    "PySide2.QtXml.QDomNode.lastChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.lineNumber": (),
-    "PySide2.QtXml.QDomNode.localName": (),
-    "PySide2.QtXml.QDomNode.namedItem": ('str',),
-    "PySide2.QtXml.QDomNode.namespaceURI": (),
-    "PySide2.QtXml.QDomNode.nextSibling": (),
-    "PySide2.QtXml.QDomNode.nextSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.nodeName": (),
-    "PySide2.QtXml.QDomNode.nodeType": (),
-    "PySide2.QtXml.QDomNode.nodeValue": (),
-    "PySide2.QtXml.QDomNode.normalize": (),
-    "PySide2.QtXml.QDomNode.ownerDocument": (),
-    "PySide2.QtXml.QDomNode.parentNode": (),
-    "PySide2.QtXml.QDomNode.prefix": (),
-    "PySide2.QtXml.QDomNode.previousSibling": (),
-    "PySide2.QtXml.QDomNode.previousSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.removeChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.replaceChild": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.save": ('PySide2.QtCore.QTextStream', 'int', 'PySide2.QtXml.QDomNode.EncodingPolicy'),
-    "PySide2.QtXml.QDomNode.setNodeValue": ('str',),
-    "PySide2.QtXml.QDomNode.setPrefix": ('str',),
-    "PySide2.QtXml.QDomNode.toAttr": (),
-    "PySide2.QtXml.QDomNode.toCDATASection": (),
-    "PySide2.QtXml.QDomNode.toCharacterData": (),
-    "PySide2.QtXml.QDomNode.toComment": (),
-    "PySide2.QtXml.QDomNode.toDocument": (),
-    "PySide2.QtXml.QDomNode.toDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.toDocumentType": (),
-    "PySide2.QtXml.QDomNode.toElement": (),
-    "PySide2.QtXml.QDomNode.toEntity": (),
-    "PySide2.QtXml.QDomNode.toEntityReference": (),
-    "PySide2.QtXml.QDomNode.toNotation": (),
-    "PySide2.QtXml.QDomNode.toProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.toText": (),
-# class PySide2.QtXml.QDomNodeList:
-    "PySide2.QtXml.QDomNodeList.__init__": [(), ('PySide2.QtXml.QDomNodeList',)],
-    "PySide2.QtXml.QDomNodeList.__copy__": (),
-    "PySide2.QtXml.QDomNodeList.at": ('int',),
-    "PySide2.QtXml.QDomNodeList.count": (),
-    "PySide2.QtXml.QDomNodeList.isEmpty": (),
-    "PySide2.QtXml.QDomNodeList.item": ('int',),
-    "PySide2.QtXml.QDomNodeList.length": (),
-    "PySide2.QtXml.QDomNodeList.size": (),
-# class PySide2.QtXml.QDomNotation:
-    "PySide2.QtXml.QDomNotation.__init__": [(), ('PySide2.QtXml.QDomNotation',)],
-    "PySide2.QtXml.QDomNotation.__copy__": (),
-    "PySide2.QtXml.QDomNotation.nodeType": (),
-    "PySide2.QtXml.QDomNotation.publicId": (),
-    "PySide2.QtXml.QDomNotation.systemId": (),
-# class PySide2.QtXml.QDomProcessingInstruction:
-    "PySide2.QtXml.QDomProcessingInstruction.__init__": [(), ('PySide2.QtXml.QDomProcessingInstruction',)],
-    "PySide2.QtXml.QDomProcessingInstruction.__copy__": (),
-    "PySide2.QtXml.QDomProcessingInstruction.data": (),
-    "PySide2.QtXml.QDomProcessingInstruction.nodeType": (),
-    "PySide2.QtXml.QDomProcessingInstruction.setData": ('str',),
-    "PySide2.QtXml.QDomProcessingInstruction.target": (),
-# class PySide2.QtXml.QDomText:
-    "PySide2.QtXml.QDomText.__init__": [(), ('PySide2.QtXml.QDomText',)],
-    "PySide2.QtXml.QDomText.__copy__": (),
-    "PySide2.QtXml.QDomText.nodeType": (),
-    "PySide2.QtXml.QDomText.splitText": ('int',),
-# class PySide2.QtXml.QXmlAttributes:
-    "PySide2.QtXml.QXmlAttributes.__init__": [(), ('PySide2.QtXml.QXmlAttributes',)],
-    "PySide2.QtXml.QXmlAttributes.__copy__": (),
-    "PySide2.QtXml.QXmlAttributes.append": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlAttributes.clear": (),
-    "PySide2.QtXml.QXmlAttributes.count": (),
-    "PySide2.QtXml.QXmlAttributes.index": [('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.length": (),
-    "PySide2.QtXml.QXmlAttributes.localName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.qName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.swap": ('PySide2.QtXml.QXmlAttributes',),
-    "PySide2.QtXml.QXmlAttributes.type": [('int',), ('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.uri": ('int',),
-    "PySide2.QtXml.QXmlAttributes.value": [('int',), ('str',), ('str', 'str')],
-# class PySide2.QtXml.QXmlContentHandler:
-    "PySide2.QtXml.QXmlContentHandler.__init__": (),
-    "PySide2.QtXml.QXmlContentHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.endDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.errorString": (),
-    "PySide2.QtXml.QXmlContentHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlContentHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.startDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlContentHandler.startPrefixMapping": ('str', 'str'),
-# class PySide2.QtXml.QXmlDTDHandler:
-    "PySide2.QtXml.QXmlDTDHandler.__init__": (),
-    "PySide2.QtXml.QXmlDTDHandler.errorString": (),
-    "PySide2.QtXml.QXmlDTDHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDTDHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-# class PySide2.QtXml.QXmlDeclHandler:
-    "PySide2.QtXml.QXmlDeclHandler.__init__": (),
-    "PySide2.QtXml.QXmlDeclHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.errorString": (),
-    "PySide2.QtXml.QXmlDeclHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.internalEntityDecl": ('str', 'str'),
-# class PySide2.QtXml.QXmlDefaultHandler:
-    "PySide2.QtXml.QXmlDefaultHandler.__init__": (),
-    "PySide2.QtXml.QXmlDefaultHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDTD": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.errorString": (),
-    "PySide2.QtXml.QXmlDefaultHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.internalEntityDecl": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-    "PySide2.QtXml.QXmlDefaultHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlDefaultHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.startDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlDefaultHandler.startEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startPrefixMapping": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlEntityResolver:
-    "PySide2.QtXml.QXmlEntityResolver.__init__": (),
-    "PySide2.QtXml.QXmlEntityResolver.errorString": (),
-    "PySide2.QtXml.QXmlEntityResolver.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-# class PySide2.QtXml.QXmlErrorHandler:
-    "PySide2.QtXml.QXmlErrorHandler.__init__": (),
-    "PySide2.QtXml.QXmlErrorHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.errorString": (),
-    "PySide2.QtXml.QXmlErrorHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlInputSource:
-    "PySide2.QtXml.QXmlInputSource.__init__": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtXml.QXmlInputSource.data": (),
-    "PySide2.QtXml.QXmlInputSource.fetchData": (),
-    "PySide2.QtXml.QXmlInputSource.fromRawData": ('PySide2.QtCore.QByteArray', 'bool'),
-    "PySide2.QtXml.QXmlInputSource.reset": (),
-    "PySide2.QtXml.QXmlInputSource.setData": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtXml.QXmlLexicalHandler:
-    "PySide2.QtXml.QXmlLexicalHandler.__init__": (),
-    "PySide2.QtXml.QXmlLexicalHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endDTD": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.errorString": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlLexicalHandler.startEntity": ('str',),
-# class PySide2.QtXml.QXmlLocator:
-    "PySide2.QtXml.QXmlLocator.__init__": (),
-    "PySide2.QtXml.QXmlLocator.columnNumber": (),
-    "PySide2.QtXml.QXmlLocator.lineNumber": (),
-# class PySide2.QtXml.QXmlNamespaceSupport:
-    "PySide2.QtXml.QXmlNamespaceSupport.__init__": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.popContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefix": ('str',),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefixes": [(), ('str',)],
-    "PySide2.QtXml.QXmlNamespaceSupport.processName": ('str', 'bool', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.pushContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.reset": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.setPrefix": ('str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.splitName": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.uri": ('str',),
-# class PySide2.QtXml.QXmlParseException:
-    "PySide2.QtXml.QXmlParseException.__init__": [('PySide2.QtXml.QXmlParseException',), ('str', 'int', 'int', 'str', 'str')],
-    "PySide2.QtXml.QXmlParseException.columnNumber": (),
-    "PySide2.QtXml.QXmlParseException.lineNumber": (),
-    "PySide2.QtXml.QXmlParseException.message": (),
-    "PySide2.QtXml.QXmlParseException.publicId": (),
-    "PySide2.QtXml.QXmlParseException.systemId": (),
-# class PySide2.QtXml.QXmlReader:
-    "PySide2.QtXml.QXmlReader.__init__": (),
-    "PySide2.QtXml.QXmlReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlReader.contentHandler": (),
-    "PySide2.QtXml.QXmlReader.declHandler": (),
-    "PySide2.QtXml.QXmlReader.entityResolver": (),
-    "PySide2.QtXml.QXmlReader.errorHandler": (),
-    "PySide2.QtXml.QXmlReader.feature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlReader.parse": ('PySide2.QtXml.QXmlInputSource',),
-    "PySide2.QtXml.QXmlReader.property": ('str',),
-    "PySide2.QtXml.QXmlReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlReader.setProperty": ('str', 'int'),
-# class PySide2.QtXml.QXmlSimpleReader:
-    "PySide2.QtXml.QXmlSimpleReader.__init__": (),
-    "PySide2.QtXml.QXmlSimpleReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.contentHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.declHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.entityResolver": (),
-    "PySide2.QtXml.QXmlSimpleReader.errorHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.feature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.parse": [('PySide2.QtXml.QXmlInputSource',), ('PySide2.QtXml.QXmlInputSource', 'bool')],
-    "PySide2.QtXml.QXmlSimpleReader.parseContinue": (),
-    "PySide2.QtXml.QXmlSimpleReader.property": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlSimpleReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlSimpleReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setProperty": ('str', 'int'),
-    }) if "PySide2.QtXml" in sys.modules else None
-# Module PySide2.QtXmlPatterns
-sig_dict.update({
-# class PySide2.QtXmlPatterns.QAbstractMessageHandler:
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.handleMessage": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.message": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-# class PySide2.QtXmlPatterns.QAbstractUriResolver:
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.resolve": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.NodeCopySetting:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis:
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.attributes": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.baseUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.compareOrder": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.createIndex": [('int',), ('int', 'int')],
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.documentUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.elementById": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.isDeepEqual": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.kind": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.name": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceBindings": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceForPrefix": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode")'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nextFromSimpleAxis": ('PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nodesByIdref": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.root": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sendNamespaces": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QAbstractXmlReceiver'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sourceLocation": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.stringValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.typedValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-# class PySide2.QtXmlPatterns.QAbstractXmlReceiver:
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.characters": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.comment": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endElement": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.whitespaceOnly": ('str',),
-# class PySide2.QtXmlPatterns.QSourceLocation:
-    "PySide2.QtXmlPatterns.QSourceLocation.__init__": [(), ('PySide2.QtCore.QUrl', 'int', 'int'), ('PySide2.QtXmlPatterns.QSourceLocation',)],
-    "PySide2.QtXmlPatterns.QSourceLocation.__copy__": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.column": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.isNull": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.line": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.setColumn": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setLine": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setUri": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtXmlPatterns.QSourceLocation.uri": (),
-# class PySide2.QtXmlPatterns.QXmlFormatter:
-    "PySide2.QtXmlPatterns.QXmlFormatter.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.indentationDepth": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.setIndentationDepth": ('int',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startOfSequence": (),
-# class PySide2.QtXmlPatterns.QXmlItem:
-    "PySide2.QtXmlPatterns.QXmlItem.__init__": [(), ('PySide2.QtXmlPatterns.QXmlItem',), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',), ('typing.Any',)],
-    "PySide2.QtXmlPatterns.QXmlItem.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNode": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toNodeModelIndex": (),
-# class PySide2.QtXmlPatterns.QXmlName:
-    "PySide2.QtXmlPatterns.QXmlName.__init__": [(), ('PySide2.QtXmlPatterns.QXmlName',), ('PySide2.QtXmlPatterns.QXmlNamePool', 'str', 'str', 'str')],
-    "PySide2.QtXmlPatterns.QXmlName.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlName.fromClarkName": ('str', 'PySide2.QtXmlPatterns.QXmlNamePool'),
-    "PySide2.QtXmlPatterns.QXmlName.isNCName": ('str',),
-    "PySide2.QtXmlPatterns.QXmlName.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlName.localName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.namespaceUri": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.prefix": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.toClarkName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-# class PySide2.QtXmlPatterns.QXmlNamePool:
-    "PySide2.QtXmlPatterns.QXmlNamePool.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',)],
-    "PySide2.QtXmlPatterns.QXmlNamePool.__copy__": (),
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.DocumentOrder:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.NodeKind:
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',)],
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.additionalData": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.data": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.internalPointer": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.model": (),
-# class PySide2.QtXmlPatterns.QXmlQuery:
-# class PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage:
-    "PySide2.QtXmlPatterns.QXmlQuery.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',), ('PySide2.QtXmlPatterns.QXmlQuery',), ('PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage', 'PySide2.QtXmlPatterns.QXmlNamePool')],
-    "PySide2.QtXmlPatterns.QXmlQuery.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.bindVariable": [('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtCore.QIODevice'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlItem'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlQuery'), ('str', 'PySide2.QtCore.QIODevice'), ('str', 'PySide2.QtXmlPatterns.QXmlItem'), ('str', 'PySide2.QtXmlPatterns.QXmlQuery')],
-    "PySide2.QtXmlPatterns.QXmlQuery.evaluateTo": [('PySide2.QtCore.QIODevice',), ('PySide2.QtXmlPatterns.QAbstractXmlReceiver',), ('PySide2.QtXmlPatterns.QXmlResultItems',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.initialTemplateName": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.queryLanguage": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.setFocus": [('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QUrl',), ('PySide2.QtXmlPatterns.QXmlItem',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setInitialTemplateName": [('PySide2.QtXmlPatterns.QXmlName',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlQuery.setQuery": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'), ('str', 'PySide2.QtCore.QUrl')],
-    "PySide2.QtXmlPatterns.QXmlQuery.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlQuery.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlResultItems:
-    "PySide2.QtXmlPatterns.QXmlResultItems.__init__": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.current": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.hasError": (),
-# class PySide2.QtXmlPatterns.QXmlSchema:
-    "PySide2.QtXmlPatterns.QXmlSchema.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.documentUri": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.load": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchema.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchema.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlSchemaValidator:
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.schema": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setSchema": ('PySide2.QtXmlPatterns.QXmlSchema',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.uriResolver": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.validate": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-# class PySide2.QtXmlPatterns.QXmlSerializer:
-    "PySide2.QtXmlPatterns.QXmlSerializer.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.codec": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.outputDevice": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startOfSequence": (),
-    }) if "PySide2.QtXmlPatterns" in sys.modules else None
-# Module PySide2.QtHelp
-sig_dict.update({
-# class PySide2.QtHelp.QCompressedHelpInfo:
-    "PySide2.QtHelp.QCompressedHelpInfo.__init__": [(), ('PySide2.QtHelp.QCompressedHelpInfo',)],
-    "PySide2.QtHelp.QCompressedHelpInfo.__copy__": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.component": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.fromCompressedHelpFile": ('str',),
-    "PySide2.QtHelp.QCompressedHelpInfo.namespaceName": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.swap": ('PySide2.QtHelp.QCompressedHelpInfo',),
-    "PySide2.QtHelp.QCompressedHelpInfo.version": (),
-# class PySide2.QtHelp.QHelpContentItem:
-    "PySide2.QtHelp.QHelpContentItem.__copy__": (),
-    "PySide2.QtHelp.QHelpContentItem.child": ('int',),
-    "PySide2.QtHelp.QHelpContentItem.childCount": (),
-    "PySide2.QtHelp.QHelpContentItem.childPosition": ('PySide2.QtHelp.QHelpContentItem',),
-    "PySide2.QtHelp.QHelpContentItem.parent": (),
-    "PySide2.QtHelp.QHelpContentItem.row": (),
-    "PySide2.QtHelp.QHelpContentItem.title": (),
-    "PySide2.QtHelp.QHelpContentItem.url": (),
-# class PySide2.QtHelp.QHelpContentModel:
-    "PySide2.QtHelp.QHelpContentModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.contentItemAt": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.createContents": ('str',),
-    "PySide2.QtHelp.QHelpContentModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtHelp.QHelpContentModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtHelp.QHelpContentModel.isCreatingContents": (),
-    "PySide2.QtHelp.QHelpContentModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtHelp.QHelpContentModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtHelp.QHelpContentWidget:
-    "PySide2.QtHelp.QHelpContentWidget.indexOf": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtHelp.QHelpEngine:
-    "PySide2.QtHelp.QHelpEngine.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngine.contentModel": (),
-    "PySide2.QtHelp.QHelpEngine.contentWidget": (),
-    "PySide2.QtHelp.QHelpEngine.indexModel": (),
-    "PySide2.QtHelp.QHelpEngine.indexWidget": (),
-    "PySide2.QtHelp.QHelpEngine.searchEngine": (),
-# class PySide2.QtHelp.QHelpEngineCore:
-    "PySide2.QtHelp.QHelpEngineCore.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngineCore.addCustomFilter": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtHelp.QHelpEngineCore.autoSaveFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.collectionFile": (),
-    "PySide2.QtHelp.QHelpEngineCore.copyCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.currentFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.customFilters": (),
-    "PySide2.QtHelp.QHelpEngineCore.customValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.documentationFileName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.error": (),
-    "PySide2.QtHelp.QHelpEngineCore.fileData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.files": [('str', 'str', 'str'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributeSets": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributes": [(), ('str',)],
-    "PySide2.QtHelp.QHelpEngineCore.filterEngine": (),
-    "PySide2.QtHelp.QHelpEngineCore.findFile": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForIdentifier": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForKeyword": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.metaData": ('str', 'str'),
-    "PySide2.QtHelp.QHelpEngineCore.namespaceName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registerDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registeredDocumentations": (),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomValue": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setAutoSaveFilter": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCurrentFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCustomValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.setUsesFilterEngine": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setupData": (),
-    "PySide2.QtHelp.QHelpEngineCore.unregisterDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.usesFilterEngine": (),
-# class PySide2.QtHelp.QHelpFilterData:
-    "PySide2.QtHelp.QHelpFilterData.__init__": [(), ('PySide2.QtHelp.QHelpFilterData',)],
-    "PySide2.QtHelp.QHelpFilterData.__copy__": (),
-    "PySide2.QtHelp.QHelpFilterData.components": (),
-    "PySide2.QtHelp.QHelpFilterData.setComponents": ('typing.Sequence[str]',),
-    "PySide2.QtHelp.QHelpFilterData.setVersions": ('typing.Sequence[PySide2.QtCore.QVersionNumber]',),
-    "PySide2.QtHelp.QHelpFilterData.swap": ('PySide2.QtHelp.QHelpFilterData',),
-    "PySide2.QtHelp.QHelpFilterData.versions": (),
-# class PySide2.QtHelp.QHelpFilterEngine:
-    "PySide2.QtHelp.QHelpFilterEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore',),
-    "PySide2.QtHelp.QHelpFilterEngine.activeFilter": (),
-    "PySide2.QtHelp.QHelpFilterEngine.availableComponents": (),
-    "PySide2.QtHelp.QHelpFilterEngine.filterData": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.filters": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToComponent": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToVersion": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespacesForFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.removeFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setActiveFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setFilterData": ('str', 'PySide2.QtHelp.QHelpFilterData'),
-# class PySide2.QtHelp.QHelpIndexModel:
-    "PySide2.QtHelp.QHelpIndexModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object'), ('str',)],
-    "PySide2.QtHelp.QHelpIndexModel.filter": ('str', 'str'),
-    "PySide2.QtHelp.QHelpIndexModel.isCreatingIndex": (),
-    "PySide2.QtHelp.QHelpIndexModel.linksForKeyword": ('str',),
-# class PySide2.QtHelp.QHelpIndexWidget:
-    "PySide2.QtHelp.QHelpIndexWidget.activateCurrentItem": (),
-    "PySide2.QtHelp.QHelpIndexWidget.filterIndices": ('str', 'str'),
-# class PySide2.QtHelp.QHelpSearchEngine:
-    "PySide2.QtHelp.QHelpSearchEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelIndexing": (),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelSearching": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hitCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hits": ('int', 'int'),
-    "PySide2.QtHelp.QHelpSearchEngine.hitsCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.query": (),
-    "PySide2.QtHelp.QHelpSearchEngine.queryWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.reindexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.resultWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.scheduleIndexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.search": [('str',), ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',)],
-    "PySide2.QtHelp.QHelpSearchEngine.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResultCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResults": ('int', 'int'),
-# class PySide2.QtHelp.QHelpSearchQuery:
-# class PySide2.QtHelp.QHelpSearchQuery.FieldName:
-    "PySide2.QtHelp.QHelpSearchQuery.__init__": [(), ('PySide2.QtHelp.QHelpSearchQuery',), ('PySide2.QtHelp.QHelpSearchQuery.FieldName', 'typing.Sequence[str]')],
-    "PySide2.QtHelp.QHelpSearchQuery.__copy__": (),
-# class PySide2.QtHelp.QHelpSearchQueryWidget:
-    "PySide2.QtHelp.QHelpSearchQueryWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.collapseExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.expandExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.isCompactMode": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.query": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setCompactMode": ('bool',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setQuery": ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setSearchInput": ('str',),
-# class PySide2.QtHelp.QHelpSearchResult:
-    "PySide2.QtHelp.QHelpSearchResult.__init__": [(), ('PySide2.QtCore.QUrl', 'str', 'str'), ('PySide2.QtHelp.QHelpSearchResult',)],
-    "PySide2.QtHelp.QHelpSearchResult.snippet": (),
-    "PySide2.QtHelp.QHelpSearchResult.title": (),
-    "PySide2.QtHelp.QHelpSearchResult.url": (),
-# class PySide2.QtHelp.QHelpSearchResultWidget:
-    "PySide2.QtHelp.QHelpSearchResultWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchResultWidget.linkAt": ('PySide2.QtCore.QPoint',),
-    }) if "PySide2.QtHelp" in sys.modules else None
-# Module PySide2.QtMultimedia
-sig_dict.update({
-# class PySide2.QtMultimedia.QAbstractAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAbstractAudioInput:
-    "PySide2.QtMultimedia.QAbstractAudioInput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioInput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAbstractAudioOutput:
-    "PySide2.QtMultimedia.QAbstractAudioOutput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAbstractVideoBuffer:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode:
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.__init__": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handle": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handleType": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.mapMode": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.release": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.unmap": (),
-# class PySide2.QtMultimedia.QAbstractVideoFilter:
-    "PySide2.QtMultimedia.QAbstractVideoFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.createFilterRunnable": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.setActive": ('bool',),
-# class PySide2.QtMultimedia.QAbstractVideoSurface:
-# class PySide2.QtMultimedia.QAbstractVideoSurface.Error:
-    "PySide2.QtMultimedia.QAbstractVideoSurface.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.error": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isFormatSupported": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nativeResolution": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nearestFormat": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.present": ('PySide2.QtMultimedia.QVideoFrame',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setError": ('PySide2.QtMultimedia.QAbstractVideoSurface.Error',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setNativeResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.start": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.stop": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.supportedPixelFormats": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.surfaceFormat": (),
-# class PySide2.QtMultimedia.QAudio:
-# class PySide2.QtMultimedia.QAudio.Error:
-# class PySide2.QtMultimedia.QAudio.Mode:
-# class PySide2.QtMultimedia.QAudio.Role:
-# class PySide2.QtMultimedia.QAudio.State:
-# class PySide2.QtMultimedia.QAudio.VolumeScale:
-    "PySide2.QtMultimedia.QAudio.convertVolume": ('float', 'PySide2.QtMultimedia.QAudio.VolumeScale', 'PySide2.QtMultimedia.QAudio.VolumeScale'),
-# class PySide2.QtMultimedia.QAudioBuffer:
-    "PySide2.QtMultimedia.QAudioBuffer.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtMultimedia.QAudioFormat', 'int'), ('PySide2.QtMultimedia.QAudioBuffer',), ('int', 'PySide2.QtMultimedia.QAudioFormat', 'int')],
-    "PySide2.QtMultimedia.QAudioBuffer.__copy__": (),
-    "PySide2.QtMultimedia.QAudioBuffer.byteCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.constData": (),
-    "PySide2.QtMultimedia.QAudioBuffer.data": (),
-    "PySide2.QtMultimedia.QAudioBuffer.duration": (),
-    "PySide2.QtMultimedia.QAudioBuffer.format": (),
-    "PySide2.QtMultimedia.QAudioBuffer.frameCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.isValid": (),
-    "PySide2.QtMultimedia.QAudioBuffer.sampleCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.startTime": (),
-# class PySide2.QtMultimedia.QAudioDecoder:
-# class PySide2.QtMultimedia.QAudioDecoder.Error:
-# class PySide2.QtMultimedia.QAudioDecoder.State:
-    "PySide2.QtMultimedia.QAudioDecoder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoder.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoder.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoder.error": (),
-    "PySide2.QtMultimedia.QAudioDecoder.errorString": (),
-    "PySide2.QtMultimedia.QAudioDecoder.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QAudioDecoder.position": (),
-    "PySide2.QtMultimedia.QAudioDecoder.read": (),
-    "PySide2.QtMultimedia.QAudioDecoder.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoder.start": (),
-    "PySide2.QtMultimedia.QAudioDecoder.state": (),
-    "PySide2.QtMultimedia.QAudioDecoder.stop": (),
-    "PySide2.QtMultimedia.QAudioDecoder.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QAudioDecoderControl:
-    "PySide2.QtMultimedia.QAudioDecoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.position": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.read": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.start": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.state": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.stop": (),
-# class PySide2.QtMultimedia.QAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__init__": [(), ('PySide2.QtMultimedia.QAudioDeviceInfo',)],
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__copy__": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.availableDevices": ('PySide2.QtMultimedia.QAudio.Mode',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultInputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultOutputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isNull": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.nearestFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.realm": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAudioEncoderSettings:
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QAudioEncoderSettings',)],
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.channelCount": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setSampleRate": ('int',),
-# class PySide2.QtMultimedia.QAudioEncoderSettingsControl:
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.audioSettings": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.codecDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.supportedAudioCodecs": (),
-# class PySide2.QtMultimedia.QAudioFormat:
-# class PySide2.QtMultimedia.QAudioFormat.Endian:
-# class PySide2.QtMultimedia.QAudioFormat.SampleType:
-    "PySide2.QtMultimedia.QAudioFormat.__init__": [(), ('PySide2.QtMultimedia.QAudioFormat',)],
-    "PySide2.QtMultimedia.QAudioFormat.__copy__": (),
-    "PySide2.QtMultimedia.QAudioFormat.byteOrder": (),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesPerFrame": (),
-    "PySide2.QtMultimedia.QAudioFormat.channelCount": (),
-    "PySide2.QtMultimedia.QAudioFormat.codec": (),
-    "PySide2.QtMultimedia.QAudioFormat.durationForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.durationForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.isValid": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleSize": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleType": (),
-    "PySide2.QtMultimedia.QAudioFormat.setByteOrder": ('PySide2.QtMultimedia.QAudioFormat.Endian',),
-    "PySide2.QtMultimedia.QAudioFormat.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleSize": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleType": ('PySide2.QtMultimedia.QAudioFormat.SampleType',),
-# class PySide2.QtMultimedia.QAudioInput:
-    "PySide2.QtMultimedia.QAudioInput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.error": (),
-    "PySide2.QtMultimedia.QAudioInput.format": (),
-    "PySide2.QtMultimedia.QAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioInput.state": (),
-    "PySide2.QtMultimedia.QAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAudioInputSelectorControl:
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.activeInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.availableInputs": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.defaultInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.inputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.setActiveInput": ('str',),
-# class PySide2.QtMultimedia.QAudioOutput:
-    "PySide2.QtMultimedia.QAudioOutput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAudioOutputSelectorControl:
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.activeOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.availableOutputs": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.defaultOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.outputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.setActiveOutput": ('str',),
-# class PySide2.QtMultimedia.QAudioProbe:
-    "PySide2.QtMultimedia.QAudioProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioProbe.isActive": (),
-    "PySide2.QtMultimedia.QAudioProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QAudioRecorder:
-    "PySide2.QtMultimedia.QAudioRecorder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputs": (),
-    "PySide2.QtMultimedia.QAudioRecorder.defaultAudioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.setAudioInput": ('str',),
-# class PySide2.QtMultimedia.QAudioRoleControl:
-    "PySide2.QtMultimedia.QAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRoleControl.audioRole": (),
-    "PySide2.QtMultimedia.QAudioRoleControl.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QAudioRoleControl.supportedAudioRoles": (),
-# class PySide2.QtMultimedia.QCamera:
-# class PySide2.QtMultimedia.QCamera.CaptureMode:
-# class PySide2.QtMultimedia.QCamera.CaptureModes:
-# class PySide2.QtMultimedia.QCamera.Error:
-# class PySide2.QtMultimedia.QCamera.FrameRateRange:
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__init__": [(), ('PySide2.QtMultimedia.QCamera.FrameRateRange',), ('float', 'float')],
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__copy__": (),
-# class PySide2.QtMultimedia.QCamera.LockChangeReason:
-# class PySide2.QtMultimedia.QCamera.LockStatus:
-# class PySide2.QtMultimedia.QCamera.LockType:
-# class PySide2.QtMultimedia.QCamera.LockTypes:
-# class PySide2.QtMultimedia.QCamera.Position:
-# class PySide2.QtMultimedia.QCamera.State:
-# class PySide2.QtMultimedia.QCamera.Status:
-    "PySide2.QtMultimedia.QCamera.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QCamera.Position', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QCameraInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QCamera.availability": (),
-    "PySide2.QtMultimedia.QCamera.availableDevices": (),
-    "PySide2.QtMultimedia.QCamera.captureMode": (),
-    "PySide2.QtMultimedia.QCamera.deviceDescription": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QCamera.error": (),
-    "PySide2.QtMultimedia.QCamera.errorString": (),
-    "PySide2.QtMultimedia.QCamera.exposure": (),
-    "PySide2.QtMultimedia.QCamera.focus": (),
-    "PySide2.QtMultimedia.QCamera.imageProcessing": (),
-    "PySide2.QtMultimedia.QCamera.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.load": (),
-    "PySide2.QtMultimedia.QCamera.lockStatus": [(), ('PySide2.QtMultimedia.QCamera.LockType',)],
-    "PySide2.QtMultimedia.QCamera.requestedLocks": (),
-    "PySide2.QtMultimedia.QCamera.searchAndLock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.setViewfinder": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QCamera.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.start": (),
-    "PySide2.QtMultimedia.QCamera.state": (),
-    "PySide2.QtMultimedia.QCamera.status": (),
-    "PySide2.QtMultimedia.QCamera.stop": (),
-    "PySide2.QtMultimedia.QCamera.supportedLocks": (),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderFrameRateRanges": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderPixelFormats": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderResolutions": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.unload": (),
-    "PySide2.QtMultimedia.QCamera.unlock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraCaptureBufferFormatControl:
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.supportedBufferFormats": (),
-# class PySide2.QtMultimedia.QCameraCaptureDestinationControl:
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-# class PySide2.QtMultimedia.QCameraControl:
-# class PySide2.QtMultimedia.QCameraControl.PropertyChangeType:
-    "PySide2.QtMultimedia.QCameraControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraControl.canChangeProperty": ('PySide2.QtMultimedia.QCameraControl.PropertyChangeType', 'PySide2.QtMultimedia.QCamera.Status'),
-    "PySide2.QtMultimedia.QCameraControl.captureMode": (),
-    "PySide2.QtMultimedia.QCameraControl.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setState": ('PySide2.QtMultimedia.QCamera.State',),
-    "PySide2.QtMultimedia.QCameraControl.state": (),
-    "PySide2.QtMultimedia.QCameraControl.status": (),
-# class PySide2.QtMultimedia.QCameraExposure:
-# class PySide2.QtMultimedia.QCameraExposure.ExposureMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashModes:
-# class PySide2.QtMultimedia.QCameraExposure.MeteringMode:
-    "PySide2.QtMultimedia.QCameraExposure.aperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureCompensation": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.flashMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraExposure.isExposureModeSupported": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraExposure.isMeteringModeSupported": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.meteringMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureCompensation": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureMode": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualAperture": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualIsoSensitivity": ('int',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualShutterSpeed": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setMeteringMode": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setSpotMeteringPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraExposure.shutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.spotMeteringPoint": (),
-# class PySide2.QtMultimedia.QCameraExposureControl:
-# class PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter:
-    "PySide2.QtMultimedia.QCameraExposureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraExposureControl.actualValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.requestedValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.setValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraFeedbackControl:
-# class PySide2.QtMultimedia.QCameraFeedbackControl.EventType:
-    "PySide2.QtMultimedia.QCameraFeedbackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackLocked": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.resetEventFeedback": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'bool'),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackSound": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'str'),
-# class PySide2.QtMultimedia.QCameraFlashControl:
-    "PySide2.QtMultimedia.QCameraFlashControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFlashControl.flashMode": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-# class PySide2.QtMultimedia.QCameraFocus:
-# class PySide2.QtMultimedia.QCameraFocus.FocusMode:
-# class PySide2.QtMultimedia.QCameraFocus.FocusModes:
-# class PySide2.QtMultimedia.QCameraFocus.FocusPointMode:
-    "PySide2.QtMultimedia.QCameraFocus.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocus.digitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocus.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.opticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCameraFocusControl:
-    "PySide2.QtMultimedia.QCameraFocusControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFocusControl.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-# class PySide2.QtMultimedia.QCameraFocusZone:
-# class PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus:
-    "PySide2.QtMultimedia.QCameraFocusZone.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus'), ('PySide2.QtMultimedia.QCameraFocusZone',)],
-    "PySide2.QtMultimedia.QCameraFocusZone.__copy__": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.area": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.isValid": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.setStatus": ('PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus',),
-    "PySide2.QtMultimedia.QCameraFocusZone.status": (),
-# class PySide2.QtMultimedia.QCameraImageCapture:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestination:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations:
-# class PySide2.QtMultimedia.QCameraImageCapture.DriveMode:
-# class PySide2.QtMultimedia.QCameraImageCapture.Error:
-    "PySide2.QtMultimedia.QCameraImageCapture.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QCameraImageCapture.availability": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.encodingSettings": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.error": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.errorString": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.mediaObject": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setEncodingSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedBufferFormats": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QCameraImageCaptureControl:
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.driveMode": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.setDriveMode": ('PySide2.QtMultimedia.QCameraImageCapture.DriveMode',),
-# class PySide2.QtMultimedia.QCameraImageProcessing:
-# class PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter:
-# class PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode:
-    "PySide2.QtMultimedia.QCameraImageProcessing.brightness": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.colorFilter": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.contrast": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.denoisingLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isColorFilterSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isWhiteBalanceModeSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.manualWhiteBalance": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.saturation": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setBrightness": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setColorFilter": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setContrast": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setDenoisingLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setManualWhiteBalance": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSaturation": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSharpeningLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setWhiteBalanceMode": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.sharpeningLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.whiteBalanceMode": (),
-# class PySide2.QtMultimedia.QCameraImageProcessingControl:
-# class PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter:
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterValueSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.parameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.setParameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraInfo:
-    "PySide2.QtMultimedia.QCameraInfo.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera',), ('PySide2.QtMultimedia.QCameraInfo',)],
-    "PySide2.QtMultimedia.QCameraInfo.__copy__": (),
-    "PySide2.QtMultimedia.QCameraInfo.availableCameras": ('PySide2.QtMultimedia.QCamera.Position',),
-    "PySide2.QtMultimedia.QCameraInfo.defaultCamera": (),
-    "PySide2.QtMultimedia.QCameraInfo.description": (),
-    "PySide2.QtMultimedia.QCameraInfo.deviceName": (),
-    "PySide2.QtMultimedia.QCameraInfo.isNull": (),
-    "PySide2.QtMultimedia.QCameraInfo.orientation": (),
-    "PySide2.QtMultimedia.QCameraInfo.position": (),
-# class PySide2.QtMultimedia.QCameraInfoControl:
-    "PySide2.QtMultimedia.QCameraInfoControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraOrientation": ('str',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraPosition": ('str',),
-# class PySide2.QtMultimedia.QCameraLocksControl:
-    "PySide2.QtMultimedia.QCameraLocksControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraLocksControl.lockStatus": ('PySide2.QtMultimedia.QCamera.LockType',),
-    "PySide2.QtMultimedia.QCameraLocksControl.searchAndLock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-    "PySide2.QtMultimedia.QCameraLocksControl.supportedLocks": (),
-    "PySide2.QtMultimedia.QCameraLocksControl.unlock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettings:
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__init__": [(), ('PySide2.QtMultimedia.QCameraViewfinderSettings',)],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.isNull": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.maximumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.minimumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelFormat": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.resolution": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMaximumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMinimumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.swap": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl:
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.isViewfinderParameterSupported": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.setViewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.viewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl2:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.supportedViewfinderSettings": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraZoomControl:
-    "PySide2.QtMultimedia.QCameraZoomControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCustomAudioRoleControl:
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.customAudioRole": (),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.supportedCustomAudioRoles": (),
-# class PySide2.QtMultimedia.QImageEncoderControl:
-    "PySide2.QtMultimedia.QImageEncoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageSettings": (),
-    "PySide2.QtMultimedia.QImageEncoderControl.setImageSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QImageEncoderControl.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QImageEncoderSettings:
-    "PySide2.QtMultimedia.QImageEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QImageEncoderSettings',)],
-    "PySide2.QtMultimedia.QImageEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QMediaAudioProbeControl:
-    "PySide2.QtMultimedia.QMediaAudioProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaAvailabilityControl:
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.availability": (),
-# class PySide2.QtMultimedia.QMediaBindableInterface:
-    "PySide2.QtMultimedia.QMediaBindableInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimedia.QMediaContainerControl:
-    "PySide2.QtMultimedia.QMediaContainerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaContainerControl.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.supportedContainers": (),
-# class PySide2.QtMultimedia.QMediaContent:
-    "PySide2.QtMultimedia.QMediaContent.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtMultimedia.QMediaContent',), ('PySide2.QtMultimedia.QMediaPlaylist', 'PySide2.QtCore.QUrl', 'bool'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest',), ('typing.Sequence[PySide2.QtMultimedia.QMediaResource]',)],
-    "PySide2.QtMultimedia.QMediaContent.__copy__": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalRequest": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalResource": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalUrl": (),
-    "PySide2.QtMultimedia.QMediaContent.isNull": (),
-    "PySide2.QtMultimedia.QMediaContent.playlist": (),
-    "PySide2.QtMultimedia.QMediaContent.request": (),
-    "PySide2.QtMultimedia.QMediaContent.resources": (),
-# class PySide2.QtMultimedia.QMediaControl:
-    "PySide2.QtMultimedia.QMediaControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaGaplessPlaybackControl:
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.crossfadeTime": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.isCrossfadeSupported": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.nextMedia": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setCrossfadeTime": ('float',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setNextMedia": ('PySide2.QtMultimedia.QMediaContent',),
-# class PySide2.QtMultimedia.QMediaNetworkAccessControl:
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.currentConfiguration": (),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.setConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-# class PySide2.QtMultimedia.QMediaObject:
-    "PySide2.QtMultimedia.QMediaObject.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaService'),
-    "PySide2.QtMultimedia.QMediaObject.addPropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.availability": (),
-    "PySide2.QtMultimedia.QMediaObject.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaObject.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaObject.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaObject.notifyInterval": (),
-    "PySide2.QtMultimedia.QMediaObject.removePropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.service": (),
-    "PySide2.QtMultimedia.QMediaObject.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QMediaObject.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaPlayer:
-# class PySide2.QtMultimedia.QMediaPlayer.Error:
-# class PySide2.QtMultimedia.QMediaPlayer.Flag:
-# class PySide2.QtMultimedia.QMediaPlayer.Flags:
-# class PySide2.QtMultimedia.QMediaPlayer.MediaStatus:
-# class PySide2.QtMultimedia.QMediaPlayer.State:
-    "PySide2.QtMultimedia.QMediaPlayer.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.audioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.availability": (),
-    "PySide2.QtMultimedia.QMediaPlayer.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentNetworkConfiguration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.customAudioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.error": (),
-    "PySide2.QtMultimedia.QMediaPlayer.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlayer.hasSupport": ('str', 'typing.Sequence[str]', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.media": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayer.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayer.play": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playlist": (),
-    "PySide2.QtMultimedia.QMediaPlayer.position": (),
-    "PySide2.QtMultimedia.QMediaPlayer.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QMediaPlayer.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QMediaPlayer.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayer.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayer.setNetworkConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaylist": ('PySide2.QtMultimedia.QMediaPlaylist',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.setVideoOutput": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QMediaPlayer.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.state": (),
-    "PySide2.QtMultimedia.QMediaPlayer.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedCustomAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedMimeTypes": ('PySide2.QtMultimedia.QMediaPlayer.Flags',),
-    "PySide2.QtMultimedia.QMediaPlayer.unbind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.volume": (),
-# class PySide2.QtMultimedia.QMediaPlayerControl:
-    "PySide2.QtMultimedia.QMediaPlayerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.availablePlaybackRanges": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.media": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.play": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.position": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.state": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.volume": (),
-# class PySide2.QtMultimedia.QMediaPlaylist:
-# class PySide2.QtMultimedia.QMediaPlaylist.Error:
-# class PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode:
-    "PySide2.QtMultimedia.QMediaPlaylist.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.addMedia": [('PySide2.QtMultimedia.QMediaContent',), ('typing.Sequence[PySide2.QtMultimedia.QMediaContent]',)],
-    "PySide2.QtMultimedia.QMediaPlaylist.clear": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentIndex": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.error": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.insertMedia": [('int', 'PySide2.QtMultimedia.QMediaContent'), ('int', 'typing.Sequence[PySide2.QtMultimedia.QMediaContent]')],
-    "PySide2.QtMultimedia.QMediaPlaylist.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.isReadOnly": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.load": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.media": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaCount": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.moveMedia": ('int', 'int'),
-    "PySide2.QtMultimedia.QMediaPlaylist.nextIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.playbackMode": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previous": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previousIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.removeMedia": [('int',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaPlaylist.save": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.setCurrentIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setPlaybackMode": ('PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode',),
-    "PySide2.QtMultimedia.QMediaPlaylist.shuffle": (),
-# class PySide2.QtMultimedia.QMediaRecorder:
-# class PySide2.QtMultimedia.QMediaRecorder.Error:
-# class PySide2.QtMultimedia.QMediaRecorder.State:
-# class PySide2.QtMultimedia.QMediaRecorder.Status:
-    "PySide2.QtMultimedia.QMediaRecorder.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QMediaRecorder.actualLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.audioCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.audioSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availability": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaRecorder.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaRecorder.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorder.error": (),
-    "PySide2.QtMultimedia.QMediaRecorder.errorString": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataWritable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorder.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaRecorder.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.pause": (),
-    "PySide2.QtMultimedia.QMediaRecorder.record": (),
-    "PySide2.QtMultimedia.QMediaRecorder.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.setEncodingSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings', 'PySide2.QtMultimedia.QVideoEncoderSettings', 'str'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaRecorder.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorder.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorder.state": (),
-    "PySide2.QtMultimedia.QMediaRecorder.status": (),
-    "PySide2.QtMultimedia.QMediaRecorder.stop": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedAudioCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedContainers": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.videoSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.volume": (),
-# class PySide2.QtMultimedia.QMediaRecorderControl:
-    "PySide2.QtMultimedia.QMediaRecorderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.applySettings": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setState": ('PySide2.QtMultimedia.QMediaRecorder.State',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.state": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.status": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.volume": (),
-# class PySide2.QtMultimedia.QMediaResource:
-    "PySide2.QtMultimedia.QMediaResource.__init__": [(), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaResource.__copy__": (),
-    "PySide2.QtMultimedia.QMediaResource.audioBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.audioCodec": (),
-    "PySide2.QtMultimedia.QMediaResource.channelCount": (),
-    "PySide2.QtMultimedia.QMediaResource.dataSize": (),
-    "PySide2.QtMultimedia.QMediaResource.isNull": (),
-    "PySide2.QtMultimedia.QMediaResource.language": (),
-    "PySide2.QtMultimedia.QMediaResource.mimeType": (),
-    "PySide2.QtMultimedia.QMediaResource.request": (),
-    "PySide2.QtMultimedia.QMediaResource.resolution": (),
-    "PySide2.QtMultimedia.QMediaResource.sampleRate": (),
-    "PySide2.QtMultimedia.QMediaResource.setAudioBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setAudioCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setDataSize": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setLanguage": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaResource.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.url": (),
-    "PySide2.QtMultimedia.QMediaResource.videoBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.videoCodec": (),
-# class PySide2.QtMultimedia.QMediaService:
-    "PySide2.QtMultimedia.QMediaService.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaService.releaseControl": ('PySide2.QtMultimedia.QMediaControl',),
-    "PySide2.QtMultimedia.QMediaService.requestControl": ('str',),
-# class PySide2.QtMultimedia.QMediaServiceCameraInfoInterface:
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraOrientation": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraPosition": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface:
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.defaultDevice": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceFeaturesInterface:
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.supportedFeatures": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceProviderHint:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Feature:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Features:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Type:
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera.Position',), ('PySide2.QtMultimedia.QMediaServiceProviderHint',), ('PySide2.QtMultimedia.QMediaServiceProviderHint.Features',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__copy__": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.cameraPosition": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.codecs": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.device": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.features": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.isNull": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.mimeType": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.type": (),
-# class PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.deviceDescription": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.devices": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.supportedMimeTypes": (),
-# class PySide2.QtMultimedia.QMediaStreamsControl:
-# class PySide2.QtMultimedia.QMediaStreamsControl.StreamType:
-    "PySide2.QtMultimedia.QMediaStreamsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.isActive": ('int',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.metaData": ('int', 'str'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.setActive": ('int', 'bool'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamCount": (),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamType": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeInterval:
-    "PySide2.QtMultimedia.QMediaTimeInterval.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeInterval.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeInterval.end": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.isNormal": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.normalized": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.start": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.translated": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeRange:
-    "PySide2.QtMultimedia.QMediaTimeRange.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.__add__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.__iadd__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__isub__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__sub__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.addInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.addTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.clear": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeRange.earliestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.intervals": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isContinuous": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.latestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.removeInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.removeTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-# class PySide2.QtMultimedia.QMediaVideoProbeControl:
-    "PySide2.QtMultimedia.QMediaVideoProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMetaDataReaderControl:
-    "PySide2.QtMultimedia.QMetaDataReaderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.metaData": ('str',),
-# class PySide2.QtMultimedia.QMetaDataWriterControl:
-    "PySide2.QtMultimedia.QMetaDataWriterControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isWritable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.metaData": ('str',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.setMetaData": ('str', 'typing.Any'),
-# class PySide2.QtMultimedia.QMultimedia:
-# class PySide2.QtMultimedia.QMultimedia.AvailabilityStatus:
-# class PySide2.QtMultimedia.QMultimedia.EncodingMode:
-# class PySide2.QtMultimedia.QMultimedia.EncodingQuality:
-# class PySide2.QtMultimedia.QMultimedia.SupportEstimate:
-# class PySide2.QtMultimedia.QRadioData:
-# class PySide2.QtMultimedia.QRadioData.Error:
-# class PySide2.QtMultimedia.QRadioData.ProgramType:
-    "PySide2.QtMultimedia.QRadioData.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QRadioData.availability": (),
-    "PySide2.QtMultimedia.QRadioData.error": (),
-    "PySide2.QtMultimedia.QRadioData.errorString": (),
-    "PySide2.QtMultimedia.QRadioData.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioData.mediaObject": (),
-    "PySide2.QtMultimedia.QRadioData.programType": (),
-    "PySide2.QtMultimedia.QRadioData.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioData.radioText": (),
-    "PySide2.QtMultimedia.QRadioData.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioData.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QRadioData.stationId": (),
-    "PySide2.QtMultimedia.QRadioData.stationName": (),
-# class PySide2.QtMultimedia.QRadioDataControl:
-    "PySide2.QtMultimedia.QRadioDataControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioDataControl.error": (),
-    "PySide2.QtMultimedia.QRadioDataControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioDataControl.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programType": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioDataControl.radioText": (),
-    "PySide2.QtMultimedia.QRadioDataControl.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioDataControl.stationId": (),
-    "PySide2.QtMultimedia.QRadioDataControl.stationName": (),
-# class PySide2.QtMultimedia.QRadioTuner:
-# class PySide2.QtMultimedia.QRadioTuner.Band:
-# class PySide2.QtMultimedia.QRadioTuner.Error:
-# class PySide2.QtMultimedia.QRadioTuner.SearchMode:
-# class PySide2.QtMultimedia.QRadioTuner.State:
-# class PySide2.QtMultimedia.QRadioTuner.StereoMode:
-    "PySide2.QtMultimedia.QRadioTuner.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTuner.availability": (),
-    "PySide2.QtMultimedia.QRadioTuner.band": (),
-    "PySide2.QtMultimedia.QRadioTuner.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTuner.error": (),
-    "PySide2.QtMultimedia.QRadioTuner.errorString": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequency": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTuner.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTuner.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTuner.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTuner.radioData": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTuner.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTuner.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTuner.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTuner.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTuner.start": (),
-    "PySide2.QtMultimedia.QRadioTuner.state": (),
-    "PySide2.QtMultimedia.QRadioTuner.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTuner.stop": (),
-    "PySide2.QtMultimedia.QRadioTuner.volume": (),
-# class PySide2.QtMultimedia.QRadioTunerControl:
-    "PySide2.QtMultimedia.QRadioTunerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTunerControl.band": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.error": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequency": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.start": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.state": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stop": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.volume": (),
-# class PySide2.QtMultimedia.QSound:
-# class PySide2.QtMultimedia.QSound.Loop:
-    "PySide2.QtMultimedia.QSound.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QSound.fileName": (),
-    "PySide2.QtMultimedia.QSound.isFinished": (),
-    "PySide2.QtMultimedia.QSound.loops": (),
-    "PySide2.QtMultimedia.QSound.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSound.play": [(), ('str',)],
-    "PySide2.QtMultimedia.QSound.setLoops": ('int',),
-    "PySide2.QtMultimedia.QSound.stop": (),
-# class PySide2.QtMultimedia.QSoundEffect:
-# class PySide2.QtMultimedia.QSoundEffect.Loop:
-# class PySide2.QtMultimedia.QSoundEffect.Status:
-    "PySide2.QtMultimedia.QSoundEffect.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QSoundEffect.category": (),
-    "PySide2.QtMultimedia.QSoundEffect.isLoaded": (),
-    "PySide2.QtMultimedia.QSoundEffect.isMuted": (),
-    "PySide2.QtMultimedia.QSoundEffect.isPlaying": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopCount": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSoundEffect.play": (),
-    "PySide2.QtMultimedia.QSoundEffect.setCategory": ('str',),
-    "PySide2.QtMultimedia.QSoundEffect.setLoopCount": ('int',),
-    "PySide2.QtMultimedia.QSoundEffect.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QSoundEffect.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QSoundEffect.setVolume": ('float',),
-    "PySide2.QtMultimedia.QSoundEffect.source": (),
-    "PySide2.QtMultimedia.QSoundEffect.status": (),
-    "PySide2.QtMultimedia.QSoundEffect.stop": (),
-    "PySide2.QtMultimedia.QSoundEffect.supportedMimeTypes": (),
-    "PySide2.QtMultimedia.QSoundEffect.volume": (),
-# class PySide2.QtMultimedia.QVideoDeviceSelectorControl:
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.defaultDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceCount": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceDescription": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceName": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.selectedDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.setSelectedDevice": ('int',),
-# class PySide2.QtMultimedia.QVideoEncoderSettings:
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QVideoEncoderSettings',)],
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.frameRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QVideoEncoderSettingsControl:
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoSettings": (),
-# class PySide2.QtMultimedia.QVideoFilterRunnable:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlag:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags:
-    "PySide2.QtMultimedia.QVideoFilterRunnable.__init__": (),
-    "PySide2.QtMultimedia.QVideoFilterRunnable.run": ('PySide2.QtMultimedia.QVideoFrame', 'PySide2.QtMultimedia.QVideoSurfaceFormat', 'PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags'),
-# class PySide2.QtMultimedia.QVideoFrame:
-# class PySide2.QtMultimedia.QVideoFrame.FieldType:
-# class PySide2.QtMultimedia.QVideoFrame.PixelFormat:
-    "PySide2.QtMultimedia.QVideoFrame.__init__": [(), ('PySide2.QtGui.QImage',), ('PySide2.QtMultimedia.QAbstractVideoBuffer', 'PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat'), ('PySide2.QtMultimedia.QVideoFrame',), ('int', 'PySide2.QtCore.QSize', 'int', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat')],
-    "PySide2.QtMultimedia.QVideoFrame.__copy__": (),
-    "PySide2.QtMultimedia.QVideoFrame.availableMetaData": (),
-    "PySide2.QtMultimedia.QVideoFrame.bits": (),
-    "PySide2.QtMultimedia.QVideoFrame.buffer": (),
-    "PySide2.QtMultimedia.QVideoFrame.bytesPerLine": [(), ('int',)],
-    "PySide2.QtMultimedia.QVideoFrame.endTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.fieldType": (),
-    "PySide2.QtMultimedia.QVideoFrame.handle": (),
-    "PySide2.QtMultimedia.QVideoFrame.handleType": (),
-    "PySide2.QtMultimedia.QVideoFrame.height": (),
-    "PySide2.QtMultimedia.QVideoFrame.imageFormatFromPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QVideoFrame.isMapped": (),
-    "PySide2.QtMultimedia.QVideoFrame.isReadable": (),
-    "PySide2.QtMultimedia.QVideoFrame.isValid": (),
-    "PySide2.QtMultimedia.QVideoFrame.isWritable": (),
-    "PySide2.QtMultimedia.QVideoFrame.map": ('PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode',),
-    "PySide2.QtMultimedia.QVideoFrame.mapMode": (),
-    "PySide2.QtMultimedia.QVideoFrame.mappedBytes": (),
-    "PySide2.QtMultimedia.QVideoFrame.metaData": ('str',),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormatFromImageFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtMultimedia.QVideoFrame.planeCount": (),
-    "PySide2.QtMultimedia.QVideoFrame.setEndTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.setFieldType": ('PySide2.QtMultimedia.QVideoFrame.FieldType',),
-    "PySide2.QtMultimedia.QVideoFrame.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoFrame.setStartTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.size": (),
-    "PySide2.QtMultimedia.QVideoFrame.startTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.unmap": (),
-    "PySide2.QtMultimedia.QVideoFrame.width": (),
-# class PySide2.QtMultimedia.QVideoProbe:
-    "PySide2.QtMultimedia.QVideoProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoProbe.isActive": (),
-    "PySide2.QtMultimedia.QVideoProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QVideoRendererControl:
-    "PySide2.QtMultimedia.QVideoRendererControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoRendererControl.setSurface": ('PySide2.QtMultimedia.QAbstractVideoSurface',),
-    "PySide2.QtMultimedia.QVideoRendererControl.surface": (),
-# class PySide2.QtMultimedia.QVideoSurfaceFormat:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.Direction:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace:
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat', 'PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType'), ('PySide2.QtMultimedia.QVideoSurfaceFormat',)],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__copy__": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameHeight": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameRate": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameSize": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameWidth": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.handleType": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isMirrored": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isValid": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.property": ('str',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.propertyNames": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.scanLineDirection": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setMirrored": ('bool',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setScanLineDirection": ('PySide2.QtMultimedia.QVideoSurfaceFormat.Direction',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setYCbCrColorSpace": ('PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.sizeHint": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.viewport": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.yCbCrColorSpace": (),
-# class PySide2.QtMultimedia.QVideoWindowControl:
-    "PySide2.QtMultimedia.QVideoWindowControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoWindowControl.aspectRatioMode": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.brightness": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.contrast": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.displayRect": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.hue": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.isFullScreen": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.nativeSize": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.repaint": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.saturation": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setBrightness": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setContrast": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setDisplayRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setHue": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setSaturation": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setWinId": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.winId": (),
-    }) if "PySide2.QtMultimedia" in sys.modules else None
-# Module PySide2.QtMultimediaWidgets
-sig_dict.update({
-# class PySide2.QtMultimediaWidgets.QCameraViewfinder:
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimediaWidgets.QGraphicsVideoItem:
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.boundingRect": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.nativeSize": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.offset": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.size": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtMultimediaWidgets.QVideoWidget:
-    "PySide2.QtMultimediaWidgets.QVideoWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.sizeHint": (),
-# class PySide2.QtMultimediaWidgets.QVideoWidgetControl:
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.isFullScreen": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.videoWidget": (),
-    }) if "PySide2.QtMultimediaWidgets" in sys.modules else None
-# Module PySide2.QtOpenGL
-sig_dict.update({
-# class PySide2.QtOpenGL.QGL:
-# class PySide2.QtOpenGL.QGL.FormatOption:
-# class PySide2.QtOpenGL.QGL.FormatOptions:
-# class PySide2.QtOpenGL.QGLBuffer:
-# class PySide2.QtOpenGL.QGLBuffer.Access:
-# class PySide2.QtOpenGL.QGLBuffer.Type:
-# class PySide2.QtOpenGL.QGLBuffer.UsagePattern:
-    "PySide2.QtOpenGL.QGLBuffer.__init__": [(), ('PySide2.QtOpenGL.QGLBuffer',), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLBuffer.bind": (),
-    "PySide2.QtOpenGL.QGLBuffer.bufferId": (),
-    "PySide2.QtOpenGL.QGLBuffer.create": (),
-    "PySide2.QtOpenGL.QGLBuffer.destroy": (),
-    "PySide2.QtOpenGL.QGLBuffer.isCreated": (),
-    "PySide2.QtOpenGL.QGLBuffer.map": ('PySide2.QtOpenGL.QGLBuffer.Access',),
-    "PySide2.QtOpenGL.QGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLBuffer.release": [(), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.setUsagePattern": ('PySide2.QtOpenGL.QGLBuffer.UsagePattern',),
-    "PySide2.QtOpenGL.QGLBuffer.size": (),
-    "PySide2.QtOpenGL.QGLBuffer.type": (),
-    "PySide2.QtOpenGL.QGLBuffer.unmap": (),
-    "PySide2.QtOpenGL.QGLBuffer.usagePattern": (),
-    "PySide2.QtOpenGL.QGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtOpenGL.QGLColormap:
-    "PySide2.QtOpenGL.QGLColormap.__init__": [(), ('PySide2.QtOpenGL.QGLColormap',)],
-    "PySide2.QtOpenGL.QGLColormap.__copy__": (),
-    "PySide2.QtOpenGL.QGLColormap.entryColor": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.entryRgb": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.find": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.findNearest": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.handle": (),
-    "PySide2.QtOpenGL.QGLColormap.isEmpty": (),
-    "PySide2.QtOpenGL.QGLColormap.setEntry": [('int', 'PySide2.QtGui.QColor'), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLColormap.setHandle": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.size": (),
-# class PySide2.QtOpenGL.QGLContext:
-# class PySide2.QtOpenGL.QGLContext.BindOption:
-# class PySide2.QtOpenGL.QGLContext.BindOptions:
-    "PySide2.QtOpenGL.QGLContext.__init__": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.areSharing": ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLContext.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLContext.chooseContext": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.colorIndex": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLContext.contextHandle": (),
-    "PySide2.QtOpenGL.QGLContext.create": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.currentContext": (),
-    "PySide2.QtOpenGL.QGLContext.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLContext.device": (),
-    "PySide2.QtOpenGL.QGLContext.deviceIsPixmap": (),
-    "PySide2.QtOpenGL.QGLContext.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLContext.format": (),
-    "PySide2.QtOpenGL.QGLContext.fromOpenGLContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtOpenGL.QGLContext.initialized": (),
-    "PySide2.QtOpenGL.QGLContext.isSharing": (),
-    "PySide2.QtOpenGL.QGLContext.isValid": (),
-    "PySide2.QtOpenGL.QGLContext.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtOpenGL.QGLContext.overlayTransparentColor": (),
-    "PySide2.QtOpenGL.QGLContext.requestedFormat": (),
-    "PySide2.QtOpenGL.QGLContext.reset": (),
-    "PySide2.QtOpenGL.QGLContext.setDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtOpenGL.QGLContext.setFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.setInitialized": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setTextureCacheLimit": ('int',),
-    "PySide2.QtOpenGL.QGLContext.setValid": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setWindowCreated": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLContext.textureCacheLimit": (),
-    "PySide2.QtOpenGL.QGLContext.windowCreated": (),
-# class PySide2.QtOpenGL.QGLFormat:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlag:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlags:
-    "PySide2.QtOpenGL.QGLFormat.__init__": [(), ('PySide2.QtOpenGL.QGL.FormatOptions', 'int'), ('PySide2.QtOpenGL.QGLFormat',)],
-    "PySide2.QtOpenGL.QGLFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFormat.accum": (),
-    "PySide2.QtOpenGL.QGLFormat.accumBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.alpha": (),
-    "PySide2.QtOpenGL.QGLFormat.alphaBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.blueBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultOverlayFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.depth": (),
-    "PySide2.QtOpenGL.QGLFormat.depthBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.directRendering": (),
-    "PySide2.QtOpenGL.QGLFormat.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLFormat.fromSurfaceFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtOpenGL.QGLFormat.greenBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGL": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGLOverlays": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOverlay": (),
-    "PySide2.QtOpenGL.QGLFormat.majorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.minorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.openGLVersionFlags": (),
-    "PySide2.QtOpenGL.QGLFormat.plane": (),
-    "PySide2.QtOpenGL.QGLFormat.profile": (),
-    "PySide2.QtOpenGL.QGLFormat.redBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.rgba": (),
-    "PySide2.QtOpenGL.QGLFormat.sampleBuffers": (),
-    "PySide2.QtOpenGL.QGLFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFormat.setAccum": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAccumBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setAlpha": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultOverlayFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDepth": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDirectRendering": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDoubleBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.setOverlay": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setPlane": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setProfile": ('PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile',),
-    "PySide2.QtOpenGL.QGLFormat.setRedBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setRgba": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSampleBuffers": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStencil": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStereo": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSwapInterval": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setVersion": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLFormat.stencil": (),
-    "PySide2.QtOpenGL.QGLFormat.stencilBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.stereo": (),
-    "PySide2.QtOpenGL.QGLFormat.swapInterval": (),
-    "PySide2.QtOpenGL.QGLFormat.testOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.toSurfaceFormat": ('PySide2.QtOpenGL.QGLFormat',),
-# class PySide2.QtOpenGL.QGLFramebufferObject:
-# class PySide2.QtOpenGL.QGLFramebufferObject.Attachment:
-    "PySide2.QtOpenGL.QGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bind": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bindDefault": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.blitFramebuffer": ('PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLFramebufferObject.devType": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.format": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.handle": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isBound": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isValid": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLFramebufferObject.paintEngine": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.release": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.size": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.texture": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.toImage": (),
-# class PySide2.QtOpenGL.QGLFramebufferObjectFormat:
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtOpenGL.QGLFramebufferObjectFormat',)],
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setAttachment": ('PySide2.QtOpenGL.QGLFramebufferObject.Attachment',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtOpenGL.QGLPixelBuffer:
-    "PySide2.QtOpenGL.QGLPixelBuffer.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget'), ('int', 'int', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindTexture": [('PySide2.QtGui.QImage', 'int'), ('PySide2.QtGui.QPixmap', 'int'), ('str',)],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindToDynamicTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.context": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.devType": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.format": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.generateDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.handle": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.hasOpenGLPbuffers": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.isValid": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.paintEngine": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.releaseFromDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.size": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.toImage": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.updateDynamicTexture": ('int',),
-# class PySide2.QtOpenGL.QGLShader:
-# class PySide2.QtOpenGL.QGLShader.ShaderType:
-# class PySide2.QtOpenGL.QGLShader.ShaderTypeBit:
-    "PySide2.QtOpenGL.QGLShader.__init__": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QObject'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShader.compileSourceFile": ('str',),
-    "PySide2.QtOpenGL.QGLShader.hasOpenGLShaders": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLShader.isCompiled": (),
-    "PySide2.QtOpenGL.QGLShader.log": (),
-    "PySide2.QtOpenGL.QGLShader.shaderId": (),
-    "PySide2.QtOpenGL.QGLShader.shaderType": (),
-    "PySide2.QtOpenGL.QGLShader.sourceCode": (),
-# class PySide2.QtOpenGL.QGLShaderProgram:
-    "PySide2.QtOpenGL.QGLShaderProgram.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str'),
-    "PySide2.QtOpenGL.QGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.bind": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryInputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputVertexCount": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLShaderProgram.isLinked": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.link": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.log": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.programId": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.release": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryInputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputVertexCount": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x2": [('int', 'PySide2.QtGui.QMatrix2x2', 'int'), ('str', 'PySide2.QtGui.QMatrix2x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x3": [('int', 'PySide2.QtGui.QMatrix2x3', 'int'), ('str', 'PySide2.QtGui.QMatrix2x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x4": [('int', 'PySide2.QtGui.QMatrix2x4', 'int'), ('str', 'PySide2.QtGui.QMatrix2x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x2": [('int', 'PySide2.QtGui.QMatrix3x2', 'int'), ('str', 'PySide2.QtGui.QMatrix3x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x3": [('int', 'PySide2.QtGui.QMatrix3x3', 'int'), ('str', 'PySide2.QtGui.QMatrix3x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x4": [('int', 'PySide2.QtGui.QMatrix3x4', 'int'), ('str', 'PySide2.QtGui.QMatrix3x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x2": [('int', 'PySide2.QtGui.QMatrix4x2', 'int'), ('str', 'PySide2.QtGui.QMatrix4x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x3": [('int', 'PySide2.QtGui.QMatrix4x3', 'int'), ('str', 'PySide2.QtGui.QMatrix4x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x4": [('int', 'PySide2.QtGui.QMatrix4x4', 'int'), ('str', 'PySide2.QtGui.QMatrix4x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayInt": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayUint": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.shaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtOpenGL.QGLWidget:
-    "PySide2.QtOpenGL.QGLWidget.__init__": [('PySide2.QtOpenGL.QGLContext', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtOpenGL.QGLFormat', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtOpenGL.QGLWidget.autoBufferSwap": (),
-    "PySide2.QtOpenGL.QGLWidget.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLWidget.colormap": (),
-    "PySide2.QtOpenGL.QGLWidget.context": (),
-    "PySide2.QtOpenGL.QGLWidget.convertToGLFormat": ('PySide2.QtGui.QImage',),
-    "PySide2.QtOpenGL.QGLWidget.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLWidget.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLWidget.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtOpenGL.QGLWidget.format": (),
-    "PySide2.QtOpenGL.QGLWidget.glDraw": (),
-    "PySide2.QtOpenGL.QGLWidget.glInit": (),
-    "PySide2.QtOpenGL.QGLWidget.grabFrameBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.initializeGL": (),
-    "PySide2.QtOpenGL.QGLWidget.initializeOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.isSharing": (),
-    "PySide2.QtOpenGL.QGLWidget.isValid": (),
-    "PySide2.QtOpenGL.QGLWidget.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.makeOverlayCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.overlayContext": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEngine": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtOpenGL.QGLWidget.paintGL": (),
-    "PySide2.QtOpenGL.QGLWidget.paintOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.qglClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.qglColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.renderPixmap": ('int', 'int', 'bool'),
-    "PySide2.QtOpenGL.QGLWidget.renderText": [('float', 'float', 'float', 'str', 'PySide2.QtGui.QFont'), ('int', 'int', 'str', 'PySide2.QtGui.QFont')],
-    "PySide2.QtOpenGL.QGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtOpenGL.QGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.resizeOverlayGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.setAutoBufferSwap": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.setColormap": ('PySide2.QtOpenGL.QGLColormap',),
-    "PySide2.QtOpenGL.QGLWidget.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLWidget.updateGL": (),
-    "PySide2.QtOpenGL.QGLWidget.updateOverlayGL": (),
-    }) if "PySide2.QtOpenGL" in sys.modules else None
-# Module PySide2.QtOpenGLFunctions
-sig_dict.update({
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnConvolutionFilter": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnHistogram": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnMinmax": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayVertexBuffers": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayVertexBuffers": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.initializeOpenGLFunctions": (),
-    }) if "PySide2.QtOpenGLFunctions" in sys.modules else None
-# Module PySide2.QtPositioning
-sig_dict.update({
-# class PySide2.QtPositioning.QGeoAddress:
-    "PySide2.QtPositioning.QGeoAddress.__init__": [(), ('PySide2.QtPositioning.QGeoAddress',)],
-    "PySide2.QtPositioning.QGeoAddress.__copy__": (),
-    "PySide2.QtPositioning.QGeoAddress.city": (),
-    "PySide2.QtPositioning.QGeoAddress.clear": (),
-    "PySide2.QtPositioning.QGeoAddress.country": (),
-    "PySide2.QtPositioning.QGeoAddress.countryCode": (),
-    "PySide2.QtPositioning.QGeoAddress.county": (),
-    "PySide2.QtPositioning.QGeoAddress.district": (),
-    "PySide2.QtPositioning.QGeoAddress.isEmpty": (),
-    "PySide2.QtPositioning.QGeoAddress.isTextGenerated": (),
-    "PySide2.QtPositioning.QGeoAddress.postalCode": (),
-    "PySide2.QtPositioning.QGeoAddress.setCity": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountry": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountryCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCounty": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setDistrict": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setPostalCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setState": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setStreet": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setText": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.state": (),
-    "PySide2.QtPositioning.QGeoAddress.street": (),
-    "PySide2.QtPositioning.QGeoAddress.text": (),
-# class PySide2.QtPositioning.QGeoAreaMonitorInfo:
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__init__": [('PySide2.QtPositioning.QGeoAreaMonitorInfo',), ('str',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.area": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.expiration": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.identifier": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isPersistent": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.name": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.notificationParameters": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setExpiration": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setName": ('str',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setNotificationParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setPersistent": ('bool',),
-# class PySide2.QtPositioning.QGeoAreaMonitorSource:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeature:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeatures:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.Error:
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.activeMonitors": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createDefaultSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createSource": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.error": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.positionInfoSource": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.requestUpdate": ('PySide2.QtPositioning.QGeoAreaMonitorInfo', 'str'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.setPositionInfoSource": ('PySide2.QtPositioning.QGeoPositionInfoSource',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.startMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.stopMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.supportedAreaMonitorFeatures": (),
-# class PySide2.QtPositioning.QGeoCircle:
-    "PySide2.QtPositioning.QGeoCircle.__init__": [(), ('PySide2.QtPositioning.QGeoCircle',), ('PySide2.QtPositioning.QGeoCoordinate', 'float'), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoCircle.__copy__": (),
-    "PySide2.QtPositioning.QGeoCircle.center": (),
-    "PySide2.QtPositioning.QGeoCircle.extendCircle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.radius": (),
-    "PySide2.QtPositioning.QGeoCircle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.setRadius": ('float',),
-    "PySide2.QtPositioning.QGeoCircle.toString": (),
-    "PySide2.QtPositioning.QGeoCircle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoCircle.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoCoordinate:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateType:
-    "PySide2.QtPositioning.QGeoCoordinate.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtPositioning.QGeoCoordinate.__copy__": (),
-    "PySide2.QtPositioning.QGeoCoordinate.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.altitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.atDistanceAndAzimuth": ('float', 'float', 'float'),
-    "PySide2.QtPositioning.QGeoCoordinate.azimuthTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.distanceTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.isValid": (),
-    "PySide2.QtPositioning.QGeoCoordinate.latitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.longitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.setAltitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLatitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLongitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.toString": ('PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat',),
-    "PySide2.QtPositioning.QGeoCoordinate.type": (),
-# class PySide2.QtPositioning.QGeoLocation:
-    "PySide2.QtPositioning.QGeoLocation.__init__": [(), ('PySide2.QtPositioning.QGeoLocation',)],
-    "PySide2.QtPositioning.QGeoLocation.__copy__": (),
-    "PySide2.QtPositioning.QGeoLocation.address": (),
-    "PySide2.QtPositioning.QGeoLocation.boundingBox": (),
-    "PySide2.QtPositioning.QGeoLocation.coordinate": (),
-    "PySide2.QtPositioning.QGeoLocation.extendedAttributes": (),
-    "PySide2.QtPositioning.QGeoLocation.isEmpty": (),
-    "PySide2.QtPositioning.QGeoLocation.setAddress": ('PySide2.QtPositioning.QGeoAddress',),
-    "PySide2.QtPositioning.QGeoLocation.setBoundingBox": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoLocation.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoLocation.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtPositioning.QGeoPath:
-    "PySide2.QtPositioning.QGeoPath.__init__": [(), ('PySide2.QtPositioning.QGeoPath',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]', 'float')],
-    "PySide2.QtPositioning.QGeoPath.__copy__": (),
-    "PySide2.QtPositioning.QGeoPath.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.clearPath": (),
-    "PySide2.QtPositioning.QGeoPath.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPath.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPath.path": (),
-    "PySide2.QtPositioning.QGeoPath.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPath.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPath.setVariantPath": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPath.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoPath.size": (),
-    "PySide2.QtPositioning.QGeoPath.toString": (),
-    "PySide2.QtPositioning.QGeoPath.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.variantPath": (),
-    "PySide2.QtPositioning.QGeoPath.width": (),
-# class PySide2.QtPositioning.QGeoPolygon:
-    "PySide2.QtPositioning.QGeoPolygon.__init__": [(), ('PySide2.QtPositioning.QGeoPolygon',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.__copy__": (),
-    "PySide2.QtPositioning.QGeoPolygon.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.addHole": [('typing.Any',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.hole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holePath": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holesCount": (),
-    "PySide2.QtPositioning.QGeoPolygon.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPolygon.path": (),
-    "PySide2.QtPositioning.QGeoPolygon.perimeter": (),
-    "PySide2.QtPositioning.QGeoPolygon.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPolygon.removeHole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPolygon.setPerimeter": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPolygon.size": (),
-    "PySide2.QtPositioning.QGeoPolygon.toString": (),
-    "PySide2.QtPositioning.QGeoPolygon.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPolygon.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoPositionInfo:
-# class PySide2.QtPositioning.QGeoPositionInfo.Attribute:
-    "PySide2.QtPositioning.QGeoPositionInfo.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtCore.QDateTime'), ('PySide2.QtPositioning.QGeoPositionInfo',)],
-    "PySide2.QtPositioning.QGeoPositionInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.attribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.coordinate": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.hasAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.removeAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoPositionInfo.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setTimestamp": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoPositionInfo.timestamp": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSource:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.Error:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethod:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods:
-    "PySide2.QtPositioning.QGeoPositionInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.backendProperty": ('str',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.preferredPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setBackendProperty": ('str', 'typing.Any'),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setPreferredPositioningMethods": ('PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSourceFactory:
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.__init__": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.areaMonitor": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.positionInfoSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.satelliteInfoSource": ('PySide2.QtCore.QObject',),
-# class PySide2.QtPositioning.QGeoRectangle:
-    "PySide2.QtPositioning.QGeoRectangle.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('PySide2.QtPositioning.QGeoCoordinate', 'float', 'float'), ('PySide2.QtPositioning.QGeoRectangle',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoRectangle.__copy__": (),
-    "PySide2.QtPositioning.QGeoRectangle.__ior__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.__or__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.bottomLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.bottomRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.center": (),
-    "PySide2.QtPositioning.QGeoRectangle.contains": [('PySide2.QtPositioning.QGeoCoordinate',), ('PySide2.QtPositioning.QGeoRectangle',)],
-    "PySide2.QtPositioning.QGeoRectangle.extendRectangle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.height": (),
-    "PySide2.QtPositioning.QGeoRectangle.intersects": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setHeight": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.toString": (),
-    "PySide2.QtPositioning.QGeoRectangle.topLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.topRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.united": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.width": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfo:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.Attribute:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem:
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__init__": [(), ('PySide2.QtPositioning.QGeoSatelliteInfo',)],
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.attribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.hasAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.removeAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteIdentifier": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteSystem": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteIdentifier": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteSystem": ('PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSignalStrength": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.signalStrength": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource:
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource.Error:
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoShape:
-# class PySide2.QtPositioning.QGeoShape.ShapeType:
-    "PySide2.QtPositioning.QGeoShape.__init__": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoShape.__copy__": (),
-    "PySide2.QtPositioning.QGeoShape.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.boundingGeoRectangle": (),
-    "PySide2.QtPositioning.QGeoShape.center": (),
-    "PySide2.QtPositioning.QGeoShape.contains": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.extendShape": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.isEmpty": (),
-    "PySide2.QtPositioning.QGeoShape.isValid": (),
-    "PySide2.QtPositioning.QGeoShape.toString": (),
-    "PySide2.QtPositioning.QGeoShape.type": (),
-# class PySide2.QtPositioning.QNmeaPositionInfoSource:
-# class PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode:
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.__init__": ('PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.device": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.parsePosInfoFromNmeaData": ('str', 'int', 'PySide2.QtPositioning.QGeoPositionInfo'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUserEquivalentRangeError": ('float',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.updateMode": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.userEquivalentRangeError": (),
-    }) if "PySide2.QtPositioning" in sys.modules else None
-# Module PySide2.QtLocation
-sig_dict.update({
-# class PySide2.QtLocation.QGeoCodeReply:
-# class PySide2.QtLocation.QGeoCodeReply.Error:
-    "PySide2.QtLocation.QGeoCodeReply.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtLocation.QGeoCodeReply.Error', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoCodeReply.abort": (),
-    "PySide2.QtLocation.QGeoCodeReply.addLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QGeoCodeReply.error": (),
-    "PySide2.QtLocation.QGeoCodeReply.errorString": (),
-    "PySide2.QtLocation.QGeoCodeReply.isFinished": (),
-    "PySide2.QtLocation.QGeoCodeReply.limit": (),
-    "PySide2.QtLocation.QGeoCodeReply.locations": (),
-    "PySide2.QtLocation.QGeoCodeReply.offset": (),
-    "PySide2.QtLocation.QGeoCodeReply.setError": ('PySide2.QtLocation.QGeoCodeReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoCodeReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoCodeReply.setLimit": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setLocations": ('typing.Sequence[PySide2.QtPositioning.QGeoLocation]',),
-    "PySide2.QtLocation.QGeoCodeReply.setOffset": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setViewport": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QGeoCodeReply.viewport": (),
-# class PySide2.QtLocation.QGeoCodingManager:
-    "PySide2.QtLocation.QGeoCodingManager.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManager.locale": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManager.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManager.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoCodingManagerEngine:
-    "PySide2.QtLocation.QGeoCodingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoManeuver:
-# class PySide2.QtLocation.QGeoManeuver.InstructionDirection:
-    "PySide2.QtLocation.QGeoManeuver.__init__": [(), ('PySide2.QtLocation.QGeoManeuver',)],
-    "PySide2.QtLocation.QGeoManeuver.__copy__": (),
-    "PySide2.QtLocation.QGeoManeuver.direction": (),
-    "PySide2.QtLocation.QGeoManeuver.distanceToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoManeuver.instructionText": (),
-    "PySide2.QtLocation.QGeoManeuver.isValid": (),
-    "PySide2.QtLocation.QGeoManeuver.position": (),
-    "PySide2.QtLocation.QGeoManeuver.setDirection": ('PySide2.QtLocation.QGeoManeuver.InstructionDirection',),
-    "PySide2.QtLocation.QGeoManeuver.setDistanceToNextInstruction": ('float',),
-    "PySide2.QtLocation.QGeoManeuver.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoManeuver.setInstructionText": ('str',),
-    "PySide2.QtLocation.QGeoManeuver.setPosition": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.setTimeToNextInstruction": ('int',),
-    "PySide2.QtLocation.QGeoManeuver.setWaypoint": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.timeToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.waypoint": (),
-# class PySide2.QtLocation.QGeoRoute:
-    "PySide2.QtLocation.QGeoRoute.__init__": [(), ('PySide2.QtLocation.QGeoRoute',)],
-    "PySide2.QtLocation.QGeoRoute.__copy__": (),
-    "PySide2.QtLocation.QGeoRoute.bounds": (),
-    "PySide2.QtLocation.QGeoRoute.distance": (),
-    "PySide2.QtLocation.QGeoRoute.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoRoute.firstRouteSegment": (),
-    "PySide2.QtLocation.QGeoRoute.path": (),
-    "PySide2.QtLocation.QGeoRoute.request": (),
-    "PySide2.QtLocation.QGeoRoute.routeId": (),
-    "PySide2.QtLocation.QGeoRoute.setBounds": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtLocation.QGeoRoute.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRoute.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRoute.setFirstRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRoute.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRoute.setRequest": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoute.setRouteId": ('str',),
-    "PySide2.QtLocation.QGeoRoute.setTravelMode": ('PySide2.QtLocation.QGeoRouteRequest.TravelMode',),
-    "PySide2.QtLocation.QGeoRoute.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRoute.travelMode": (),
-    "PySide2.QtLocation.QGeoRoute.travelTime": (),
-# class PySide2.QtLocation.QGeoRouteReply:
-# class PySide2.QtLocation.QGeoRouteReply.Error:
-    "PySide2.QtLocation.QGeoRouteReply.__init__": [('PySide2.QtLocation.QGeoRouteReply.Error', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtLocation.QGeoRouteRequest', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoRouteReply.abort": (),
-    "PySide2.QtLocation.QGeoRouteReply.addRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-    "PySide2.QtLocation.QGeoRouteReply.error": (),
-    "PySide2.QtLocation.QGeoRouteReply.errorString": (),
-    "PySide2.QtLocation.QGeoRouteReply.isFinished": (),
-    "PySide2.QtLocation.QGeoRouteReply.request": (),
-    "PySide2.QtLocation.QGeoRouteReply.routes": (),
-    "PySide2.QtLocation.QGeoRouteReply.setError": ('PySide2.QtLocation.QGeoRouteReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoRouteReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoRouteReply.setRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-# class PySide2.QtLocation.QGeoRouteRequest:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureType:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureTypes:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeight:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeights:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimization:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelMode:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelModes:
-    "PySide2.QtLocation.QGeoRouteRequest.__init__": [('PySide2.QtLocation.QGeoRouteRequest',), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtLocation.QGeoRouteRequest.departureTime": (),
-    "PySide2.QtLocation.QGeoRouteRequest.excludeAreas": (),
-    "PySide2.QtLocation.QGeoRouteRequest.extraParameters": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureTypes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType',),
-    "PySide2.QtLocation.QGeoRouteRequest.maneuverDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.numberAlternativeRoutes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.routeOptimization": (),
-    "PySide2.QtLocation.QGeoRouteRequest.segmentDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.setDepartureTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExcludeAreas": ('typing.Sequence[PySide2.QtPositioning.QGeoRectangle]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExtraParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setFeatureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType', 'PySide2.QtLocation.QGeoRouteRequest.FeatureWeight'),
-    "PySide2.QtLocation.QGeoRouteRequest.setManeuverDetail": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setNumberAlternativeRoutes": ('int',),
-    "PySide2.QtLocation.QGeoRouteRequest.setRouteOptimization": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRouteRequest.setSegmentDetail": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypoints": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypointsMetadata": ('typing.Sequence[typing.Dict]',),
-    "PySide2.QtLocation.QGeoRouteRequest.travelModes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypoints": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypointsMetadata": (),
-# class PySide2.QtLocation.QGeoRouteSegment:
-    "PySide2.QtLocation.QGeoRouteSegment.__init__": [(), ('PySide2.QtLocation.QGeoRouteSegment',)],
-    "PySide2.QtLocation.QGeoRouteSegment.__copy__": (),
-    "PySide2.QtLocation.QGeoRouteSegment.distance": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isLegLastSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isValid": (),
-    "PySide2.QtLocation.QGeoRouteSegment.maneuver": (),
-    "PySide2.QtLocation.QGeoRouteSegment.nextRouteSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.path": (),
-    "PySide2.QtLocation.QGeoRouteSegment.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRouteSegment.setManeuver": ('PySide2.QtLocation.QGeoManeuver',),
-    "PySide2.QtLocation.QGeoRouteSegment.setNextRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRouteSegment.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteSegment.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRouteSegment.travelTime": (),
-# class PySide2.QtLocation.QGeoRoutingManager:
-    "PySide2.QtLocation.QGeoRoutingManager.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManager.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManager.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManager.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoRoutingManagerEngine:
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureTypes": ('PySide2.QtLocation.QGeoRouteRequest.FeatureTypes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureWeights": ('PySide2.QtLocation.QGeoRouteRequest.FeatureWeights',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedManeuverDetails": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedRouteOptimizations": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedSegmentDetails": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoServiceProvider:
-# class PySide2.QtLocation.QGeoServiceProvider.Error:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeatures:
-    "PySide2.QtLocation.QGeoServiceProvider.__init__": ('str', 'typing.Dict[str, typing.Any]', 'bool'),
-    "PySide2.QtLocation.QGeoServiceProvider.availableServiceProviders": (),
-    "PySide2.QtLocation.QGeoServiceProvider.error": (),
-    "PySide2.QtLocation.QGeoServiceProvider.errorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placeManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.setAllowExperimental": ('bool',),
-    "PySide2.QtLocation.QGeoServiceProvider.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoServiceProvider.setParameters": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtLocation.QGeoServiceProviderFactory:
-    "PySide2.QtLocation.QGeoServiceProviderFactory.__init__": (),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createGeocodingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createPlaceManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createRoutingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-# class PySide2.QtLocation.QGeoServiceProviderFactoryV2:
-    "PySide2.QtLocation.QGeoServiceProviderFactoryV2.__init__": (),
-# class PySide2.QtLocation.QPlace:
-    "PySide2.QtLocation.QPlace.__init__": [(), ('PySide2.QtLocation.QPlace',)],
-    "PySide2.QtLocation.QPlace.__copy__": (),
-    "PySide2.QtLocation.QPlace.appendContactDetail": ('str', 'PySide2.QtLocation.QPlaceContactDetail'),
-    "PySide2.QtLocation.QPlace.attribution": (),
-    "PySide2.QtLocation.QPlace.categories": (),
-    "PySide2.QtLocation.QPlace.contactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.contactTypes": (),
-    "PySide2.QtLocation.QPlace.content": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlace.detailsFetched": (),
-    "PySide2.QtLocation.QPlace.extendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.extendedAttributeTypes": (),
-    "PySide2.QtLocation.QPlace.icon": (),
-    "PySide2.QtLocation.QPlace.insertContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.isEmpty": (),
-    "PySide2.QtLocation.QPlace.location": (),
-    "PySide2.QtLocation.QPlace.name": (),
-    "PySide2.QtLocation.QPlace.placeId": (),
-    "PySide2.QtLocation.QPlace.primaryEmail": (),
-    "PySide2.QtLocation.QPlace.primaryFax": (),
-    "PySide2.QtLocation.QPlace.primaryPhone": (),
-    "PySide2.QtLocation.QPlace.primaryWebsite": (),
-    "PySide2.QtLocation.QPlace.ratings": (),
-    "PySide2.QtLocation.QPlace.removeContactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.removeExtendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlace.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlace.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlace.setContactDetails": ('str', 'typing.Sequence[PySide2.QtLocation.QPlaceContactDetail]'),
-    "PySide2.QtLocation.QPlace.setContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.setDetailsFetched": ('bool',),
-    "PySide2.QtLocation.QPlace.setExtendedAttribute": ('str', 'PySide2.QtLocation.QPlaceAttribute'),
-    "PySide2.QtLocation.QPlace.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlace.setLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QPlace.setName": ('str',),
-    "PySide2.QtLocation.QPlace.setPlaceId": ('str',),
-    "PySide2.QtLocation.QPlace.setRatings": ('PySide2.QtLocation.QPlaceRatings',),
-    "PySide2.QtLocation.QPlace.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlace.setTotalContentCount": ('PySide2.QtLocation.QPlaceContent.Type', 'int'),
-    "PySide2.QtLocation.QPlace.supplier": (),
-    "PySide2.QtLocation.QPlace.totalContentCount": ('PySide2.QtLocation.QPlaceContent.Type',),
-# class PySide2.QtLocation.QPlaceAttribute:
-    "PySide2.QtLocation.QPlaceAttribute.__init__": [(), ('PySide2.QtLocation.QPlaceAttribute',)],
-    "PySide2.QtLocation.QPlaceAttribute.__copy__": (),
-    "PySide2.QtLocation.QPlaceAttribute.isEmpty": (),
-    "PySide2.QtLocation.QPlaceAttribute.label": (),
-    "PySide2.QtLocation.QPlaceAttribute.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.setText": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.text": (),
-# class PySide2.QtLocation.QPlaceCategory:
-    "PySide2.QtLocation.QPlaceCategory.__init__": [(), ('PySide2.QtLocation.QPlaceCategory',)],
-    "PySide2.QtLocation.QPlaceCategory.__copy__": (),
-    "PySide2.QtLocation.QPlaceCategory.categoryId": (),
-    "PySide2.QtLocation.QPlaceCategory.icon": (),
-    "PySide2.QtLocation.QPlaceCategory.isEmpty": (),
-    "PySide2.QtLocation.QPlaceCategory.name": (),
-    "PySide2.QtLocation.QPlaceCategory.setCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceCategory.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceCategory.setName": ('str',),
-# class PySide2.QtLocation.QPlaceContactDetail:
-    "PySide2.QtLocation.QPlaceContactDetail.__init__": [(), ('PySide2.QtLocation.QPlaceContactDetail',)],
-    "PySide2.QtLocation.QPlaceContactDetail.__copy__": (),
-    "PySide2.QtLocation.QPlaceContactDetail.clear": (),
-    "PySide2.QtLocation.QPlaceContactDetail.label": (),
-    "PySide2.QtLocation.QPlaceContactDetail.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.setValue": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.value": (),
-# class PySide2.QtLocation.QPlaceContent:
-# class PySide2.QtLocation.QPlaceContent.Type:
-    "PySide2.QtLocation.QPlaceContent.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceContent.__copy__": (),
-    "PySide2.QtLocation.QPlaceContent.attribution": (),
-    "PySide2.QtLocation.QPlaceContent.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlaceContent.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlaceContent.setUser": ('PySide2.QtLocation.QPlaceUser',),
-    "PySide2.QtLocation.QPlaceContent.supplier": (),
-    "PySide2.QtLocation.QPlaceContent.type": (),
-    "PySide2.QtLocation.QPlaceContent.user": (),
-# class PySide2.QtLocation.QPlaceContentReply:
-    "PySide2.QtLocation.QPlaceContentReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceContentReply.content": (),
-    "PySide2.QtLocation.QPlaceContentReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.request": (),
-    "PySide2.QtLocation.QPlaceContentReply.setContent": ('typing.Dict[int, PySide2.QtLocation.QPlaceContent]',),
-    "PySide2.QtLocation.QPlaceContentReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setTotalCount": ('int',),
-    "PySide2.QtLocation.QPlaceContentReply.totalCount": (),
-    "PySide2.QtLocation.QPlaceContentReply.type": (),
-# class PySide2.QtLocation.QPlaceContentRequest:
-    "PySide2.QtLocation.QPlaceContentRequest.__init__": [(), ('PySide2.QtLocation.QPlaceContentRequest',)],
-    "PySide2.QtLocation.QPlaceContentRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceContentRequest.clear": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentContext": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentType": (),
-    "PySide2.QtLocation.QPlaceContentRequest.limit": (),
-    "PySide2.QtLocation.QPlaceContentRequest.placeId": (),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentType": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlaceContentRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceContentRequest.setPlaceId": ('str',),
-# class PySide2.QtLocation.QPlaceDetailsReply:
-    "PySide2.QtLocation.QPlaceDetailsReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceDetailsReply.place": (),
-    "PySide2.QtLocation.QPlaceDetailsReply.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceDetailsReply.type": (),
-# class PySide2.QtLocation.QPlaceEditorial:
-    "PySide2.QtLocation.QPlaceEditorial.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceEditorial.language": (),
-    "PySide2.QtLocation.QPlaceEditorial.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setText": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.text": (),
-    "PySide2.QtLocation.QPlaceEditorial.title": (),
-# class PySide2.QtLocation.QPlaceIcon:
-    "PySide2.QtLocation.QPlaceIcon.__init__": [(), ('PySide2.QtLocation.QPlaceIcon',)],
-    "PySide2.QtLocation.QPlaceIcon.__copy__": (),
-    "PySide2.QtLocation.QPlaceIcon.isEmpty": (),
-    "PySide2.QtLocation.QPlaceIcon.manager": (),
-    "PySide2.QtLocation.QPlaceIcon.parameters": (),
-    "PySide2.QtLocation.QPlaceIcon.setManager": ('PySide2.QtLocation.QPlaceManager',),
-    "PySide2.QtLocation.QPlaceIcon.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceIcon.url": ('PySide2.QtCore.QSize',),
-# class PySide2.QtLocation.QPlaceIdReply:
-# class PySide2.QtLocation.QPlaceIdReply.OperationType:
-    "PySide2.QtLocation.QPlaceIdReply.__init__": ('PySide2.QtLocation.QPlaceIdReply.OperationType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceIdReply.id": (),
-    "PySide2.QtLocation.QPlaceIdReply.operationType": (),
-    "PySide2.QtLocation.QPlaceIdReply.setId": ('str',),
-    "PySide2.QtLocation.QPlaceIdReply.type": (),
-# class PySide2.QtLocation.QPlaceImage:
-    "PySide2.QtLocation.QPlaceImage.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceImage.imageId": (),
-    "PySide2.QtLocation.QPlaceImage.mimeType": (),
-    "PySide2.QtLocation.QPlaceImage.setImageId": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setMimeType": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceImage.url": (),
-# class PySide2.QtLocation.QPlaceManager:
-    "PySide2.QtLocation.QPlaceManager.category": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManager.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManager.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManager.locales": (),
-    "PySide2.QtLocation.QPlaceManager.managerName": (),
-    "PySide2.QtLocation.QPlaceManager.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManager.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManager.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManager.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManager.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QPlaceManager.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceManagerEngine:
-    "PySide2.QtLocation.QPlaceManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceManagerEngine.category": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.constructIconUrl": ('PySide2.QtLocation.QPlaceIcon', 'PySide2.QtCore.QSize'),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.locales": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.manager": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerName": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManagerEngine.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceMatchReply:
-    "PySide2.QtLocation.QPlaceMatchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceMatchReply.places": (),
-    "PySide2.QtLocation.QPlaceMatchReply.request": (),
-    "PySide2.QtLocation.QPlaceMatchReply.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchReply.setRequest": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceMatchReply.type": (),
-# class PySide2.QtLocation.QPlaceMatchRequest:
-    "PySide2.QtLocation.QPlaceMatchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceMatchRequest',)],
-    "PySide2.QtLocation.QPlaceMatchRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.parameters": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.places": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-# class PySide2.QtLocation.QPlaceProposedSearchResult:
-    "PySide2.QtLocation.QPlaceProposedSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceProposedSearchResult.searchRequest": (),
-    "PySide2.QtLocation.QPlaceProposedSearchResult.setSearchRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-# class PySide2.QtLocation.QPlaceRatings:
-    "PySide2.QtLocation.QPlaceRatings.__init__": [(), ('PySide2.QtLocation.QPlaceRatings',)],
-    "PySide2.QtLocation.QPlaceRatings.__copy__": (),
-    "PySide2.QtLocation.QPlaceRatings.average": (),
-    "PySide2.QtLocation.QPlaceRatings.count": (),
-    "PySide2.QtLocation.QPlaceRatings.isEmpty": (),
-    "PySide2.QtLocation.QPlaceRatings.maximum": (),
-    "PySide2.QtLocation.QPlaceRatings.setAverage": ('float',),
-    "PySide2.QtLocation.QPlaceRatings.setCount": ('int',),
-    "PySide2.QtLocation.QPlaceRatings.setMaximum": ('float',),
-# class PySide2.QtLocation.QPlaceReply:
-# class PySide2.QtLocation.QPlaceReply.Error:
-# class PySide2.QtLocation.QPlaceReply.Type:
-    "PySide2.QtLocation.QPlaceReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceReply.abort": (),
-    "PySide2.QtLocation.QPlaceReply.error": (),
-    "PySide2.QtLocation.QPlaceReply.errorString": (),
-    "PySide2.QtLocation.QPlaceReply.isFinished": (),
-    "PySide2.QtLocation.QPlaceReply.setError": ('PySide2.QtLocation.QPlaceReply.Error', 'str'),
-    "PySide2.QtLocation.QPlaceReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QPlaceReply.type": (),
-# class PySide2.QtLocation.QPlaceResult:
-    "PySide2.QtLocation.QPlaceResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceResult.distance": (),
-    "PySide2.QtLocation.QPlaceResult.isSponsored": (),
-    "PySide2.QtLocation.QPlaceResult.place": (),
-    "PySide2.QtLocation.QPlaceResult.setDistance": ('float',),
-    "PySide2.QtLocation.QPlaceResult.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceResult.setSponsored": ('bool',),
-# class PySide2.QtLocation.QPlaceReview:
-    "PySide2.QtLocation.QPlaceReview.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceReview.dateTime": (),
-    "PySide2.QtLocation.QPlaceReview.language": (),
-    "PySide2.QtLocation.QPlaceReview.rating": (),
-    "PySide2.QtLocation.QPlaceReview.reviewId": (),
-    "PySide2.QtLocation.QPlaceReview.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QPlaceReview.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setRating": ('float',),
-    "PySide2.QtLocation.QPlaceReview.setReviewId": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setText": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceReview.text": (),
-    "PySide2.QtLocation.QPlaceReview.title": (),
-# class PySide2.QtLocation.QPlaceSearchReply:
-    "PySide2.QtLocation.QPlaceSearchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.request": (),
-    "PySide2.QtLocation.QPlaceSearchReply.results": (),
-    "PySide2.QtLocation.QPlaceSearchReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-    "PySide2.QtLocation.QPlaceSearchReply.type": (),
-# class PySide2.QtLocation.QPlaceSearchRequest:
-# class PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint:
-    "PySide2.QtLocation.QPlaceSearchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceSearchRequest',)],
-    "PySide2.QtLocation.QPlaceSearchRequest.categories": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.limit": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.recommendationId": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.relevanceHint": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchArea": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchContext": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchTerm": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRecommendationId": ('str',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRelevanceHint": ('PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchTerm": ('str',),
-# class PySide2.QtLocation.QPlaceSearchResult:
-# class PySide2.QtLocation.QPlaceSearchResult.SearchResultType:
-    "PySide2.QtLocation.QPlaceSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceSearchResult.icon": (),
-    "PySide2.QtLocation.QPlaceSearchResult.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSearchResult.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceSearchResult.title": (),
-    "PySide2.QtLocation.QPlaceSearchResult.type": (),
-# class PySide2.QtLocation.QPlaceSearchSuggestionReply:
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.setSuggestions": ('typing.Sequence[str]',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.suggestions": (),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.type": (),
-# class PySide2.QtLocation.QPlaceSupplier:
-    "PySide2.QtLocation.QPlaceSupplier.__init__": [(), ('PySide2.QtLocation.QPlaceSupplier',)],
-    "PySide2.QtLocation.QPlaceSupplier.__copy__": (),
-    "PySide2.QtLocation.QPlaceSupplier.icon": (),
-    "PySide2.QtLocation.QPlaceSupplier.isEmpty": (),
-    "PySide2.QtLocation.QPlaceSupplier.name": (),
-    "PySide2.QtLocation.QPlaceSupplier.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSupplier.setName": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setSupplierId": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceSupplier.supplierId": (),
-    "PySide2.QtLocation.QPlaceSupplier.url": (),
-# class PySide2.QtLocation.QPlaceUser:
-    "PySide2.QtLocation.QPlaceUser.__init__": [(), ('PySide2.QtLocation.QPlaceUser',)],
-    "PySide2.QtLocation.QPlaceUser.__copy__": (),
-    "PySide2.QtLocation.QPlaceUser.name": (),
-    "PySide2.QtLocation.QPlaceUser.setName": ('str',),
-    "PySide2.QtLocation.QPlaceUser.setUserId": ('str',),
-    "PySide2.QtLocation.QPlaceUser.userId": (),
-    }) if "PySide2.QtLocation" in sys.modules else None
-# Module PySide2.QtQml
-sig_dict.update({
-# class PySide2.QtQml.ListProperty:
-    "PySide2.QtQml.ListProperty.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable'),
-# class PySide2.QtQml.QJSEngine:
-# class PySide2.QtQml.QJSEngine.Extension:
-# class PySide2.QtQml.QJSEngine.Extensions:
-    "PySide2.QtQml.QJSEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QJSEngine.collectGarbage": (),
-    "PySide2.QtQml.QJSEngine.evaluate": ('str', 'str', 'int'),
-    "PySide2.QtQml.QJSEngine.globalObject": (),
-    "PySide2.QtQml.QJSEngine.importModule": ('str',),
-    "PySide2.QtQml.QJSEngine.installExtensions": ('PySide2.QtQml.QJSEngine.Extensions', 'PySide2.QtQml.QJSValue'),
-    "PySide2.QtQml.QJSEngine.installTranslatorFunctions": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSEngine.isInterrupted": (),
-    "PySide2.QtQml.QJSEngine.newArray": ('int',),
-    "PySide2.QtQml.QJSEngine.newErrorObject": ('PySide2.QtQml.QJSValue.ErrorType', 'str'),
-    "PySide2.QtQml.QJSEngine.newObject": (),
-    "PySide2.QtQml.QJSEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtQml.QJSEngine.newQObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QJSEngine.setInterrupted": ('bool',),
-    "PySide2.QtQml.QJSEngine.throwError": [('PySide2.QtQml.QJSValue.ErrorType', 'str'), ('str',)],
-    "PySide2.QtQml.QJSEngine.toScriptValue": ('typing.Any',),
-# class PySide2.QtQml.QJSValue:
-# class PySide2.QtQml.QJSValue.ErrorType:
-# class PySide2.QtQml.QJSValue.SpecialValue:
-    "PySide2.QtQml.QJSValue.__init__": [('PySide2.QtQml.QJSValue',), ('PySide2.QtQml.QJSValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.__copy__": (),
-    "PySide2.QtQml.QJSValue.call": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callAsConstructor": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callWithInstance": ('PySide2.QtQml.QJSValue', 'typing.Sequence[PySide2.QtQml.QJSValue]'),
-    "PySide2.QtQml.QJSValue.deleteProperty": ('str',),
-    "PySide2.QtQml.QJSValue.engine": (),
-    "PySide2.QtQml.QJSValue.equals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.errorType": (),
-    "PySide2.QtQml.QJSValue.hasOwnProperty": ('str',),
-    "PySide2.QtQml.QJSValue.hasProperty": ('str',),
-    "PySide2.QtQml.QJSValue.isArray": (),
-    "PySide2.QtQml.QJSValue.isBool": (),
-    "PySide2.QtQml.QJSValue.isCallable": (),
-    "PySide2.QtQml.QJSValue.isDate": (),
-    "PySide2.QtQml.QJSValue.isError": (),
-    "PySide2.QtQml.QJSValue.isNull": (),
-    "PySide2.QtQml.QJSValue.isNumber": (),
-    "PySide2.QtQml.QJSValue.isObject": (),
-    "PySide2.QtQml.QJSValue.isQMetaObject": (),
-    "PySide2.QtQml.QJSValue.isQObject": (),
-    "PySide2.QtQml.QJSValue.isRegExp": (),
-    "PySide2.QtQml.QJSValue.isString": (),
-    "PySide2.QtQml.QJSValue.isUndefined": (),
-    "PySide2.QtQml.QJSValue.isVariant": (),
-    "PySide2.QtQml.QJSValue.property": [('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.prototype": (),
-    "PySide2.QtQml.QJSValue.setProperty": [('int', 'PySide2.QtQml.QJSValue'), ('str', 'PySide2.QtQml.QJSValue')],
-    "PySide2.QtQml.QJSValue.setPrototype": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.strictlyEquals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.toBool": (),
-    "PySide2.QtQml.QJSValue.toDateTime": (),
-    "PySide2.QtQml.QJSValue.toInt": (),
-    "PySide2.QtQml.QJSValue.toNumber": (),
-    "PySide2.QtQml.QJSValue.toQMetaObject": (),
-    "PySide2.QtQml.QJSValue.toQObject": (),
-    "PySide2.QtQml.QJSValue.toString": (),
-    "PySide2.QtQml.QJSValue.toUInt": (),
-    "PySide2.QtQml.QJSValue.toVariant": (),
-# class PySide2.QtQml.QJSValueIterator:
-    "PySide2.QtQml.QJSValueIterator.__init__": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValueIterator.hasNext": (),
-    "PySide2.QtQml.QJSValueIterator.name": (),
-    "PySide2.QtQml.QJSValueIterator.value": (),
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor:
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType:
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.__init__": (),
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.intercept": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType'),
-# class PySide2.QtQml.QQmlApplicationEngine:
-    "PySide2.QtQml.QQmlApplicationEngine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlApplicationEngine.load": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlApplicationEngine.loadData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlApplicationEngine.rootObjects": (),
-    "PySide2.QtQml.QQmlApplicationEngine.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtQml.QQmlComponent:
-# class PySide2.QtQml.QQmlComponent.CompilationMode:
-# class PySide2.QtQml.QQmlComponent.Status:
-    "PySide2.QtQml.QQmlComponent.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlComponent.beginCreate": ('PySide2.QtQml.QQmlContext',),
-    "PySide2.QtQml.QQmlComponent.completeCreate": (),
-    "PySide2.QtQml.QQmlComponent.create": [('PySide2.QtQml.QQmlContext',), ('PySide2.QtQml.QQmlIncubator', 'PySide2.QtQml.QQmlContext', 'PySide2.QtQml.QQmlContext')],
-    "PySide2.QtQml.QQmlComponent.createWithInitialProperties": ('typing.Dict[str, typing.Any]', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlComponent.creationContext": (),
-    "PySide2.QtQml.QQmlComponent.engine": (),
-    "PySide2.QtQml.QQmlComponent.errorString": (),
-    "PySide2.QtQml.QQmlComponent.errors": (),
-    "PySide2.QtQml.QQmlComponent.isError": (),
-    "PySide2.QtQml.QQmlComponent.isLoading": (),
-    "PySide2.QtQml.QQmlComponent.isNull": (),
-    "PySide2.QtQml.QQmlComponent.isReady": (),
-    "PySide2.QtQml.QQmlComponent.loadUrl": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode')],
-    "PySide2.QtQml.QQmlComponent.progress": (),
-    "PySide2.QtQml.QQmlComponent.setData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlComponent.setInitialProperties": ('PySide2.QtCore.QObject', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlComponent.status": (),
-    "PySide2.QtQml.QQmlComponent.url": (),
-# class PySide2.QtQml.QQmlContext:
-    "PySide2.QtQml.QQmlContext.__init__": [('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlContext.baseUrl": (),
-    "PySide2.QtQml.QQmlContext.contextObject": (),
-    "PySide2.QtQml.QQmlContext.contextProperty": ('str',),
-    "PySide2.QtQml.QQmlContext.engine": (),
-    "PySide2.QtQml.QQmlContext.isValid": (),
-    "PySide2.QtQml.QQmlContext.nameForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.parentContext": (),
-    "PySide2.QtQml.QQmlContext.resolvedUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setContextObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.setContextProperty": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Any')],
-# class PySide2.QtQml.QQmlDebuggingEnabler:
-# class PySide2.QtQml.QQmlDebuggingEnabler.StartMode:
-    "PySide2.QtQml.QQmlDebuggingEnabler.__init__": ('bool',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.connectToLocalDebugger": ('str', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.debuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.inspectorServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.nativeDebuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.profilerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.setServices": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startDebugConnector": ('str', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startTcpDebugServer": ('int', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode', 'str'),
-# class PySide2.QtQml.QQmlEngine:
-# class PySide2.QtQml.QQmlEngine.ObjectOwnership:
-    "PySide2.QtQml.QQmlEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.addImageProvider": ('str', 'PySide2.QtQml.QQmlImageProviderBase'),
-    "PySide2.QtQml.QQmlEngine.addImportPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.addNamedBundle": ('str', 'str'),
-    "PySide2.QtQml.QQmlEngine.addPluginPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.baseUrl": (),
-    "PySide2.QtQml.QQmlEngine.clearComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.contextForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQml.QQmlEngine.imageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.importPathList": (),
-    "PySide2.QtQml.QQmlEngine.importPlugin": ('str', 'str', 'typing.Sequence[PySide2.QtQml.QQmlError]'),
-    "PySide2.QtQml.QQmlEngine.incubationController": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManager": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManagerFactory": (),
-    "PySide2.QtQml.QQmlEngine.objectOwnership": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.offlineStorageDatabaseFilePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.offlineStoragePath": (),
-    "PySide2.QtQml.QQmlEngine.outputWarningsToStandardError": (),
-    "PySide2.QtQml.QQmlEngine.pluginPathList": (),
-    "PySide2.QtQml.QQmlEngine.removeImageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.retranslate": (),
-    "PySide2.QtQml.QQmlEngine.rootContext": (),
-    "PySide2.QtQml.QQmlEngine.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlEngine.setContextForObject": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlEngine.setImportPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setIncubationController": ('PySide2.QtQml.QQmlIncubationController',),
-    "PySide2.QtQml.QQmlEngine.setNetworkAccessManagerFactory": ('PySide2.QtQml.QQmlNetworkAccessManagerFactory',),
-    "PySide2.QtQml.QQmlEngine.setObjectOwnership": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine.ObjectOwnership'),
-    "PySide2.QtQml.QQmlEngine.setOfflineStoragePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.setOutputWarningsToStandardError": ('bool',),
-    "PySide2.QtQml.QQmlEngine.setPluginPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setUrlInterceptor": ('PySide2.QtQml.QQmlAbstractUrlInterceptor',),
-    "PySide2.QtQml.QQmlEngine.trimComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.urlInterceptor": (),
-# class PySide2.QtQml.QQmlError:
-    "PySide2.QtQml.QQmlError.__init__": [(), ('PySide2.QtQml.QQmlError',)],
-    "PySide2.QtQml.QQmlError.__copy__": (),
-    "PySide2.QtQml.QQmlError.column": (),
-    "PySide2.QtQml.QQmlError.description": (),
-    "PySide2.QtQml.QQmlError.isValid": (),
-    "PySide2.QtQml.QQmlError.line": (),
-    "PySide2.QtQml.QQmlError.messageType": (),
-    "PySide2.QtQml.QQmlError.object": (),
-    "PySide2.QtQml.QQmlError.setColumn": ('int',),
-    "PySide2.QtQml.QQmlError.setDescription": ('str',),
-    "PySide2.QtQml.QQmlError.setLine": ('int',),
-    "PySide2.QtQml.QQmlError.setMessageType": ('PySide2.QtCore.QtMsgType',),
-    "PySide2.QtQml.QQmlError.setObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlError.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlError.toString": (),
-    "PySide2.QtQml.QQmlError.url": (),
-# class PySide2.QtQml.QQmlExpression:
-    "PySide2.QtQml.QQmlExpression.__init__": [(), ('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlScriptString', 'PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlExpression.clearError": (),
-    "PySide2.QtQml.QQmlExpression.columnNumber": (),
-    "PySide2.QtQml.QQmlExpression.context": (),
-    "PySide2.QtQml.QQmlExpression.engine": (),
-    "PySide2.QtQml.QQmlExpression.error": (),
-    "PySide2.QtQml.QQmlExpression.evaluate": (),
-    "PySide2.QtQml.QQmlExpression.expression": (),
-    "PySide2.QtQml.QQmlExpression.hasError": (),
-    "PySide2.QtQml.QQmlExpression.lineNumber": (),
-    "PySide2.QtQml.QQmlExpression.notifyOnValueChanged": (),
-    "PySide2.QtQml.QQmlExpression.scopeObject": (),
-    "PySide2.QtQml.QQmlExpression.setExpression": ('str',),
-    "PySide2.QtQml.QQmlExpression.setNotifyOnValueChanged": ('bool',),
-    "PySide2.QtQml.QQmlExpression.setSourceLocation": ('str', 'int', 'int'),
-    "PySide2.QtQml.QQmlExpression.sourceFile": (),
-# class PySide2.QtQml.QQmlExtensionInterface:
-    "PySide2.QtQml.QQmlExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlExtensionInterface.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-# class PySide2.QtQml.QQmlExtensionPlugin:
-    "PySide2.QtQml.QQmlExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlExtensionPlugin.baseUrl": (),
-    "PySide2.QtQml.QQmlExtensionPlugin.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-    "PySide2.QtQml.QQmlExtensionPlugin.registerTypes": ('str',),
-# class PySide2.QtQml.QQmlFile:
-# class PySide2.QtQml.QQmlFile.Status:
-    "PySide2.QtQml.QQmlFile.__init__": [(), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.clear": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QQmlFile.connectDownloadProgress": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.connectFinished": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.data": (),
-    "PySide2.QtQml.QQmlFile.dataByteArray": (),
-    "PySide2.QtQml.QQmlFile.error": (),
-    "PySide2.QtQml.QQmlFile.isError": (),
-    "PySide2.QtQml.QQmlFile.isLoading": (),
-    "PySide2.QtQml.QQmlFile.isLocalFile": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.isNull": (),
-    "PySide2.QtQml.QQmlFile.isReady": (),
-    "PySide2.QtQml.QQmlFile.isSynchronous": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.load": [('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.size": (),
-    "PySide2.QtQml.QQmlFile.status": (),
-    "PySide2.QtQml.QQmlFile.url": (),
-    "PySide2.QtQml.QQmlFile.urlToLocalFileOrQrc": [('PySide2.QtCore.QUrl',), ('str',)],
-# class PySide2.QtQml.QQmlFileSelector:
-    "PySide2.QtQml.QQmlFileSelector.__init__": ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQml.QQmlFileSelector.get": ('PySide2.QtQml.QQmlEngine',),
-    "PySide2.QtQml.QQmlFileSelector.selector": (),
-    "PySide2.QtQml.QQmlFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlFileSelector.setSelector": ('PySide2.QtCore.QFileSelector',),
-# class PySide2.QtQml.QQmlImageProviderBase:
-# class PySide2.QtQml.QQmlImageProviderBase.Flag:
-# class PySide2.QtQml.QQmlImageProviderBase.Flags:
-# class PySide2.QtQml.QQmlImageProviderBase.ImageType:
-    "PySide2.QtQml.QQmlImageProviderBase.flags": (),
-    "PySide2.QtQml.QQmlImageProviderBase.imageType": (),
-# class PySide2.QtQml.QQmlIncubationController:
-    "PySide2.QtQml.QQmlIncubationController.__init__": (),
-    "PySide2.QtQml.QQmlIncubationController.engine": (),
-    "PySide2.QtQml.QQmlIncubationController.incubateFor": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubateWhile": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCount": (),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCountChanged": ('int',),
-# class PySide2.QtQml.QQmlIncubator:
-# class PySide2.QtQml.QQmlIncubator.IncubationMode:
-# class PySide2.QtQml.QQmlIncubator.Status:
-    "PySide2.QtQml.QQmlIncubator.__init__": ('PySide2.QtQml.QQmlIncubator.IncubationMode',),
-    "PySide2.QtQml.QQmlIncubator.clear": (),
-    "PySide2.QtQml.QQmlIncubator.errors": (),
-    "PySide2.QtQml.QQmlIncubator.forceCompletion": (),
-    "PySide2.QtQml.QQmlIncubator.incubationMode": (),
-    "PySide2.QtQml.QQmlIncubator.isError": (),
-    "PySide2.QtQml.QQmlIncubator.isLoading": (),
-    "PySide2.QtQml.QQmlIncubator.isNull": (),
-    "PySide2.QtQml.QQmlIncubator.isReady": (),
-    "PySide2.QtQml.QQmlIncubator.object": (),
-    "PySide2.QtQml.QQmlIncubator.setInitialState": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlIncubator.status": (),
-    "PySide2.QtQml.QQmlIncubator.statusChanged": ('PySide2.QtQml.QQmlIncubator.Status',),
-# class PySide2.QtQml.QQmlListReference:
-    "PySide2.QtQml.QQmlListReference.__init__": [(), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlListReference',)],
-    "PySide2.QtQml.QQmlListReference.__copy__": (),
-    "PySide2.QtQml.QQmlListReference.append": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlListReference.at": ('int',),
-    "PySide2.QtQml.QQmlListReference.canAppend": (),
-    "PySide2.QtQml.QQmlListReference.canAt": (),
-    "PySide2.QtQml.QQmlListReference.canClear": (),
-    "PySide2.QtQml.QQmlListReference.canCount": (),
-    "PySide2.QtQml.QQmlListReference.clear": (),
-    "PySide2.QtQml.QQmlListReference.count": (),
-    "PySide2.QtQml.QQmlListReference.isManipulable": (),
-    "PySide2.QtQml.QQmlListReference.isReadable": (),
-    "PySide2.QtQml.QQmlListReference.isValid": (),
-    "PySide2.QtQml.QQmlListReference.listElementType": (),
-    "PySide2.QtQml.QQmlListReference.object": (),
-# class PySide2.QtQml.QQmlNetworkAccessManagerFactory:
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.__init__": (),
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.create": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.QQmlParserStatus:
-    "PySide2.QtQml.QQmlParserStatus.__init__": (),
-    "PySide2.QtQml.QQmlParserStatus.classBegin": (),
-    "PySide2.QtQml.QQmlParserStatus.componentComplete": (),
-# class PySide2.QtQml.QQmlProperty:
-# class PySide2.QtQml.QQmlProperty.PropertyTypeCategory:
-# class PySide2.QtQml.QQmlProperty.Type:
-    "PySide2.QtQml.QQmlProperty.__init__": [(), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlProperty',)],
-    "PySide2.QtQml.QQmlProperty.__copy__": (),
-    "PySide2.QtQml.QQmlProperty.connectNotifySignal": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlProperty.hasNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.index": (),
-    "PySide2.QtQml.QQmlProperty.isDesignable": (),
-    "PySide2.QtQml.QQmlProperty.isProperty": (),
-    "PySide2.QtQml.QQmlProperty.isResettable": (),
-    "PySide2.QtQml.QQmlProperty.isSignalProperty": (),
-    "PySide2.QtQml.QQmlProperty.isValid": (),
-    "PySide2.QtQml.QQmlProperty.isWritable": (),
-    "PySide2.QtQml.QQmlProperty.method": (),
-    "PySide2.QtQml.QQmlProperty.name": (),
-    "PySide2.QtQml.QQmlProperty.needsNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.object": (),
-    "PySide2.QtQml.QQmlProperty.property": (),
-    "PySide2.QtQml.QQmlProperty.propertyType": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeCategory": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeName": (),
-    "PySide2.QtQml.QQmlProperty.read": [(), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine')],
-    "PySide2.QtQml.QQmlProperty.reset": (),
-    "PySide2.QtQml.QQmlProperty.type": (),
-    "PySide2.QtQml.QQmlProperty.write": [('PySide2.QtCore.QObject', 'str', 'typing.Any'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlEngine'), ('typing.Any',)],
-# class PySide2.QtQml.QQmlPropertyMap:
-    "PySide2.QtQml.QQmlPropertyMap.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlPropertyMap.clear": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.contains": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.count": (),
-    "PySide2.QtQml.QQmlPropertyMap.insert": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.isEmpty": (),
-    "PySide2.QtQml.QQmlPropertyMap.keys": (),
-    "PySide2.QtQml.QQmlPropertyMap.size": (),
-    "PySide2.QtQml.QQmlPropertyMap.updateValue": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.value": ('str',),
-# class PySide2.QtQml.QQmlPropertyValueSource:
-    "PySide2.QtQml.QQmlPropertyValueSource.__init__": (),
-    "PySide2.QtQml.QQmlPropertyValueSource.setTarget": ('PySide2.QtQml.QQmlProperty',),
-# class PySide2.QtQml.QQmlScriptString:
-    "PySide2.QtQml.QQmlScriptString.__init__": [(), ('PySide2.QtQml.QQmlScriptString',)],
-    "PySide2.QtQml.QQmlScriptString.__copy__": (),
-    "PySide2.QtQml.QQmlScriptString.booleanLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isEmpty": (),
-    "PySide2.QtQml.QQmlScriptString.isNullLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isUndefinedLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.numberLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.stringLiteral": (),
-# class PySide2.QtQml.QQmlTypesExtensionInterface:
-    "PySide2.QtQml.QQmlTypesExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlTypesExtensionInterface.registerTypes": ('str',),
-# class PySide2.QtQml.QtQml:
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObject": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObjectById": ('int', 'PySide2.QtCore.QObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlContext": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlEngine": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlExecuteDeferred": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.VolatileBool:
-    "PySide2.QtQml.VolatileBool.get": (),
-    "PySide2.QtQml.VolatileBool.set": ('object',),
-    "PySide2.QtQml.VolatileBool.qmlRegisterType": ('type', 'str', 'int', 'int', 'str'),
-    }) if "PySide2.QtQml" in sys.modules else None
-# Module PySide2.QtQuick
-sig_dict.update({
-# class PySide2.QtQuick.QQuickAsyncImageProvider:
-    "PySide2.QtQuick.QQuickAsyncImageProvider.__init__": (),
-    "PySide2.QtQuick.QQuickAsyncImageProvider.requestImageResponse": ('str', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickFramebufferObject:
-# class PySide2.QtQuick.QQuickFramebufferObject.Renderer:
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.__init__": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.createFramebufferObject": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.framebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.invalidateFramebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.render": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.synchronize": ('PySide2.QtQuick.QQuickFramebufferObject',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.update": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickFramebufferObject.createRenderer": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickFramebufferObject.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.mirrorVertically": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.releaseResources": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.setMirrorVertically": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.setTextureFollowsItemSize": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureFollowsItemSize": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickImageProvider:
-    "PySide2.QtQuick.QQuickImageProvider.__init__": ('PySide2.QtQml.QQmlImageProviderBase.ImageType', 'PySide2.QtQml.QQmlImageProviderBase.Flags'),
-    "PySide2.QtQuick.QQuickImageProvider.flags": (),
-    "PySide2.QtQuick.QQuickImageProvider.imageType": (),
-    "PySide2.QtQuick.QQuickImageProvider.requestImage": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestPixmap": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestTexture": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickImageResponse:
-    "PySide2.QtQuick.QQuickImageResponse.__init__": (),
-    "PySide2.QtQuick.QQuickImageResponse.cancel": (),
-    "PySide2.QtQuick.QQuickImageResponse.errorString": (),
-    "PySide2.QtQuick.QQuickImageResponse.textureFactory": (),
-# class PySide2.QtQuick.QQuickItem:
-# class PySide2.QtQuick.QQuickItem.Flag:
-# class PySide2.QtQuick.QQuickItem.Flags:
-# class PySide2.QtQuick.QQuickItem.ItemChange:
-# class PySide2.QtQuick.QQuickItem.TransformOrigin:
-# class PySide2.QtQuick.QQuickItem.UpdatePaintNodeData:
-    "PySide2.QtQuick.QQuickItem.UpdatePaintNodeData.__copy__": (),
-    "PySide2.QtQuick.QQuickItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.acceptHoverEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptTouchEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptedMouseButtons": (),
-    "PySide2.QtQuick.QQuickItem.activeFocusOnTab": (),
-    "PySide2.QtQuick.QQuickItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickItem.baselineOffset": (),
-    "PySide2.QtQuick.QQuickItem.boundingRect": (),
-    "PySide2.QtQuick.QQuickItem.childAt": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.childItems": (),
-    "PySide2.QtQuick.QQuickItem.childMouseEventFilter": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickItem.childrenRect": (),
-    "PySide2.QtQuick.QQuickItem.classBegin": (),
-    "PySide2.QtQuick.QQuickItem.clip": (),
-    "PySide2.QtQuick.QQuickItem.clipRect": (),
-    "PySide2.QtQuick.QQuickItem.componentComplete": (),
-    "PySide2.QtQuick.QQuickItem.containmentMask": (),
-    "PySide2.QtQuick.QQuickItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.cursor": (),
-    "PySide2.QtQuick.QQuickItem.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuick.QQuickItem.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuick.QQuickItem.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuick.QQuickItem.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuick.QQuickItem.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItem.filtersChildMouseEvents": (),
-    "PySide2.QtQuick.QQuickItem.flags": (),
-    "PySide2.QtQuick.QQuickItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.forceActiveFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtQuick.QQuickItem.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.grabMouse": (),
-    "PySide2.QtQuick.QQuickItem.grabToImage": [('PySide2.QtCore.QSize',), ('PySide2.QtQml.QJSValue', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickItem.grabTouchPoints": ('typing.List[int]',),
-    "PySide2.QtQuick.QQuickItem.hasActiveFocus": (),
-    "PySide2.QtQuick.QQuickItem.hasFocus": (),
-    "PySide2.QtQuick.QQuickItem.height": (),
-    "PySide2.QtQuick.QQuickItem.heightValid": (),
-    "PySide2.QtQuick.QQuickItem.hoverEnterEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverLeaveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverMoveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.implicitHeight": (),
-    "PySide2.QtQuick.QQuickItem.implicitWidth": (),
-    "PySide2.QtQuick.QQuickItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtQuick.QQuickItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtQuick.QQuickItem.isAncestorOf": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.isComponentComplete": (),
-    "PySide2.QtQuick.QQuickItem.isEnabled": (),
-    "PySide2.QtQuick.QQuickItem.isFocusScope": (),
-    "PySide2.QtQuick.QQuickItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickItem.isUnderMouse": (),
-    "PySide2.QtQuick.QQuickItem.isVisible": (),
-    "PySide2.QtQuick.QQuickItem.itemTransform": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.keepMouseGrab": (),
-    "PySide2.QtQuick.QQuickItem.keepTouchGrab": (),
-    "PySide2.QtQuick.QQuickItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.mapFromGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapFromScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapRectFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectFromScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapRectToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectToScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapToGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapToScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.nextItemInFocusChain": ('bool',),
-    "PySide2.QtQuick.QQuickItem.opacity": (),
-    "PySide2.QtQuick.QQuickItem.parentItem": (),
-    "PySide2.QtQuick.QQuickItem.polish": (),
-    "PySide2.QtQuick.QQuickItem.position": (),
-    "PySide2.QtQuick.QQuickItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickItem.resetAntialiasing": (),
-    "PySide2.QtQuick.QQuickItem.resetHeight": (),
-    "PySide2.QtQuick.QQuickItem.resetWidth": (),
-    "PySide2.QtQuick.QQuickItem.rotation": (),
-    "PySide2.QtQuick.QQuickItem.scale": (),
-    "PySide2.QtQuick.QQuickItem.scopedFocusItem": (),
-    "PySide2.QtQuick.QQuickItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtQuick.QQuickItem.setActiveFocusOnTab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setBaselineOffset": ('float',),
-    "PySide2.QtQuick.QQuickItem.setClip": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setContainmentMask": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtQuick.QQuickItem.setEnabled": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFiltersChildMouseEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFlag": ('PySide2.QtQuick.QQuickItem.Flag', 'bool'),
-    "PySide2.QtQuick.QQuickItem.setFlags": ('PySide2.QtQuick.QQuickItem.Flags',),
-    "PySide2.QtQuick.QQuickItem.setFocus": [('bool',), ('bool', 'PySide2.QtCore.Qt.FocusReason')],
-    "PySide2.QtQuick.QQuickItem.setHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitSize": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.setImplicitWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setKeepMouseGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setKeepTouchGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setOpacity": ('float',),
-    "PySide2.QtQuick.QQuickItem.setParentItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setRotation": ('float',),
-    "PySide2.QtQuick.QQuickItem.setScale": ('float',),
-    "PySide2.QtQuick.QQuickItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtQuick.QQuickItem.setSmooth": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setState": ('str',),
-    "PySide2.QtQuick.QQuickItem.setTransformOrigin": ('PySide2.QtQuick.QQuickItem.TransformOrigin',),
-    "PySide2.QtQuick.QQuickItem.setTransformOriginPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setVisible": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setX": ('float',),
-    "PySide2.QtQuick.QQuickItem.setY": ('float',),
-    "PySide2.QtQuick.QQuickItem.setZ": ('float',),
-    "PySide2.QtQuick.QQuickItem.size": (),
-    "PySide2.QtQuick.QQuickItem.smooth": (),
-    "PySide2.QtQuick.QQuickItem.stackAfter": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.stackBefore": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.state": (),
-    "PySide2.QtQuick.QQuickItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickItem.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtQuick.QQuickItem.touchUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.transformOrigin": (),
-    "PySide2.QtQuick.QQuickItem.transformOriginPoint": (),
-    "PySide2.QtQuick.QQuickItem.ungrabMouse": (),
-    "PySide2.QtQuick.QQuickItem.ungrabTouchPoints": (),
-    "PySide2.QtQuick.QQuickItem.unsetCursor": (),
-    "PySide2.QtQuick.QQuickItem.update": (),
-    "PySide2.QtQuick.QQuickItem.updateInputMethod": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtQuick.QQuickItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-    "PySide2.QtQuick.QQuickItem.updatePolish": (),
-    "PySide2.QtQuick.QQuickItem.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtQuick.QQuickItem.width": (),
-    "PySide2.QtQuick.QQuickItem.widthValid": (),
-    "PySide2.QtQuick.QQuickItem.window": (),
-    "PySide2.QtQuick.QQuickItem.windowDeactivateEvent": (),
-    "PySide2.QtQuick.QQuickItem.x": (),
-    "PySide2.QtQuick.QQuickItem.y": (),
-    "PySide2.QtQuick.QQuickItem.z": (),
-# class PySide2.QtQuick.QQuickItemGrabResult:
-    "PySide2.QtQuick.QQuickItemGrabResult.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItemGrabResult.image": (),
-    "PySide2.QtQuick.QQuickItemGrabResult.saveToFile": ('str',),
-    "PySide2.QtQuick.QQuickItemGrabResult.url": (),
-# class PySide2.QtQuick.QQuickPaintedItem:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHint:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHints:
-# class PySide2.QtQuick.QQuickPaintedItem.RenderTarget:
-    "PySide2.QtQuick.QQuickPaintedItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickPaintedItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsBoundingRect": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsScale": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.fillColor": (),
-    "PySide2.QtQuick.QQuickPaintedItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.mipmap": (),
-    "PySide2.QtQuick.QQuickPaintedItem.opaquePainting": (),
-    "PySide2.QtQuick.QQuickPaintedItem.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtQuick.QQuickPaintedItem.performanceHints": (),
-    "PySide2.QtQuick.QQuickPaintedItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickPaintedItem.renderTarget": (),
-    "PySide2.QtQuick.QQuickPaintedItem.resetContentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsScale": ('float',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.setFillColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickPaintedItem.setMipmap": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setOpaquePainting": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHint": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHint', 'bool'),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHints": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHints',),
-    "PySide2.QtQuick.QQuickPaintedItem.setRenderTarget": ('PySide2.QtQuick.QQuickPaintedItem.RenderTarget',),
-    "PySide2.QtQuick.QQuickPaintedItem.setTextureSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.textureSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.update": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtQuick.QQuickPaintedItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickRenderControl:
-    "PySide2.QtQuick.QQuickRenderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickRenderControl.grab": (),
-    "PySide2.QtQuick.QQuickRenderControl.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QQuickRenderControl.invalidate": (),
-    "PySide2.QtQuick.QQuickRenderControl.polishItems": (),
-    "PySide2.QtQuick.QQuickRenderControl.prepareThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtQuick.QQuickRenderControl.render": (),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindow": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindowFor": ('PySide2.QtQuick.QQuickWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtQuick.QQuickRenderControl.sync": (),
-# class PySide2.QtQuick.QQuickTextDocument:
-    "PySide2.QtQuick.QQuickTextDocument.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTextDocument.textDocument": (),
-# class PySide2.QtQuick.QQuickTextureFactory:
-    "PySide2.QtQuick.QQuickTextureFactory.__init__": (),
-    "PySide2.QtQuick.QQuickTextureFactory.createTexture": ('PySide2.QtQuick.QQuickWindow',),
-    "PySide2.QtQuick.QQuickTextureFactory.image": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureByteCount": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureFactoryForImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtQuick.QQuickTextureFactory.textureSize": (),
-# class PySide2.QtQuick.QQuickTransform:
-    "PySide2.QtQuick.QQuickTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickTransform.appendToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QQuickTransform.prependToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.update": (),
-# class PySide2.QtQuick.QQuickView:
-# class PySide2.QtQuick.QQuickView.ResizeMode:
-# class PySide2.QtQuick.QQuickView.Status:
-    "PySide2.QtQuick.QQuickView.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtGui.QWindow'), ('PySide2.QtCore.QUrl', 'PySide2.QtQuick.QQuickRenderControl'), ('PySide2.QtGui.QWindow',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtQuick.QQuickView.engine": (),
-    "PySide2.QtQuick.QQuickView.errors": (),
-    "PySide2.QtQuick.QQuickView.initialSize": (),
-    "PySide2.QtQuick.QQuickView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickView.resizeMode": (),
-    "PySide2.QtQuick.QQuickView.rootContext": (),
-    "PySide2.QtQuick.QQuickView.rootObject": (),
-    "PySide2.QtQuick.QQuickView.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuick.QQuickView.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtQuick.QQuickView.setResizeMode": ('PySide2.QtQuick.QQuickView.ResizeMode',),
-    "PySide2.QtQuick.QQuickView.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuick.QQuickView.sizeHint": (),
-    "PySide2.QtQuick.QQuickView.source": (),
-    "PySide2.QtQuick.QQuickView.status": (),
-    "PySide2.QtQuick.QQuickView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtQuick.QQuickWindow:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOption:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOptions:
-# class PySide2.QtQuick.QQuickWindow.NativeObjectType:
-# class PySide2.QtQuick.QQuickWindow.RenderStage:
-# class PySide2.QtQuick.QQuickWindow.SceneGraphError:
-# class PySide2.QtQuick.QQuickWindow.TextRenderType:
-    "PySide2.QtQuick.QQuickWindow.__init__": [('PySide2.QtGui.QWindow',), ('PySide2.QtQuick.QQuickRenderControl',)],
-    "PySide2.QtQuick.QQuickWindow.accessibleRoot": (),
-    "PySide2.QtQuick.QQuickWindow.activeFocusItem": (),
-    "PySide2.QtQuick.QQuickWindow.beginExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.clearBeforeRendering": (),
-    "PySide2.QtQuick.QQuickWindow.color": (),
-    "PySide2.QtQuick.QQuickWindow.contentItem": (),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromImage": [('PySide2.QtGui.QImage',), ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions')],
-    "PySide2.QtQuick.QQuickWindow.createTextureFromNativeObject": ('PySide2.QtQuick.QQuickWindow.NativeObjectType', 'int', 'int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.effectiveDevicePixelRatio": (),
-    "PySide2.QtQuick.QQuickWindow.endExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusObject": (),
-    "PySide2.QtQuick.QQuickWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.grabWindow": (),
-    "PySide2.QtQuick.QQuickWindow.hasDefaultAlphaBuffer": (),
-    "PySide2.QtQuick.QQuickWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuick.QQuickWindow.incubationController": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentOpenGLContext": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentSceneGraph": (),
-    "PySide2.QtQuick.QQuickWindow.isSceneGraphInitialized": (),
-    "PySide2.QtQuick.QQuickWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseGrabberItem": (),
-    "PySide2.QtQuick.QQuickWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.openglContext": (),
-    "PySide2.QtQuick.QQuickWindow.releaseResources": (),
-    "PySide2.QtQuick.QQuickWindow.renderTarget": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetId": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetSize": (),
-    "PySide2.QtQuick.QQuickWindow.resetOpenGLState": (),
-    "PySide2.QtQuick.QQuickWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickWindow.sceneGraphBackend": (),
-    "PySide2.QtQuick.QQuickWindow.scheduleRenderJob": ('PySide2.QtCore.QRunnable', 'PySide2.QtQuick.QQuickWindow.RenderStage'),
-    "PySide2.QtQuick.QQuickWindow.sendEvent": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickWindow.setClearBeforeRendering": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickWindow.setDefaultAlphaBuffer": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentOpenGLContext": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentSceneGraph": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setRenderTarget": [('PySide2.QtGui.QOpenGLFramebufferObject',), ('int', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickWindow.setSceneGraphBackend": ('str',),
-    "PySide2.QtQuick.QQuickWindow.setTextRenderType": ('PySide2.QtQuick.QQuickWindow.TextRenderType',),
-    "PySide2.QtQuick.QQuickWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuick.QQuickWindow.textRenderType": (),
-    "PySide2.QtQuick.QQuickWindow.update": (),
-    "PySide2.QtQuick.QQuickWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtQuick.QSGAbstractRenderer:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearMode:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearModeBit:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlag:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags:
-    "PySide2.QtQuick.QSGAbstractRenderer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearColor": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearMode": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.deviceRect": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.nodeChanged": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode.DirtyState'),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrix": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrixWithNativeNDC": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.renderScene": ('int',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearMode": ('PySide2.QtQuick.QSGAbstractRenderer.ClearMode',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setDeviceRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixToRect": [('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRectF', 'PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags')],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixWithNativeNDC": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setViewportRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.viewportRect": (),
-# class PySide2.QtQuick.QSGBasicGeometryNode:
-    "PySide2.QtQuick.QSGBasicGeometryNode.__init__": ('PySide2.QtQuick.QSGNode.NodeType',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.clipList": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.geometry": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.matrix": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setGeometry": ('PySide2.QtQuick.QSGGeometry',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererClipList": ('PySide2.QtQuick.QSGClipNode',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSGClipNode:
-    "PySide2.QtQuick.QSGClipNode.__init__": (),
-    "PySide2.QtQuick.QSGClipNode.clipRect": (),
-    "PySide2.QtQuick.QSGClipNode.isRectangular": (),
-    "PySide2.QtQuick.QSGClipNode.setClipRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGClipNode.setIsRectangular": ('bool',),
-# class PySide2.QtQuick.QSGDynamicTexture:
-    "PySide2.QtQuick.QSGDynamicTexture.__init__": (),
-    "PySide2.QtQuick.QSGDynamicTexture.updateTexture": (),
-# class PySide2.QtQuick.QSGEngine:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOption:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOptions:
-    "PySide2.QtQuick.QSGEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGEngine.createRenderer": (),
-    "PySide2.QtQuick.QSGEngine.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.createTextureFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QSGEngine.invalidate": (),
-# class PySide2.QtQuick.QSGGeometry:
-# class PySide2.QtQuick.QSGGeometry.Attribute:
-    "PySide2.QtQuick.QSGGeometry.Attribute.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Attribute',)],
-    "PySide2.QtQuick.QSGGeometry.Attribute.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Attribute.create": ('int', 'int', 'int', 'bool'),
-    "PySide2.QtQuick.QSGGeometry.Attribute.createWithAttributeType": ('int', 'int', 'int', 'PySide2.QtQuick.QSGGeometry.AttributeType'),
-# class PySide2.QtQuick.QSGGeometry.AttributeSet:
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__init__": [(), ('PySide2.QtQuick.QSGGeometry.AttributeSet',)],
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__copy__": (),
-# class PySide2.QtQuick.QSGGeometry.AttributeType:
-# class PySide2.QtQuick.QSGGeometry.ColoredPoint2D:
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.ColoredPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.set": ('float', 'float', 'int', 'int', 'int', 'int'),
-# class PySide2.QtQuick.QSGGeometry.DataPattern:
-# class PySide2.QtQuick.QSGGeometry.DrawingMode:
-# class PySide2.QtQuick.QSGGeometry.Point2D:
-    "PySide2.QtQuick.QSGGeometry.Point2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Point2D',)],
-    "PySide2.QtQuick.QSGGeometry.Point2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Point2D.set": ('float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.TexturedPoint2D:
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.TexturedPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.set": ('float', 'float', 'float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.Type:
-    "PySide2.QtQuick.QSGGeometry.__init__": ('PySide2.QtQuick.QSGGeometry.AttributeSet', 'int', 'int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.allocate": ('int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.attributeCount": (),
-    "PySide2.QtQuick.QSGGeometry.attributes": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_ColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_Point2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_TexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.drawingMode": (),
-    "PySide2.QtQuick.QSGGeometry.indexCount": (),
-    "PySide2.QtQuick.QSGGeometry.indexData": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUInt": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUShort": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataPattern": (),
-    "PySide2.QtQuick.QSGGeometry.indexType": (),
-    "PySide2.QtQuick.QSGGeometry.lineWidth": (),
-    "PySide2.QtQuick.QSGGeometry.markIndexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.markVertexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.setDrawingMode": ('int',),
-    "PySide2.QtQuick.QSGGeometry.setIndexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.setLineWidth": ('float',),
-    "PySide2.QtQuick.QSGGeometry.setVertexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.sizeOfIndex": (),
-    "PySide2.QtQuick.QSGGeometry.sizeOfVertex": (),
-    "PySide2.QtQuick.QSGGeometry.updateColoredRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateTexturedRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.vertexCount": (),
-    "PySide2.QtQuick.QSGGeometry.vertexData": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsTexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataPattern": (),
-# class PySide2.QtQuick.QSGGeometryNode:
-    "PySide2.QtQuick.QSGGeometryNode.__init__": (),
-    "PySide2.QtQuick.QSGGeometryNode.inheritedOpacity": (),
-    "PySide2.QtQuick.QSGGeometryNode.renderOrder": (),
-    "PySide2.QtQuick.QSGGeometryNode.setInheritedOpacity": ('float',),
-    "PySide2.QtQuick.QSGGeometryNode.setRenderOrder": ('int',),
-# class PySide2.QtQuick.QSGMaterialType:
-    "PySide2.QtQuick.QSGMaterialType.__init__": (),
-# class PySide2.QtQuick.QSGNode:
-# class PySide2.QtQuick.QSGNode.DirtyState:
-# class PySide2.QtQuick.QSGNode.DirtyStateBit:
-# class PySide2.QtQuick.QSGNode.Flag:
-# class PySide2.QtQuick.QSGNode.Flags:
-# class PySide2.QtQuick.QSGNode.NodeType:
-    "PySide2.QtQuick.QSGNode.__init__": [(), ('PySide2.QtQuick.QSGNode.NodeType',)],
-    "PySide2.QtQuick.QSGNode.appendChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.childAtIndex": ('int',),
-    "PySide2.QtQuick.QSGNode.childCount": (),
-    "PySide2.QtQuick.QSGNode.clearDirty": (),
-    "PySide2.QtQuick.QSGNode.dirtyState": (),
-    "PySide2.QtQuick.QSGNode.firstChild": (),
-    "PySide2.QtQuick.QSGNode.flags": (),
-    "PySide2.QtQuick.QSGNode.insertChildNodeAfter": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.insertChildNodeBefore": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGNode.lastChild": (),
-    "PySide2.QtQuick.QSGNode.markDirty": ('PySide2.QtQuick.QSGNode.DirtyState',),
-    "PySide2.QtQuick.QSGNode.nextSibling": (),
-    "PySide2.QtQuick.QSGNode.parent": (),
-    "PySide2.QtQuick.QSGNode.prependChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.preprocess": (),
-    "PySide2.QtQuick.QSGNode.previousSibling": (),
-    "PySide2.QtQuick.QSGNode.removeAllChildNodes": (),
-    "PySide2.QtQuick.QSGNode.removeChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.reparentChildNodesTo": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.setFlag": ('PySide2.QtQuick.QSGNode.Flag', 'bool'),
-    "PySide2.QtQuick.QSGNode.setFlags": ('PySide2.QtQuick.QSGNode.Flags', 'bool'),
-    "PySide2.QtQuick.QSGNode.type": (),
-# class PySide2.QtQuick.QSGOpacityNode:
-    "PySide2.QtQuick.QSGOpacityNode.__init__": (),
-    "PySide2.QtQuick.QSGOpacityNode.combinedOpacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGOpacityNode.opacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.setCombinedOpacity": ('float',),
-    "PySide2.QtQuick.QSGOpacityNode.setOpacity": ('float',),
-# class PySide2.QtQuick.QSGSimpleRectNode:
-    "PySide2.QtQuick.QSGSimpleRectNode.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor')],
-    "PySide2.QtQuick.QSGSimpleRectNode.color": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGSimpleRectNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-# class PySide2.QtQuick.QSGSimpleTextureNode:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformFlag:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode:
-    "PySide2.QtQuick.QSGSimpleTextureNode.__init__": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.filtering": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.ownsTexture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setOwnsTexture": ('bool',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setSourceRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTexture": ('PySide2.QtQuick.QSGTexture',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTextureCoordinatesTransform": ('PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.sourceRect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.texture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.textureCoordinatesTransform": (),
-# class PySide2.QtQuick.QSGTexture:
-# class PySide2.QtQuick.QSGTexture.AnisotropyLevel:
-# class PySide2.QtQuick.QSGTexture.Filtering:
-# class PySide2.QtQuick.QSGTexture.WrapMode:
-    "PySide2.QtQuick.QSGTexture.__init__": (),
-    "PySide2.QtQuick.QSGTexture.anisotropyLevel": (),
-    "PySide2.QtQuick.QSGTexture.bind": (),
-    "PySide2.QtQuick.QSGTexture.comparisonKey": (),
-    "PySide2.QtQuick.QSGTexture.convertToNormalizedSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGTexture.filtering": (),
-    "PySide2.QtQuick.QSGTexture.hasAlphaChannel": (),
-    "PySide2.QtQuick.QSGTexture.hasMipmaps": (),
-    "PySide2.QtQuick.QSGTexture.horizontalWrapMode": (),
-    "PySide2.QtQuick.QSGTexture.isAtlasTexture": (),
-    "PySide2.QtQuick.QSGTexture.mipmapFiltering": (),
-    "PySide2.QtQuick.QSGTexture.normalizedTextureSubRect": (),
-    "PySide2.QtQuick.QSGTexture.removedFromAtlas": (),
-    "PySide2.QtQuick.QSGTexture.setAnisotropyLevel": ('PySide2.QtQuick.QSGTexture.AnisotropyLevel',),
-    "PySide2.QtQuick.QSGTexture.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setHorizontalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.setMipmapFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setVerticalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.textureId": (),
-    "PySide2.QtQuick.QSGTexture.textureSize": (),
-    "PySide2.QtQuick.QSGTexture.updateBindOptions": ('bool',),
-    "PySide2.QtQuick.QSGTexture.verticalWrapMode": (),
-# class PySide2.QtQuick.QSGTextureProvider:
-    "PySide2.QtQuick.QSGTextureProvider.__init__": (),
-    "PySide2.QtQuick.QSGTextureProvider.texture": (),
-# class PySide2.QtQuick.QSGTransformNode:
-    "PySide2.QtQuick.QSGTransformNode.__init__": (),
-    "PySide2.QtQuick.QSGTransformNode.combinedMatrix": (),
-    "PySide2.QtQuick.QSGTransformNode.matrix": (),
-    "PySide2.QtQuick.QSGTransformNode.setCombinedMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGTransformNode.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >:
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.__copy__": (),
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.data": (),
-    }) if "PySide2.QtQuick" in sys.modules else None
-# Module PySide2.QtQuickWidgets
-sig_dict.update({
-# class PySide2.QtQuickWidgets.QQuickWidget:
-# class PySide2.QtQuickWidgets.QQuickWidget.ResizeMode:
-# class PySide2.QtQuickWidgets.QQuickWidget.Status:
-    "PySide2.QtQuickWidgets.QQuickWidget.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtQuickWidgets.QQuickWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.engine": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.errors": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.format": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.grabFramebuffer": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.initialSize": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.quickWindow": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeMode": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootContext": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootObject": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuickWidgets.QQuickWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setResizeMode": ('PySide2.QtQuickWidgets.QQuickWidget.ResizeMode',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuickWidgets.QQuickWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.sizeHint": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.source": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.status": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    }) if "PySide2.QtQuickWidgets" in sys.modules else None
-# Module PySide2.QtRemoteObjects
-sig_dict.update({
-# class PySide2.QtRemoteObjects.QAbstractItemModelReplica:
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.availableRoles": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasData": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.roleNames": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.selectionModel": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-# class PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-# class PySide2.QtRemoteObjects.QRemoteObjectDynamicReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase:
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas:
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.addHostSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.disableRemoting": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.enableRemoting": [('PySide2.QtCore.QAbstractItemModel', 'str', 'typing.List[int]', 'PySide2.QtCore.QItemSelectionModel'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.proxy": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.reverseProxy": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setName": ('str',),
-# class PySide2.QtRemoteObjects.QRemoteObjectNode:
-# class PySide2.QtRemoteObjects.QRemoteObjectNode.ErrorCode:
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireDynamic": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireModel": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.addClientSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.connectToNode": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.heartbeatInterval": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.instances": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.lastError": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.persistedStore": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registry": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registryUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setHeartbeatInterval": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setName": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setPersistedStore": ('PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.waitForRegistry": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall:
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall.Error:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.__init__": [(), ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall',)],
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.error": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.fromCompletedCall": ('typing.Any',),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.returnValue": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.waitForFinished": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.__init__": ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.waitForFinished": [(), ('int',)],
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistry:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.pushToRegistryIfNeeded": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.registerMetatypes": (),
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistryHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.__init__": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica.State:
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.__init__": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initializeNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode', 'str'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isReplicaValid": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.node": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.persistProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.propAsVariant": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.retrieveProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.send": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.sendWithReply": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setChild": ('int', 'typing.Any'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setProperties": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.state": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.waitForSource": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectSettingsStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    }) if "PySide2.QtRemoteObjects" in sys.modules else None
-# Module PySide2.QtScxml
-sig_dict.update({
-# class PySide2.QtScxml.QScxmlCompiler:
-# class PySide2.QtScxml.QScxmlCompiler.Loader:
-    "PySide2.QtScxml.QScxmlCompiler.Loader.__init__": (),
-    "PySide2.QtScxml.QScxmlCompiler.Loader.load": ('str', 'str'),
-    "PySide2.QtScxml.QScxmlCompiler.__init__": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtScxml.QScxmlCompiler.compile": (),
-    "PySide2.QtScxml.QScxmlCompiler.errors": (),
-    "PySide2.QtScxml.QScxmlCompiler.fileName": (),
-    "PySide2.QtScxml.QScxmlCompiler.loader": (),
-    "PySide2.QtScxml.QScxmlCompiler.setFileName": ('str',),
-    "PySide2.QtScxml.QScxmlCompiler.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-# class PySide2.QtScxml.QScxmlCppDataModel:
-    "PySide2.QtScxml.QScxmlCppDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.inState": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlEvent": (),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlCppDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlDataModel:
-# class PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody:
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.__init__": (),
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.run": (),
-    "PySide2.QtScxml.QScxmlDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlDataModel.setStateMachine": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlDataModel.setup": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlDataModel.stateMachine": (),
-# class PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlEcmaScriptDataModel:
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlError:
-    "PySide2.QtScxml.QScxmlError.__init__": [(), ('PySide2.QtScxml.QScxmlError',), ('str', 'int', 'int', 'str')],
-    "PySide2.QtScxml.QScxmlError.__copy__": (),
-    "PySide2.QtScxml.QScxmlError.column": (),
-    "PySide2.QtScxml.QScxmlError.description": (),
-    "PySide2.QtScxml.QScxmlError.fileName": (),
-    "PySide2.QtScxml.QScxmlError.isValid": (),
-    "PySide2.QtScxml.QScxmlError.line": (),
-    "PySide2.QtScxml.QScxmlError.toString": (),
-# class PySide2.QtScxml.QScxmlEvent:
-# class PySide2.QtScxml.QScxmlEvent.EventType:
-    "PySide2.QtScxml.QScxmlEvent.__init__": [(), ('PySide2.QtScxml.QScxmlEvent',)],
-    "PySide2.QtScxml.QScxmlEvent.clear": (),
-    "PySide2.QtScxml.QScxmlEvent.data": (),
-    "PySide2.QtScxml.QScxmlEvent.delay": (),
-    "PySide2.QtScxml.QScxmlEvent.errorMessage": (),
-    "PySide2.QtScxml.QScxmlEvent.eventType": (),
-    "PySide2.QtScxml.QScxmlEvent.invokeId": (),
-    "PySide2.QtScxml.QScxmlEvent.isErrorEvent": (),
-    "PySide2.QtScxml.QScxmlEvent.name": (),
-    "PySide2.QtScxml.QScxmlEvent.origin": (),
-    "PySide2.QtScxml.QScxmlEvent.originType": (),
-    "PySide2.QtScxml.QScxmlEvent.scxmlType": (),
-    "PySide2.QtScxml.QScxmlEvent.sendId": (),
-    "PySide2.QtScxml.QScxmlEvent.setData": ('typing.Any',),
-    "PySide2.QtScxml.QScxmlEvent.setDelay": ('int',),
-    "PySide2.QtScxml.QScxmlEvent.setErrorMessage": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setEventType": ('PySide2.QtScxml.QScxmlEvent.EventType',),
-    "PySide2.QtScxml.QScxmlEvent.setInvokeId": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setName": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOrigin": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOriginType": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setSendId": ('str',),
-# class PySide2.QtScxml.QScxmlExecutableContent:
-# class PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlInvokableService:
-    "PySide2.QtScxml.QScxmlInvokableService.__init__": ('PySide2.QtScxml.QScxmlStateMachine', 'PySide2.QtScxml.QScxmlInvokableServiceFactory'),
-    "PySide2.QtScxml.QScxmlInvokableService.id": (),
-    "PySide2.QtScxml.QScxmlInvokableService.name": (),
-    "PySide2.QtScxml.QScxmlInvokableService.parentStateMachine": (),
-    "PySide2.QtScxml.QScxmlInvokableService.postEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlInvokableService.start": (),
-# class PySide2.QtScxml.QScxmlInvokableServiceFactory:
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invokeInfo": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.names": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.parameters": (),
-# class PySide2.QtScxml.QScxmlNullDataModel:
-    "PySide2.QtScxml.QScxmlNullDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlNullDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlStateMachine:
-    "PySide2.QtScxml.QScxmlStateMachine.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStateMachine.activeStateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.cancelDelayedEvent": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToEvent": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToState": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.dataModel": (),
-    "PySide2.QtScxml.QScxmlStateMachine.fromData": ('PySide2.QtCore.QIODevice', 'str'),
-    "PySide2.QtScxml.QScxmlStateMachine.fromFile": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.init": (),
-    "PySide2.QtScxml.QScxmlStateMachine.initialValues": (),
-    "PySide2.QtScxml.QScxmlStateMachine.invokedServices": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isActive": [('int',), ('str',)],
-    "PySide2.QtScxml.QScxmlStateMachine.isDispatchableTarget": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.isInitialized": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isInvoked": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isRunning": (),
-    "PySide2.QtScxml.QScxmlStateMachine.loader": (),
-    "PySide2.QtScxml.QScxmlStateMachine.name": (),
-    "PySide2.QtScxml.QScxmlStateMachine.parseErrors": (),
-    "PySide2.QtScxml.QScxmlStateMachine.sessionId": (),
-    "PySide2.QtScxml.QScxmlStateMachine.setDataModel": ('PySide2.QtScxml.QScxmlDataModel',),
-    "PySide2.QtScxml.QScxmlStateMachine.setInitialValues": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlStateMachine.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-    "PySide2.QtScxml.QScxmlStateMachine.setRunning": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.setTableData": ('PySide2.QtScxml.QScxmlTableData',),
-    "PySide2.QtScxml.QScxmlStateMachine.start": (),
-    "PySide2.QtScxml.QScxmlStateMachine.stateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.stop": (),
-    "PySide2.QtScxml.QScxmlStateMachine.submitEvent": [('PySide2.QtScxml.QScxmlEvent',), ('str',), ('str', 'typing.Any')],
-    "PySide2.QtScxml.QScxmlStateMachine.tableData": (),
-# class PySide2.QtScxml.QScxmlStaticScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlTableData:
-    "PySide2.QtScxml.QScxmlTableData.__init__": (),
-    "PySide2.QtScxml.QScxmlTableData.assignmentInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.dataNames": (),
-    "PySide2.QtScxml.QScxmlTableData.evaluatorInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.foreachInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.initialSetup": (),
-    "PySide2.QtScxml.QScxmlTableData.instructions": (),
-    "PySide2.QtScxml.QScxmlTableData.name": (),
-    "PySide2.QtScxml.QScxmlTableData.serviceFactory": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.stateMachineTable": (),
-    "PySide2.QtScxml.QScxmlTableData.string": ('int',),
-    }) if "PySide2.QtScxml" in sys.modules else None
-# Module PySide2.QtScript
-sig_dict.update({
-# class PySide2.QtScript.QScriptClass:
-# class PySide2.QtScript.QScriptClass.Extension:
-# class PySide2.QtScript.QScriptClass.QueryFlag:
-    "PySide2.QtScript.QScriptClass.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptClass.engine": (),
-    "PySide2.QtScript.QScriptClass.extension": ('PySide2.QtScript.QScriptClass.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptClass.name": (),
-    "PySide2.QtScript.QScriptClass.newIterator": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClass.property": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.propertyFlags": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.prototype": (),
-    "PySide2.QtScript.QScriptClass.setProperty": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptClass.supportsExtension": ('PySide2.QtScript.QScriptClass.Extension',),
-# class PySide2.QtScript.QScriptClassPropertyIterator:
-    "PySide2.QtScript.QScriptClassPropertyIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClassPropertyIterator.flags": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasNext": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.id": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.name": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.object": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.previous": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toBack": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toFront": (),
-# class PySide2.QtScript.QScriptContext:
-# class PySide2.QtScript.QScriptContext.Error:
-# class PySide2.QtScript.QScriptContext.ExecutionState:
-    "PySide2.QtScript.QScriptContext.activationObject": (),
-    "PySide2.QtScript.QScriptContext.argument": ('int',),
-    "PySide2.QtScript.QScriptContext.argumentCount": (),
-    "PySide2.QtScript.QScriptContext.argumentsObject": (),
-    "PySide2.QtScript.QScriptContext.backtrace": (),
-    "PySide2.QtScript.QScriptContext.callee": (),
-    "PySide2.QtScript.QScriptContext.engine": (),
-    "PySide2.QtScript.QScriptContext.isCalledAsConstructor": (),
-    "PySide2.QtScript.QScriptContext.parentContext": (),
-    "PySide2.QtScript.QScriptContext.popScope": (),
-    "PySide2.QtScript.QScriptContext.pushScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.returnValue": (),
-    "PySide2.QtScript.QScriptContext.scopeChain": (),
-    "PySide2.QtScript.QScriptContext.setActivationObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setReturnValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setThisObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.state": (),
-    "PySide2.QtScript.QScriptContext.thisObject": (),
-    "PySide2.QtScript.QScriptContext.throwError": [('PySide2.QtScript.QScriptContext.Error', 'str'), ('str',)],
-    "PySide2.QtScript.QScriptContext.throwValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.toString": (),
-# class PySide2.QtScript.QScriptContextInfo:
-# class PySide2.QtScript.QScriptContextInfo.FunctionType:
-    "PySide2.QtScript.QScriptContextInfo.__init__": [(), ('PySide2.QtScript.QScriptContext',), ('PySide2.QtScript.QScriptContextInfo',)],
-    "PySide2.QtScript.QScriptContextInfo.__copy__": (),
-    "PySide2.QtScript.QScriptContextInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.columnNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.fileName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionEndLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionMetaIndex": (),
-    "PySide2.QtScript.QScriptContextInfo.functionName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionParameterNames": (),
-    "PySide2.QtScript.QScriptContextInfo.functionStartLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionType": (),
-    "PySide2.QtScript.QScriptContextInfo.isNull": (),
-    "PySide2.QtScript.QScriptContextInfo.lineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.scriptId": (),
-# class PySide2.QtScript.QScriptEngine:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOption:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOptions:
-# class PySide2.QtScript.QScriptEngine.ValueOwnership:
-    "PySide2.QtScript.QScriptEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtScript.QScriptEngine.abortEvaluation": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.agent": (),
-    "PySide2.QtScript.QScriptEngine.availableExtensions": (),
-    "PySide2.QtScript.QScriptEngine.canEvaluate": ('str',),
-    "PySide2.QtScript.QScriptEngine.clearExceptions": (),
-    "PySide2.QtScript.QScriptEngine.collectGarbage": (),
-    "PySide2.QtScript.QScriptEngine.currentContext": (),
-    "PySide2.QtScript.QScriptEngine.defaultPrototype": ('int',),
-    "PySide2.QtScript.QScriptEngine.evaluate": [('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptEngine.globalObject": (),
-    "PySide2.QtScript.QScriptEngine.hasUncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.importExtension": ('str',),
-    "PySide2.QtScript.QScriptEngine.importedExtensions": (),
-    "PySide2.QtScript.QScriptEngine.installTranslatorFunctions": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.isEvaluating": (),
-    "PySide2.QtScript.QScriptEngine.newActivationObject": (),
-    "PySide2.QtScript.QScriptEngine.newArray": ('int',),
-    "PySide2.QtScript.QScriptEngine.newDate": [('PySide2.QtCore.QDateTime',), ('float',)],
-    "PySide2.QtScript.QScriptEngine.newObject": [(), ('PySide2.QtScript.QScriptClass', 'PySide2.QtScript.QScriptValue')],
-    "PySide2.QtScript.QScriptEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.newQObject": [('PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions'), ('PySide2.QtScript.QScriptValue', 'PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions')],
-    "PySide2.QtScript.QScriptEngine.newRegExp": [('PySide2.QtCore.QRegExp',), ('str', 'str')],
-    "PySide2.QtScript.QScriptEngine.newVariant": [('PySide2.QtScript.QScriptValue', 'typing.Any'), ('typing.Any',)],
-    "PySide2.QtScript.QScriptEngine.nullValue": (),
-    "PySide2.QtScript.QScriptEngine.objectById": ('int',),
-    "PySide2.QtScript.QScriptEngine.popContext": (),
-    "PySide2.QtScript.QScriptEngine.processEventsInterval": (),
-    "PySide2.QtScript.QScriptEngine.pushContext": (),
-    "PySide2.QtScript.QScriptEngine.reportAdditionalMemoryCost": ('int',),
-    "PySide2.QtScript.QScriptEngine.setAgent": ('PySide2.QtScript.QScriptEngineAgent',),
-    "PySide2.QtScript.QScriptEngine.setDefaultPrototype": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.setGlobalObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.setProcessEventsInterval": ('int',),
-    "PySide2.QtScript.QScriptEngine.toObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.toStringHandle": ('str',),
-    "PySide2.QtScript.QScriptEngine.uncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionBacktrace": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionLineNumber": (),
-    "PySide2.QtScript.QScriptEngine.undefinedValue": (),
-# class PySide2.QtScript.QScriptEngineAgent:
-# class PySide2.QtScript.QScriptEngineAgent.Extension:
-    "PySide2.QtScript.QScriptEngineAgent.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptEngineAgent.contextPop": (),
-    "PySide2.QtScript.QScriptEngineAgent.contextPush": (),
-    "PySide2.QtScript.QScriptEngineAgent.engine": (),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionCatch": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionThrow": ('int', 'PySide2.QtScript.QScriptValue', 'bool'),
-    "PySide2.QtScript.QScriptEngineAgent.extension": ('PySide2.QtScript.QScriptEngineAgent.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptEngineAgent.functionEntry": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.functionExit": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.positionChange": ('int', 'int', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptLoad": ('int', 'str', 'str', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptUnload": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.supportsExtension": ('PySide2.QtScript.QScriptEngineAgent.Extension',),
-# class PySide2.QtScript.QScriptExtensionInterface:
-    "PySide2.QtScript.QScriptExtensionInterface.__init__": (),
-    "PySide2.QtScript.QScriptExtensionInterface.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptExtensionPlugin:
-    "PySide2.QtScript.QScriptExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScript.QScriptExtensionPlugin.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-    "PySide2.QtScript.QScriptExtensionPlugin.keys": (),
-    "PySide2.QtScript.QScriptExtensionPlugin.setupPackage": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptProgram:
-    "PySide2.QtScript.QScriptProgram.__init__": [(), ('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptProgram.__copy__": (),
-    "PySide2.QtScript.QScriptProgram.fileName": (),
-    "PySide2.QtScript.QScriptProgram.firstLineNumber": (),
-    "PySide2.QtScript.QScriptProgram.isNull": (),
-    "PySide2.QtScript.QScriptProgram.sourceCode": (),
-# class PySide2.QtScript.QScriptString:
-    "PySide2.QtScript.QScriptString.__init__": [(), ('PySide2.QtScript.QScriptString',)],
-    "PySide2.QtScript.QScriptString.__copy__": (),
-    "PySide2.QtScript.QScriptString.isValid": (),
-    "PySide2.QtScript.QScriptString.toArrayIndex": (),
-    "PySide2.QtScript.QScriptString.toString": (),
-# class PySide2.QtScript.QScriptValue:
-# class PySide2.QtScript.QScriptValue.PropertyFlag:
-# class PySide2.QtScript.QScriptValue.PropertyFlags:
-# class PySide2.QtScript.QScriptValue.ResolveFlag:
-# class PySide2.QtScript.QScriptValue.ResolveFlags:
-# class PySide2.QtScript.QScriptValue.SpecialValue:
-    "PySide2.QtScript.QScriptValue.__init__": [(), ('PySide2.QtScript.QScriptEngine', 'PySide2.QtScript.QScriptValue.SpecialValue'), ('PySide2.QtScript.QScriptEngine', 'bool'), ('PySide2.QtScript.QScriptEngine', 'float'), ('PySide2.QtScript.QScriptEngine', 'int'), ('PySide2.QtScript.QScriptEngine', 'str'), ('PySide2.QtScript.QScriptValue',), ('PySide2.QtScript.QScriptValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtScript.QScriptValue.__copy__": (),
-    "PySide2.QtScript.QScriptValue.__iter__": (),
-    "PySide2.QtScript.QScriptValue.__repr__": (),
-    "PySide2.QtScript.QScriptValue.call": [('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue'), ('PySide2.QtScript.QScriptValue', 'typing.Sequence[PySide2.QtScript.QScriptValue]')],
-    "PySide2.QtScript.QScriptValue.construct": [('PySide2.QtScript.QScriptValue',), ('typing.Sequence[PySide2.QtScript.QScriptValue]',)],
-    "PySide2.QtScript.QScriptValue.data": (),
-    "PySide2.QtScript.QScriptValue.engine": (),
-    "PySide2.QtScript.QScriptValue.equals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.instanceOf": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.isArray": (),
-    "PySide2.QtScript.QScriptValue.isBool": (),
-    "PySide2.QtScript.QScriptValue.isBoolean": (),
-    "PySide2.QtScript.QScriptValue.isDate": (),
-    "PySide2.QtScript.QScriptValue.isError": (),
-    "PySide2.QtScript.QScriptValue.isFunction": (),
-    "PySide2.QtScript.QScriptValue.isNull": (),
-    "PySide2.QtScript.QScriptValue.isNumber": (),
-    "PySide2.QtScript.QScriptValue.isObject": (),
-    "PySide2.QtScript.QScriptValue.isQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.isQObject": (),
-    "PySide2.QtScript.QScriptValue.isRegExp": (),
-    "PySide2.QtScript.QScriptValue.isString": (),
-    "PySide2.QtScript.QScriptValue.isUndefined": (),
-    "PySide2.QtScript.QScriptValue.isValid": (),
-    "PySide2.QtScript.QScriptValue.isVariant": (),
-    "PySide2.QtScript.QScriptValue.lessThan": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.objectId": (),
-    "PySide2.QtScript.QScriptValue.property": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('int', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.propertyFlags": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.prototype": (),
-    "PySide2.QtScript.QScriptValue.scope": (),
-    "PySide2.QtScript.QScriptValue.scriptClass": (),
-    "PySide2.QtScript.QScriptValue.setData": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setProperty": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('int', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('str', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags')],
-    "PySide2.QtScript.QScriptValue.setPrototype": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScriptClass": ('PySide2.QtScript.QScriptClass',),
-    "PySide2.QtScript.QScriptValue.strictlyEquals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.toBool": (),
-    "PySide2.QtScript.QScriptValue.toBoolean": (),
-    "PySide2.QtScript.QScriptValue.toDateTime": (),
-    "PySide2.QtScript.QScriptValue.toInt32": (),
-    "PySide2.QtScript.QScriptValue.toInteger": (),
-    "PySide2.QtScript.QScriptValue.toNumber": (),
-    "PySide2.QtScript.QScriptValue.toObject": (),
-    "PySide2.QtScript.QScriptValue.toQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.toQObject": (),
-    "PySide2.QtScript.QScriptValue.toRegExp": (),
-    "PySide2.QtScript.QScriptValue.toString": (),
-    "PySide2.QtScript.QScriptValue.toUInt16": (),
-    "PySide2.QtScript.QScriptValue.toUInt32": (),
-    "PySide2.QtScript.QScriptValue.toVariant": (),
-# class PySide2.QtScript.QScriptValueIterator:
-    "PySide2.QtScript.QScriptValueIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.__iter__": (),
-    "PySide2.QtScript.QScriptValueIterator.flags": (),
-    "PySide2.QtScript.QScriptValueIterator.hasNext": (),
-    "PySide2.QtScript.QScriptValueIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptValueIterator.name": (),
-    "PySide2.QtScript.QScriptValueIterator.previous": (),
-    "PySide2.QtScript.QScriptValueIterator.remove": (),
-    "PySide2.QtScript.QScriptValueIterator.scriptName": (),
-    "PySide2.QtScript.QScriptValueIterator.setValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.toBack": (),
-    "PySide2.QtScript.QScriptValueIterator.toFront": (),
-    "PySide2.QtScript.QScriptValueIterator.value": (),
-# class PySide2.QtScript.QScriptable:
-    "PySide2.QtScript.QScriptable.__init__": (),
-    "PySide2.QtScript.QScriptable.argument": ('int',),
-    "PySide2.QtScript.QScriptable.argumentCount": (),
-    "PySide2.QtScript.QScriptable.context": (),
-    "PySide2.QtScript.QScriptable.engine": (),
-    "PySide2.QtScript.QScriptable.thisObject": (),
-    }) if "PySide2.QtScript" in sys.modules else None
-# Module PySide2.QtScriptTools
-sig_dict.update({
-# class PySide2.QtScriptTools.QScriptEngineDebugger:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerState:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget:
-    "PySide2.QtScriptTools.QScriptEngineDebugger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.action": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.attachTo": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.autoShowStandardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardMenu": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardToolBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.setAutoShowStandardWindow": ('bool',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.standardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.state": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.widget": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget',),
-    }) if "PySide2.QtScriptTools" in sys.modules else None
-# Module PySide2.QtSensors
-sig_dict.update({
-# class PySide2.QtSensors.QAccelerometer:
-# class PySide2.QtSensors.QAccelerometer.AccelerationMode:
-    "PySide2.QtSensors.QAccelerometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometer.accelerationMode": (),
-    "PySide2.QtSensors.QAccelerometer.reading": (),
-    "PySide2.QtSensors.QAccelerometer.setAccelerationMode": ('PySide2.QtSensors.QAccelerometer.AccelerationMode',),
-# class PySide2.QtSensors.QAccelerometerFilter:
-    "PySide2.QtSensors.QAccelerometerFilter.__init__": (),
-    "PySide2.QtSensors.QAccelerometerFilter.filter": [('PySide2.QtSensors.QAccelerometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAccelerometerReading:
-    "PySide2.QtSensors.QAccelerometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAccelerometerReading.setX": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setY": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.x": (),
-    "PySide2.QtSensors.QAccelerometerReading.y": (),
-    "PySide2.QtSensors.QAccelerometerReading.z": (),
-# class PySide2.QtSensors.QAltimeter:
-    "PySide2.QtSensors.QAltimeter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeter.reading": (),
-# class PySide2.QtSensors.QAltimeterFilter:
-    "PySide2.QtSensors.QAltimeterFilter.__init__": (),
-    "PySide2.QtSensors.QAltimeterFilter.filter": [('PySide2.QtSensors.QAltimeterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAltimeterReading:
-    "PySide2.QtSensors.QAltimeterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeterReading.altitude": (),
-    "PySide2.QtSensors.QAltimeterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAltimeterReading.setAltitude": ('float',),
-# class PySide2.QtSensors.QAmbientLightFilter:
-    "PySide2.QtSensors.QAmbientLightFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientLightFilter.filter": [('PySide2.QtSensors.QAmbientLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientLightReading:
-# class PySide2.QtSensors.QAmbientLightReading.LightLevel:
-    "PySide2.QtSensors.QAmbientLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientLightReading.lightLevel": (),
-    "PySide2.QtSensors.QAmbientLightReading.setLightLevel": ('PySide2.QtSensors.QAmbientLightReading.LightLevel',),
-# class PySide2.QtSensors.QAmbientLightSensor:
-    "PySide2.QtSensors.QAmbientLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightSensor.reading": (),
-# class PySide2.QtSensors.QAmbientTemperatureFilter:
-    "PySide2.QtSensors.QAmbientTemperatureFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientTemperatureFilter.filter": [('PySide2.QtSensors.QAmbientTemperatureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientTemperatureReading:
-    "PySide2.QtSensors.QAmbientTemperatureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.temperature": (),
-# class PySide2.QtSensors.QAmbientTemperatureSensor:
-    "PySide2.QtSensors.QAmbientTemperatureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureSensor.reading": (),
-# class PySide2.QtSensors.QCompass:
-    "PySide2.QtSensors.QCompass.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompass.reading": (),
-# class PySide2.QtSensors.QCompassFilter:
-    "PySide2.QtSensors.QCompassFilter.__init__": (),
-    "PySide2.QtSensors.QCompassFilter.filter": [('PySide2.QtSensors.QCompassReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QCompassReading:
-    "PySide2.QtSensors.QCompassReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompassReading.azimuth": (),
-    "PySide2.QtSensors.QCompassReading.calibrationLevel": (),
-    "PySide2.QtSensors.QCompassReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QCompassReading.setAzimuth": ('float',),
-    "PySide2.QtSensors.QCompassReading.setCalibrationLevel": ('float',),
-# class PySide2.QtSensors.QDistanceFilter:
-    "PySide2.QtSensors.QDistanceFilter.__init__": (),
-    "PySide2.QtSensors.QDistanceFilter.filter": [('PySide2.QtSensors.QDistanceReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QDistanceReading:
-    "PySide2.QtSensors.QDistanceReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QDistanceReading.distance": (),
-    "PySide2.QtSensors.QDistanceReading.setDistance": ('float',),
-# class PySide2.QtSensors.QDistanceSensor:
-    "PySide2.QtSensors.QDistanceSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceSensor.reading": (),
-# class PySide2.QtSensors.QGyroscope:
-    "PySide2.QtSensors.QGyroscope.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscope.reading": (),
-# class PySide2.QtSensors.QGyroscopeFilter:
-    "PySide2.QtSensors.QGyroscopeFilter.__init__": (),
-    "PySide2.QtSensors.QGyroscopeFilter.filter": [('PySide2.QtSensors.QGyroscopeReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QGyroscopeReading:
-    "PySide2.QtSensors.QGyroscopeReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscopeReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QGyroscopeReading.setX": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setY": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setZ": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.x": (),
-    "PySide2.QtSensors.QGyroscopeReading.y": (),
-    "PySide2.QtSensors.QGyroscopeReading.z": (),
-# class PySide2.QtSensors.QHolsterFilter:
-    "PySide2.QtSensors.QHolsterFilter.__init__": (),
-    "PySide2.QtSensors.QHolsterFilter.filter": [('PySide2.QtSensors.QHolsterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHolsterReading:
-    "PySide2.QtSensors.QHolsterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHolsterReading.holstered": (),
-    "PySide2.QtSensors.QHolsterReading.setHolstered": ('bool',),
-# class PySide2.QtSensors.QHolsterSensor:
-    "PySide2.QtSensors.QHolsterSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterSensor.reading": (),
-# class PySide2.QtSensors.QHumidityFilter:
-    "PySide2.QtSensors.QHumidityFilter.__init__": (),
-    "PySide2.QtSensors.QHumidityFilter.filter": [('PySide2.QtSensors.QHumidityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHumidityReading:
-    "PySide2.QtSensors.QHumidityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumidityReading.absoluteHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHumidityReading.relativeHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.setAbsoluteHumidity": ('float',),
-    "PySide2.QtSensors.QHumidityReading.setRelativeHumidity": ('float',),
-# class PySide2.QtSensors.QHumiditySensor:
-    "PySide2.QtSensors.QHumiditySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumiditySensor.reading": (),
-# class PySide2.QtSensors.QIRProximityFilter:
-    "PySide2.QtSensors.QIRProximityFilter.__init__": (),
-    "PySide2.QtSensors.QIRProximityFilter.filter": [('PySide2.QtSensors.QIRProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QIRProximityReading:
-    "PySide2.QtSensors.QIRProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QIRProximityReading.reflectance": (),
-    "PySide2.QtSensors.QIRProximityReading.setReflectance": ('float',),
-# class PySide2.QtSensors.QIRProximitySensor:
-    "PySide2.QtSensors.QIRProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximitySensor.reading": (),
-# class PySide2.QtSensors.QLidFilter:
-    "PySide2.QtSensors.QLidFilter.__init__": (),
-    "PySide2.QtSensors.QLidFilter.filter": [('PySide2.QtSensors.QLidReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLidReading:
-    "PySide2.QtSensors.QLidReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidReading.backLidClosed": (),
-    "PySide2.QtSensors.QLidReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLidReading.frontLidClosed": (),
-    "PySide2.QtSensors.QLidReading.setBackLidClosed": ('bool',),
-    "PySide2.QtSensors.QLidReading.setFrontLidClosed": ('bool',),
-# class PySide2.QtSensors.QLidSensor:
-    "PySide2.QtSensors.QLidSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidSensor.reading": (),
-# class PySide2.QtSensors.QLightFilter:
-    "PySide2.QtSensors.QLightFilter.__init__": (),
-    "PySide2.QtSensors.QLightFilter.filter": [('PySide2.QtSensors.QLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLightReading:
-    "PySide2.QtSensors.QLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLightReading.lux": (),
-    "PySide2.QtSensors.QLightReading.setLux": ('float',),
-# class PySide2.QtSensors.QLightSensor:
-    "PySide2.QtSensors.QLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightSensor.fieldOfView": (),
-    "PySide2.QtSensors.QLightSensor.reading": (),
-    "PySide2.QtSensors.QLightSensor.setFieldOfView": ('float',),
-# class PySide2.QtSensors.QMagnetometer:
-    "PySide2.QtSensors.QMagnetometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometer.reading": (),
-    "PySide2.QtSensors.QMagnetometer.returnGeoValues": (),
-    "PySide2.QtSensors.QMagnetometer.setReturnGeoValues": ('bool',),
-# class PySide2.QtSensors.QMagnetometerFilter:
-    "PySide2.QtSensors.QMagnetometerFilter.__init__": (),
-    "PySide2.QtSensors.QMagnetometerFilter.filter": [('PySide2.QtSensors.QMagnetometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QMagnetometerReading:
-    "PySide2.QtSensors.QMagnetometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometerReading.calibrationLevel": (),
-    "PySide2.QtSensors.QMagnetometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QMagnetometerReading.setCalibrationLevel": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setX": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setY": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.x": (),
-    "PySide2.QtSensors.QMagnetometerReading.y": (),
-    "PySide2.QtSensors.QMagnetometerReading.z": (),
-# class PySide2.QtSensors.QOrientationFilter:
-    "PySide2.QtSensors.QOrientationFilter.__init__": (),
-    "PySide2.QtSensors.QOrientationFilter.filter": [('PySide2.QtSensors.QOrientationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QOrientationReading:
-# class PySide2.QtSensors.QOrientationReading.Orientation:
-    "PySide2.QtSensors.QOrientationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QOrientationReading.orientation": (),
-    "PySide2.QtSensors.QOrientationReading.setOrientation": ('PySide2.QtSensors.QOrientationReading.Orientation',),
-# class PySide2.QtSensors.QOrientationSensor:
-    "PySide2.QtSensors.QOrientationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationSensor.reading": (),
-# class PySide2.QtSensors.QPressureFilter:
-    "PySide2.QtSensors.QPressureFilter.__init__": (),
-    "PySide2.QtSensors.QPressureFilter.filter": [('PySide2.QtSensors.QPressureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QPressureReading:
-    "PySide2.QtSensors.QPressureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QPressureReading.pressure": (),
-    "PySide2.QtSensors.QPressureReading.setPressure": ('float',),
-    "PySide2.QtSensors.QPressureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QPressureReading.temperature": (),
-# class PySide2.QtSensors.QPressureSensor:
-    "PySide2.QtSensors.QPressureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureSensor.reading": (),
-# class PySide2.QtSensors.QProximityFilter:
-    "PySide2.QtSensors.QProximityFilter.__init__": (),
-    "PySide2.QtSensors.QProximityFilter.filter": [('PySide2.QtSensors.QProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QProximityReading:
-    "PySide2.QtSensors.QProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximityReading.close": (),
-    "PySide2.QtSensors.QProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QProximityReading.setClose": ('bool',),
-# class PySide2.QtSensors.QProximitySensor:
-    "PySide2.QtSensors.QProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximitySensor.reading": (),
-# class PySide2.QtSensors.QRotationFilter:
-    "PySide2.QtSensors.QRotationFilter.__init__": (),
-    "PySide2.QtSensors.QRotationFilter.filter": [('PySide2.QtSensors.QRotationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QRotationReading:
-    "PySide2.QtSensors.QRotationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QRotationReading.setFromEuler": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QRotationReading.x": (),
-    "PySide2.QtSensors.QRotationReading.y": (),
-    "PySide2.QtSensors.QRotationReading.z": (),
-# class PySide2.QtSensors.QRotationSensor:
-    "PySide2.QtSensors.QRotationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationSensor.hasZ": (),
-    "PySide2.QtSensors.QRotationSensor.reading": (),
-    "PySide2.QtSensors.QRotationSensor.setHasZ": ('bool',),
-# class PySide2.QtSensors.QSensor:
-# class PySide2.QtSensors.QSensor.AxesOrientationMode:
-# class PySide2.QtSensors.QSensor.Feature:
-    "PySide2.QtSensors.QSensor.__init__": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensor.addFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.availableDataRates": (),
-    "PySide2.QtSensors.QSensor.axesOrientationMode": (),
-    "PySide2.QtSensors.QSensor.backend": (),
-    "PySide2.QtSensors.QSensor.bufferSize": (),
-    "PySide2.QtSensors.QSensor.connectToBackend": (),
-    "PySide2.QtSensors.QSensor.currentOrientation": (),
-    "PySide2.QtSensors.QSensor.dataRate": (),
-    "PySide2.QtSensors.QSensor.defaultSensorForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.description": (),
-    "PySide2.QtSensors.QSensor.efficientBufferSize": (),
-    "PySide2.QtSensors.QSensor.error": (),
-    "PySide2.QtSensors.QSensor.filters": (),
-    "PySide2.QtSensors.QSensor.identifier": (),
-    "PySide2.QtSensors.QSensor.isActive": (),
-    "PySide2.QtSensors.QSensor.isAlwaysOn": (),
-    "PySide2.QtSensors.QSensor.isBusy": (),
-    "PySide2.QtSensors.QSensor.isConnectedToBackend": (),
-    "PySide2.QtSensors.QSensor.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensor.maxBufferSize": (),
-    "PySide2.QtSensors.QSensor.outputRange": (),
-    "PySide2.QtSensors.QSensor.outputRanges": (),
-    "PySide2.QtSensors.QSensor.reading": (),
-    "PySide2.QtSensors.QSensor.removeFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.sensorTypes": (),
-    "PySide2.QtSensors.QSensor.sensorsForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setActive": ('bool',),
-    "PySide2.QtSensors.QSensor.setAlwaysOn": ('bool',),
-    "PySide2.QtSensors.QSensor.setAxesOrientationMode": ('PySide2.QtSensors.QSensor.AxesOrientationMode',),
-    "PySide2.QtSensors.QSensor.setBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setCurrentOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.setDataRate": ('int',),
-    "PySide2.QtSensors.QSensor.setEfficientBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setIdentifier": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setMaxBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setOutputRange": ('int',),
-    "PySide2.QtSensors.QSensor.setSkipDuplicates": ('bool',),
-    "PySide2.QtSensors.QSensor.setUserOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.skipDuplicates": (),
-    "PySide2.QtSensors.QSensor.start": (),
-    "PySide2.QtSensors.QSensor.stop": (),
-    "PySide2.QtSensors.QSensor.type": (),
-    "PySide2.QtSensors.QSensor.userOrientation": (),
-# class PySide2.QtSensors.QSensorBackend:
-    "PySide2.QtSensors.QSensorBackend.__init__": ('PySide2.QtSensors.QSensor', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensorBackend.addDataRate": ('float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.addOutputRange": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensorBackend.newReadingAvailable": (),
-    "PySide2.QtSensors.QSensorBackend.reading": (),
-    "PySide2.QtSensors.QSensorBackend.sensor": (),
-    "PySide2.QtSensors.QSensorBackend.sensorBusy": (),
-    "PySide2.QtSensors.QSensorBackend.sensorError": ('int',),
-    "PySide2.QtSensors.QSensorBackend.sensorStopped": (),
-    "PySide2.QtSensors.QSensorBackend.setDataRates": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorBackend.setDescription": ('str',),
-    "PySide2.QtSensors.QSensorBackend.start": (),
-    "PySide2.QtSensors.QSensorBackend.stop": (),
-# class PySide2.QtSensors.QSensorBackendFactory:
-    "PySide2.QtSensors.QSensorBackendFactory.__init__": (),
-    "PySide2.QtSensors.QSensorBackendFactory.createBackend": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorChangesInterface:
-    "PySide2.QtSensors.QSensorChangesInterface.__init__": (),
-    "PySide2.QtSensors.QSensorChangesInterface.sensorsChanged": (),
-# class PySide2.QtSensors.QSensorFilter:
-    "PySide2.QtSensors.QSensorFilter.__init__": (),
-    "PySide2.QtSensors.QSensorFilter.filter": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorFilter.setSensor": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorGestureManager:
-    "PySide2.QtSensors.QSensorGestureManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureManager.gestureIds": (),
-    "PySide2.QtSensors.QSensorGestureManager.recognizerSignals": ('str',),
-    "PySide2.QtSensors.QSensorGestureManager.registerSensorGestureRecognizer": ('PySide2.QtSensors.QSensorGestureRecognizer',),
-    "PySide2.QtSensors.QSensorGestureManager.sensorGestureRecognizer": ('str',),
-# class PySide2.QtSensors.QSensorGesturePluginInterface:
-    "PySide2.QtSensors.QSensorGesturePluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.createRecognizers": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.name": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.supportedIds": (),
-# class PySide2.QtSensors.QSensorGestureRecognizer:
-    "PySide2.QtSensors.QSensorGestureRecognizer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureRecognizer.create": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.createBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.gestureSignals": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.id": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.isActive": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.start": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.startBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stop": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stopBackend": (),
-# class PySide2.QtSensors.QSensorManager:
-    "PySide2.QtSensors.QSensorManager.__init__": (),
-    "PySide2.QtSensors.QSensorManager.createBackend": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorManager.isBackendRegistered": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.registerBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtSensors.QSensorBackendFactory'),
-    "PySide2.QtSensors.QSensorManager.setDefaultBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.unregisterBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtSensors.QSensorPluginInterface:
-    "PySide2.QtSensors.QSensorPluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorPluginInterface.registerSensors": (),
-# class PySide2.QtSensors.QSensorReading:
-    "PySide2.QtSensors.QSensorReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorReading.setTimestamp": ('int',),
-    "PySide2.QtSensors.QSensorReading.timestamp": (),
-    "PySide2.QtSensors.QSensorReading.value": ('int',),
-    "PySide2.QtSensors.QSensorReading.valueCount": (),
-# class PySide2.QtSensors.QTapFilter:
-    "PySide2.QtSensors.QTapFilter.__init__": (),
-    "PySide2.QtSensors.QTapFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTapReading',)],
-# class PySide2.QtSensors.QTapReading:
-# class PySide2.QtSensors.QTapReading.TapDirection:
-    "PySide2.QtSensors.QTapReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTapReading.isDoubleTap": (),
-    "PySide2.QtSensors.QTapReading.setDoubleTap": ('bool',),
-    "PySide2.QtSensors.QTapReading.setTapDirection": ('PySide2.QtSensors.QTapReading.TapDirection',),
-    "PySide2.QtSensors.QTapReading.tapDirection": (),
-# class PySide2.QtSensors.QTapSensor:
-    "PySide2.QtSensors.QTapSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapSensor.reading": (),
-    "PySide2.QtSensors.QTapSensor.returnDoubleTapEvents": (),
-    "PySide2.QtSensors.QTapSensor.setReturnDoubleTapEvents": ('bool',),
-# class PySide2.QtSensors.QTiltFilter:
-    "PySide2.QtSensors.QTiltFilter.__init__": (),
-    "PySide2.QtSensors.QTiltFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTiltReading',)],
-# class PySide2.QtSensors.QTiltReading:
-    "PySide2.QtSensors.QTiltReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTiltReading.setXRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.setYRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.xRotation": (),
-    "PySide2.QtSensors.QTiltReading.yRotation": (),
-# class PySide2.QtSensors.QTiltSensor:
-    "PySide2.QtSensors.QTiltSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltSensor.calibrate": (),
-    "PySide2.QtSensors.QTiltSensor.reading": (),
-# class PySide2.QtSensors.qoutputrange:
-    "PySide2.QtSensors.qoutputrange.__init__": [(), ('PySide2.QtSensors.qoutputrange',)],
-    "PySide2.QtSensors.qoutputrange.__copy__": (),
-    }) if "PySide2.QtSensors" in sys.modules else None
-# Module PySide2.QtTextToSpeech
-sig_dict.update({
-# class PySide2.QtTextToSpeech.QTextToSpeech:
-# class PySide2.QtTextToSpeech.QTextToSpeech.State:
-    "PySide2.QtTextToSpeech.QTextToSpeech.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableEngines": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.volume": (),
-# class PySide2.QtTextToSpeech.QTextToSpeechEngine:
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.createVoice": ('str', 'PySide2.QtTextToSpeech.QVoice.Gender', 'PySide2.QtTextToSpeech.QVoice.Age', 'typing.Any'),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voiceData": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.volume": (),
-# class PySide2.QtTextToSpeech.QVoice:
-# class PySide2.QtTextToSpeech.QVoice.Age:
-# class PySide2.QtTextToSpeech.QVoice.Gender:
-    "PySide2.QtTextToSpeech.QVoice.__init__": [(), ('PySide2.QtTextToSpeech.QVoice',)],
-    "PySide2.QtTextToSpeech.QVoice.__copy__": (),
-    "PySide2.QtTextToSpeech.QVoice.age": (),
-    "PySide2.QtTextToSpeech.QVoice.ageName": ('PySide2.QtTextToSpeech.QVoice.Age',),
-    "PySide2.QtTextToSpeech.QVoice.gender": (),
-    "PySide2.QtTextToSpeech.QVoice.genderName": ('PySide2.QtTextToSpeech.QVoice.Gender',),
-    "PySide2.QtTextToSpeech.QVoice.name": (),
-    }) if "PySide2.QtTextToSpeech" in sys.modules else None
-# Module PySide2.QtCharts
-sig_dict.update({
-# class PySide2.QtCharts.QtCharts:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis.AxisType:
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.alignment": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isMinorGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isReverse": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isTitleVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsEditable": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePenColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.orientation": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsAngle": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsEditable": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePenColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMax": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMin": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setRange": ('typing.Any', 'typing.Any'),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setReverse": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleText": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBorderColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesPen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleText": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition:
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.append": [('PySide2.QtCharts.QtCharts.QBarSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBarSet]',)],
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barSets": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barWidth": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBarSet'),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.isLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPrecision": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.remove": ('PySide2.QtCharts.QtCharts.QBarSet',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setBarWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPrecision": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.take": ('PySide2.QtCharts.QtCharts.QBarSet',),
-# class PySide2.QtCharts.QtCharts.QAbstractSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractSeries.SeriesType:
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachedAxes": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.chart": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.detachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.name": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.opacity": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setName": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setOpacity": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setUseOpenGL": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.useOpenGL": (),
-# class PySide2.QtCharts.QtCharts.QAreaLegendMarker:
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAreaSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QAreaSeries:
-    "PySide2.QtCharts.QtCharts.QAreaSeries.__init__": [('PySide2.QtCharts.QtCharts.QLineSeries', 'PySide2.QtCharts.QtCharts.QLineSeries'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCharts.QtCharts.QAreaSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.lowerSeries": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setLowerSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setUpperSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.upperSeries": (),
-# class PySide2.QtCharts.QtCharts.QBarCategoryAxis:
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.append": [('str',), ('typing.Sequence[str]',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.categories": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.clear": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.insert": ('int', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.replace": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setCategories": ('typing.Sequence[str]',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMax": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMin": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setRange": [('str', 'str'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QBarLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries', 'PySide2.QtCharts.QtCharts.QBarSet', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.barset": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.firstBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.lastBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirstBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setLastBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QBarSeries:
-    "PySide2.QtCharts.QtCharts.QBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBarSet:
-    "PySide2.QtCharts.QtCharts.QBarSet.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBarSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBarSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarSet.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.color": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.insert": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.remove": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QBarSet.replace": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBarSet.sum": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.firstBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.lastBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirstBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setLastBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QBoxPlotSeries:
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.append": [('PySide2.QtCharts.QtCharts.QBoxSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBoxSet]',)],
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxSets": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxWidth": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBoxSet'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.remove": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.take": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxSet:
-# class PySide2.QtCharts.QtCharts.QBoxSet.ValuePositions:
-    "PySide2.QtCharts.QtCharts.QBoxSet.__init__": [('float', 'float', 'float', 'float', 'float', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QBoxSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBoxSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setValue": ('int', 'float'),
-# class PySide2.QtCharts.QtCharts.QCandlestickLegendMarker:
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QCandlestickSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.firstSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.lastSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setClose": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setFirstSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setHigh": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLastSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLow": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setOpen": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QCandlestickSeries',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setTimestamp": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSeries:
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.append": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.decreasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.increasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QCandlestickSet'),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.maximumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.minimumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.remove": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setDecreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setIncreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMaximumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMinimumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.sets": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.take": ('PySide2.QtCharts.QtCharts.QCandlestickSet',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSet:
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.__init__": [('float', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setClose": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setHigh": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setLow": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setOpen": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setTimestamp": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCategoryAxis:
-# class PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition:
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.append": ('str', 'float'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.categoriesLabels": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.endValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.replaceLabel": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setStartValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.startValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QChart:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOption:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOptions:
-# class PySide2.QtCharts.QtCharts.QChart.ChartTheme:
-# class PySide2.QtCharts.QtCharts.QChart.ChartType:
-    "PySide2.QtCharts.QtCharts.QChart.__init__": [('PySide2.QtCharts.QtCharts.QChart.ChartType', 'PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtCharts.QtCharts.QChart.addAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtCharts.QtCharts.QChart.addSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.animationDuration": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationEasingCurve": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationOptions": (),
-    "PySide2.QtCharts.QtCharts.QChart.axes": ('PySide2.QtCore.Qt.Orientations', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.axisX": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.axisY": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundRoundness": (),
-    "PySide2.QtCharts.QtCharts.QChart.chartType": (),
-    "PySide2.QtCharts.QtCharts.QChart.createDefaultAxes": (),
-    "PySide2.QtCharts.QtCharts.QChart.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isDropShadowEnabled": (),
-    "PySide2.QtCharts.QtCharts.QChart.isPlotAreaBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isZoomed": (),
-    "PySide2.QtCharts.QtCharts.QChart.legend": (),
-    "PySide2.QtCharts.QtCharts.QChart.locale": (),
-    "PySide2.QtCharts.QtCharts.QChart.localizeNumbers": (),
-    "PySide2.QtCharts.QtCharts.QChart.mapToPosition": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.mapToValue": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.margins": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotArea": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAllSeries": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QChart.removeSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.scroll": ('float', 'float'),
-    "PySide2.QtCharts.QtCharts.QChart.series": (),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationDuration": ('int',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationOptions": ('PySide2.QtCharts.QtCharts.QChart.AnimationOptions',),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisX": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisY": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundRoundness": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setDropShadowEnabled": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocalizeNumbers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setMargins": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotArea": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setTheme": ('PySide2.QtCharts.QtCharts.QChart.ChartTheme',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitle": ('str',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QChart.theme": (),
-    "PySide2.QtCharts.QtCharts.QChart.title": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoom": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.zoomIn": [(), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtCharts.QtCharts.QChart.zoomOut": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoomReset": (),
-# class PySide2.QtCharts.QtCharts.QChartView:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBand:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBands:
-    "PySide2.QtCharts.QtCharts.QChartView.__init__": [('PySide2.QtCharts.QtCharts.QChart', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtCharts.QtCharts.QChartView.chart": (),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.rubberBand": (),
-    "PySide2.QtCharts.QtCharts.QChartView.setChart": ('PySide2.QtCharts.QtCharts.QChart',),
-    "PySide2.QtCharts.QtCharts.QChartView.setRubberBand": ('PySide2.QtCharts.QtCharts.QChartView.RubberBands',),
-# class PySide2.QtCharts.QtCharts.QDateTimeAxis:
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.format": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMax": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMin": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setRange": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QHBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.lastBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setLastBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.lastBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setLastBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QHCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.closeColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.firstSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.highColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lastSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lowColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.openColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setCloseColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setFirstSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setHighColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLastSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLowColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setOpenColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setTimestampColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.timestampColumn": (),
-# class PySide2.QtCharts.QtCharts.QHPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.labelsRow": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setLabelsRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setValuesRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.valuesRow": (),
-# class PySide2.QtCharts.QtCharts.QHXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setXRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setYRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.xRow": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.yRow": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLegend:
-# class PySide2.QtCharts.QtCharts.QLegend.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QLegend.alignment": (),
-    "PySide2.QtCharts.QtCharts.QLegend.attachToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.color": (),
-    "PySide2.QtCharts.QtCharts.QLegend.detachFromChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.font": (),
-    "PySide2.QtCharts.QtCharts.QLegend.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.isAttachedToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markers": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QLegend.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtCharts.QtCharts.QLegend.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegend.reverseMarkers": (),
-    "PySide2.QtCharts.QtCharts.QLegend.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setMarkerShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegend.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegend.setReverseMarkers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setShowToolTips": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.showToolTips": (),
-# class PySide2.QtCharts.QtCharts.QLegendMarker:
-# class PySide2.QtCharts.QtCharts.QLegendMarker.LegendMarkerType:
-    "PySide2.QtCharts.QtCharts.QLegendMarker.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.font": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.label": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.shape": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QLineSeries:
-    "PySide2.QtCharts.QtCharts.QLineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLogValueAxis:
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.base": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setBase": ('float',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QPieLegendMarker:
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QPieSeries', 'PySide2.QtCharts.QtCharts.QPieSlice', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.slice": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.labelsSection": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setLabelsSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setValuesSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.valuesSection": (),
-# class PySide2.QtCharts.QtCharts.QPieSeries:
-    "PySide2.QtCharts.QtCharts.QPieSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.__lshift__": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.append": [('PySide2.QtCharts.QtCharts.QPieSlice',), ('str', 'float'), ('typing.Sequence[PySide2.QtCharts.QtCharts.QPieSlice]',)],
-    "PySide2.QtCharts.QtCharts.QPieSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.holeSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.horizontalPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QPieSlice'),
-    "PySide2.QtCharts.QtCharts.QPieSeries.isEmpty": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieEndAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieStartAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.remove": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHoleSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHorizontalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieEndAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieStartAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setVerticalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.slices": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.sum": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.take": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.verticalPosition": (),
-# class PySide2.QtCharts.QtCharts.QPieSlice:
-# class PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition:
-    "PySide2.QtCharts.QtCharts.QPieSlice.__init__": [('PySide2.QtCore.QObject',), ('str', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QPieSlice.angleSpan": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderWidth": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.brush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.color": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.explodeDistanceFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isExploded": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isLabelVisible": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.label": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelArmLengthFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.pen": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.percentage": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.series": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderWidth": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExplodeDistanceFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExploded": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelArmLengthFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.startAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.value": (),
-# class PySide2.QtCharts.QtCharts.QPolarChart:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientations:
-    "PySide2.QtCharts.QtCharts.QPolarChart.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtCharts.QtCharts.QPolarChart.addAxis": [('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation'), ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtCharts.QtCharts.QPolarChart.axisPolarOrientation": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-# class PySide2.QtCharts.QtCharts.QScatterSeries:
-# class PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QScatterSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerSize": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerShape": ('PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QSplineSeries:
-    "PySide2.QtCharts.QtCharts.QSplineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QSplineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QVBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.lastBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setLastBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.lastBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setLastBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QVCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.closeRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.firstSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.highRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lastSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lowRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.openRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setCloseRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setFirstSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setHighRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLastSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLowRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setOpenRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setTimestampRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.timestampRow": (),
-# class PySide2.QtCharts.QtCharts.QVPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.labelsColumn": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setLabelsColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setValuesColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.valuesColumn": (),
-# class PySide2.QtCharts.QtCharts.QVXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setXColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setYColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.xColumn": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.yColumn": (),
-# class PySide2.QtCharts.QtCharts.QValueAxis:
-    "PySide2.QtCharts.QtCharts.QValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.applyNiceNumbers": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickAnchor": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickInterval": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickAnchor": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickInterval": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QXYLegendMarker:
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QXYSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setXSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setYSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.xSection": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.ySection": (),
-# class PySide2.QtCharts.QtCharts.QXYSeries:
-    "PySide2.QtCharts.QtCharts.QXYSeries.__lshift__": [('PySide2.QtCore.QPointF',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.append": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.insert": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.points": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVector": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.remove": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('int',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.removePoints": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.replace": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'float', 'float'), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointsVisible": ('bool',),
-    }) if "PySide2.QtCharts" in sys.modules else None
-# Module PySide2.QtSvg
-sig_dict.update({
-# class PySide2.QtSvg.QGraphicsSvgItem:
-    "PySide2.QtSvg.QGraphicsSvgItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtSvg.QGraphicsSvgItem.boundingRect": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.elementId": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.isCachingEnabled": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.maximumCacheSize": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtSvg.QGraphicsSvgItem.renderer": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.setCachingEnabled": ('bool',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setElementId": ('str',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setMaximumCacheSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setSharedRenderer": ('PySide2.QtSvg.QSvgRenderer',),
-    "PySide2.QtSvg.QGraphicsSvgItem.type": (),
-# class PySide2.QtSvg.QSvgGenerator:
-    "PySide2.QtSvg.QSvgGenerator.__init__": (),
-    "PySide2.QtSvg.QSvgGenerator.description": (),
-    "PySide2.QtSvg.QSvgGenerator.fileName": (),
-    "PySide2.QtSvg.QSvgGenerator.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtSvg.QSvgGenerator.outputDevice": (),
-    "PySide2.QtSvg.QSvgGenerator.paintEngine": (),
-    "PySide2.QtSvg.QSvgGenerator.resolution": (),
-    "PySide2.QtSvg.QSvgGenerator.setDescription": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setFileName": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setOutputDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtSvg.QSvgGenerator.setResolution": ('int',),
-    "PySide2.QtSvg.QSvgGenerator.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QSvgGenerator.setTitle": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgGenerator.size": (),
-    "PySide2.QtSvg.QSvgGenerator.title": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBox": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBoxF": (),
-# class PySide2.QtSvg.QSvgRenderer:
-    "PySide2.QtSvg.QSvgRenderer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QXmlStreamReader', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtSvg.QSvgRenderer.animated": (),
-    "PySide2.QtSvg.QSvgRenderer.animationDuration": (),
-    "PySide2.QtSvg.QSvgRenderer.boundsOnElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.currentFrame": (),
-    "PySide2.QtSvg.QSvgRenderer.defaultSize": (),
-    "PySide2.QtSvg.QSvgRenderer.elementExists": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.framesPerSecond": (),
-    "PySide2.QtSvg.QSvgRenderer.isValid": (),
-    "PySide2.QtSvg.QSvgRenderer.load": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QXmlStreamReader',), ('str',)],
-    "PySide2.QtSvg.QSvgRenderer.matrixForElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.render": [('PySide2.QtGui.QPainter',), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'), ('PySide2.QtGui.QPainter', 'str', 'PySide2.QtCore.QRectF')],
-    "PySide2.QtSvg.QSvgRenderer.setCurrentFrame": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setFramesPerSecond": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgRenderer.viewBox": (),
-    "PySide2.QtSvg.QSvgRenderer.viewBoxF": (),
-# class PySide2.QtSvg.QSvgWidget:
-    "PySide2.QtSvg.QSvgWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtSvg.QSvgWidget.load": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtSvg.QSvgWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtSvg.QSvgWidget.renderer": (),
-    "PySide2.QtSvg.QSvgWidget.sizeHint": (),
-    }) if "PySide2.QtSvg" in sys.modules else None
-# Module PySide2.QtDataVisualization
-sig_dict.update({
-# class PySide2.QtDataVisualization.QtDataVisualization:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DBars:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barSpacing": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barThickness": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.columnAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.floorLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.insertSeries": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isBarSpacingRelative": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isMultiSeriesUniform": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.primarySeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.rowAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacing": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacingRelative": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarThickness": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setColumnAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setFloorLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setMultiSeriesUniform": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setPrimarySeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setRowAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setValueAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.valueAxis": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.cameraPreset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.maxZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.minZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPosition": ('float', 'float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPreset": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMaxZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMinZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setTarget": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapXRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapYRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setXRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setYRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.target": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapXRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapYRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.xRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.yRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.zoomLevel": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isRotationEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isSelectionEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomAtTargetEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setRotationEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setSelectionEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomAtTargetEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DLight:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.isAutoPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.setAutoPosition": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DObject:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.isDirty": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.parentScene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setPosition": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScene:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeLight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.devicePixelRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.graphPositionQuery": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.invalidSelectionPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInPrimarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInSecondarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSecondarySubviewOnTop": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSlicingActive": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.primarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.secondarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.selectionQueryPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveCamera": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveLight": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DLight',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setDevicePixelRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setGraphPositionQuery": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setPrimarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubviewOnTop": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSelectionQueryPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSlicingActive": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.viewport": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.flipHorizontalGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setFlipHorizontalGrid": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ambientLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseColors": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseGradients": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.gridLineColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.highlightLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isGridEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelBackgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelTextColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setAmbientLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseColors": ('typing.Sequence[PySide2.QtGui.QColor]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseGradients": ('typing.Sequence[PySide2.QtGui.QLinearGradient]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setHighlightLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setType": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setWindowColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.windowColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisOrientation:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isAutoAdjustRange": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleFixed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labelAutoRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.max": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.min": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.orientation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setAutoAdjustRange": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabelAutoRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMax": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setRange": ('float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitle": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleFixed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.title": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ElementType:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHint:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeInputHandler": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeTheme": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.aspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.clearSelection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.currentFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.customItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.hasContext": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.horizontalAspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.inputHandlers": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isOrthoProjection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isPolar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isReflection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.margin": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.measureFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.optimizationHints": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.queriedGraphPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.radialLabelOffset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.reflectivity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItemAt": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.renderToImage": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItemIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedElement": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedLabelIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectionMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setHorizontalAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMargin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMeasureFps": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOptimizationHints": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOrthoProjection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setPolar": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setRadialLabelOffset": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflectivity": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setSelectionMode": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setShadowQuality": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowQuality": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowsSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.themes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputView": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.prevDistance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.previousInputPos": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputView": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPrevDistance": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPreviousInputPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setScene": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DScene',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.SeriesType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isItemLabelVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isMeshSmooth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.mesh": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.meshRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.name": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMesh": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshSmooth": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setName": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setUserDefinedMesh": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.userDefinedMesh": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.DataType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.meshAngle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.selectedBar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setMeshAngle": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setSelectedBar": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem',), ('float',), ('float', 'float')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.value": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRow": [('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]',), ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRows": [('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.columnLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.removeRows": ('int', 'int', 'bool'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.resetArray": [(), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setColumnLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRowLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.setLabels": ('typing.Sequence[str]',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isPositionAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isScalingAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isShadowCasting": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.meshFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.scaling": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setMeshFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPositionAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotationAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScaling": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScalingAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setShadowCasting": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isFacingCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFacingCamera": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setText": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.text": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.textColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'int', 'int', 'int', 'typing.List[int]', 'PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.alphaMultiplier": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.colorTable": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.createTextureData": ('typing.List[PySide2.QtGui.QImage]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSliceFrames": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSlices": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.preserveOpacity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.renderSlice": ('PySide2.QtCore.Qt.Axis', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setAlphaMultiplier": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setColorTable": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSliceFrames": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSlices": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setPreserveOpacity": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameGaps": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameThicknesses": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameWidths": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexX": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexY": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexZ": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndices": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSubTextureData": [('PySide2.QtCore.Qt.Axis', 'int', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.Qt.Axis', 'int', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureData": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDepth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDimensions": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureHeight": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureWidth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setUseHighDefShader": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameGaps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameThicknesses": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameWidths": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDataWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDepth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureHeight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.useHighDefShader": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QImage', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMap": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMapFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMapFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setValueRanges": ('float', 'float', 'float', 'float'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.remap": ('str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.remap": ('str', 'str', 'str', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.remap": ('str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.autoSubGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.base": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setAutoSubGrid": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setBase": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setShowEdgeLabels": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.showEdgeLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.valueAt": ('float',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.invalidSelectionIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.itemSize": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.selectedItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setItemSize": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setSelectedItem": ('int',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItem": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItems": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.removeItems": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.resetArray": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.drawMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.selectedPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDrawMode": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setFlatShadingEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setSelectedPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTexture": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.texture": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRow": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRows": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.columnCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.removeRows": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.resetArray": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.formatter": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.labelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.reversed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.segmentCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setFormatter": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setReversed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSubSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.subSegmentCount": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowNegatives": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowZero": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.axis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.gridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelStrings": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.markDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowNegatives": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowZero": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.stringForValue": ('float', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.subGridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.valueAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.qDefaultSurfaceFormat": ('bool',),
-    }) if "PySide2.QtDataVisualization" in sys.modules else None
-# Module PySide2.QtUiTools
-sig_dict.update({
-# class PySide2.QtUiTools.QUiLoader:
-    "PySide2.QtUiTools.QUiLoader.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtUiTools.QUiLoader.addPluginPath": ('str',),
-    "PySide2.QtUiTools.QUiLoader.availableLayouts": (),
-    "PySide2.QtUiTools.QUiLoader.availableWidgets": (),
-    "PySide2.QtUiTools.QUiLoader.clearPluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.createAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createActionGroup": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createLayout": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createWidget": ('str', 'PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtUiTools.QUiLoader.errorString": (),
-    "PySide2.QtUiTools.QUiLoader.isLanguageChangeEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.isTranslationEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.load": [('PySide2.QtCore.QIODevice', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtUiTools.QUiLoader.pluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.registerCustomWidget": ('object',),
-    "PySide2.QtUiTools.QUiLoader.setLanguageChangeEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setTranslationEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setWorkingDirectory": ('PySide2.QtCore.QDir',),
-    "PySide2.QtUiTools.QUiLoader.workingDirectory": (),
-    }) if "PySide2.QtUiTools" in sys.modules else None
-# Module PySide2.QtWebChannel
-sig_dict.update({
-# class PySide2.QtWebChannel.QWebChannel:
-    "PySide2.QtWebChannel.QWebChannel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.blockUpdates": (),
-    "PySide2.QtWebChannel.QWebChannel.connectTo": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.deregisterObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.disconnectFrom": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.registerObject": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebChannel.QWebChannel.registerObjects": ('typing.Dict[str, PySide2.QtCore.QObject]',),
-    "PySide2.QtWebChannel.QWebChannel.registeredObjects": (),
-    "PySide2.QtWebChannel.QWebChannel.setBlockUpdates": ('bool',),
-# class PySide2.QtWebChannel.QWebChannelAbstractTransport:
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.sendMessage": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    }) if "PySide2.QtWebChannel" in sys.modules else None
-# Module PySide2.QtWebEngineCore
-sig_dict.update({
-# class PySide2.QtWebEngineCore.QWebEngineCookieStore:
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteAllCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteSessionCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.loadAllCookies": (),
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest:
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method:
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method'), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.hasHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.header": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.headers": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.method": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postData": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postRequest": ('PySide2.QtCore.QUrl', 'typing.Dict[str, str]'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setMethod": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setPostData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.swap": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.unsetHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.url": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.NavigationType:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.ResourceType:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.block": ('bool',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.changed": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.firstPartyUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.navigationType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.resourceType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.setHttpHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.interceptRequest": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo',),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.fail": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.reply": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestHeaders": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestUrl": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flag:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.SpecialPort:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax:
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',)],
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__copy__": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.defaultPort": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.flags": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.name": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.registerScheme": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.schemeByName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setDefaultPort": ('int',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setFlags": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setSyntax": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.syntax": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler:
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.requestStarted": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob',),
-    }) if "PySide2.QtWebEngineCore" in sys.modules else None
-# Module PySide2.QtWebEngine
-sig_dict.update({
-# class PySide2.QtWebEngine.QtWebEngine:
-    "PySide2.QtWebEngine.QtWebEngine.initialize": (),
-    }) if "PySide2.QtWebEngine" in sys.modules else None
-# Module PySide2.QtWebEngineWidgets
-sig_dict.update({
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError:
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError.Error:
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.__init__": [('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',), ('int', 'PySide2.QtCore.QUrl', 'bool', 'str')],
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.answered": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.certificateChain": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.defer": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.deferred": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.error": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.errorDescription": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.ignoreCertificateError": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.isOverridable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.rejectCertificate": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaType:
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineContextMenuData',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.editFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isContentEditable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.misspelledWord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.position": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.spellCheckerSuggestions": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadInterruptReason:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadState:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadType:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat:
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.cancel": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadDirectory": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.id": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReason": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReasonString": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isFinished": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isPaused": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isSavePageDownload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.mimeType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.path": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.pause": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.receivedBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.resume": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.savePageFormat": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadDirectory": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadFileName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setSavePageFormat": ('PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.state": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.suggestedFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.totalBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.type": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest:
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.origin": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.reject": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.toggleOn": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistory:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoBack": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoForward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItemIndex": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.goToItem": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.itemAt": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.items": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistoryItem:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__init__": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.lastVisited": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.originalUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.swap": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEnginePage:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.Feature:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlag:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.RenderProcessTerminationStatus:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType:
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtWebEngineWidgets.QWebEngineProfile', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.acceptNavigationRequest": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.action": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.backgroundColor": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.certificateError": ('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.chooseFiles": ('PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contentsSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contextMenuData": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createStandardContextMenu": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.devToolsPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.download": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.inspectedPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isAudioMuted": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isVisible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptAlert": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConfirm": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConsoleMessage": ('PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel', 'str', 'int', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptPrompt": ('PySide2.QtCore.QUrl', 'str', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.printToPdf": [('object', 'PySide2.QtGui.QPageLayout'), ('str', 'PySide2.QtGui.QPageLayout')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.profile": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.recentlyAudible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.replaceMisspelledWord": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.requestedUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.runJavaScript": [('str',), ('str', 'int'), ('str', 'int', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.save": ('str', 'PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scrollPosition": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setAudioMuted": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setDevToolsPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setFeaturePermission": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.Feature', 'PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setInspectedPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setView": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setVisible": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setWebChannel": [('PySide2.QtWebChannel.QWebChannel',), ('PySide2.QtWebChannel.QWebChannel', 'int')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toHtml": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toPlainText": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.triggerAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.view": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.webChannel": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.zoomFactor": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy:
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cachePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearAllVisitedLinks": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearHttpCache": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearVisitedLinks": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cookieStore": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.defaultProfile": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.downloadPath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpAcceptLanguage": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheMaximumSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpUserAgent": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.installUrlSchemeHandler": ('PySide2.QtCore.QByteArray', 'PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler'),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isOffTheRecord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isSpellCheckEnabled": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isUsedForGlobalCertificateVerification": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentCookiesPolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentStoragePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeAllUrlSchemeHandlers": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlScheme": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlSchemeHandler": ('PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setCachePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setDownloadPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpAcceptLanguage": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheMaximumSize": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheType": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpUserAgent": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentCookiesPolicy": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentStoragePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckEnabled": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckLanguages": ('typing.Sequence[str]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUseForGlobalCertificateVerification": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.spellCheckLanguages": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.storageName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.urlSchemeHandler": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.visitedLinksContainsUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtWebEngineWidgets.QWebEngineScript:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.ScriptWorldId:
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineScript',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.injectionPoint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.isNull": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.name": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.runsOnSubFrames": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setInjectionPoint": ('PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setRunsOnSubFrames": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setSourceCode": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setWorldId": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.sourceCode": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.swap": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.worldId": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineScriptCollection:
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.contains": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScript": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScripts": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.insert": [('PySide2.QtWebEngineWidgets.QWebEngineScript',), ('typing.Sequence[PySide2.QtWebEngineWidgets.QWebEngineScript]',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.isEmpty": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.remove": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.size": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.toList": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute:
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultTextEncoding": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.globalSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetUnknownUrlSchemePolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setDefaultTextEncoding": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize', 'int'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setUnknownUrlSchemePolicy": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.testAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.unknownUrlSchemePolicy": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineView:
-    "PySide2.QtWebEngineWidgets.QWebEngineView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.pageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.reload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.sizeHint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.stop": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.triggerPageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.zoomFactor": (),
-    }) if "PySide2.QtWebEngineWidgets" in sys.modules else None
-# Module PySide2.QtWebSockets
-sig_dict.update({
-# class PySide2.QtWebSockets.QMaskGenerator:
-    "PySide2.QtWebSockets.QMaskGenerator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebSockets.QMaskGenerator.nextMask": (),
-    "PySide2.QtWebSockets.QMaskGenerator.seed": (),
-# class PySide2.QtWebSockets.QWebSocket:
-    "PySide2.QtWebSockets.QWebSocket.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketProtocol.Version', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocket.abort": (),
-    "PySide2.QtWebSockets.QWebSocket.bytesToWrite": (),
-    "PySide2.QtWebSockets.QWebSocket.close": ('PySide2.QtWebSockets.QWebSocketProtocol.CloseCode', 'str'),
-    "PySide2.QtWebSockets.QWebSocket.closeCode": (),
-    "PySide2.QtWebSockets.QWebSocket.closeReason": (),
-    "PySide2.QtWebSockets.QWebSocket.error": (),
-    "PySide2.QtWebSockets.QWebSocket.errorString": (),
-    "PySide2.QtWebSockets.QWebSocket.flush": (),
-    "PySide2.QtWebSockets.QWebSocket.isValid": (),
-    "PySide2.QtWebSockets.QWebSocket.localAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.localPort": (),
-    "PySide2.QtWebSockets.QWebSocket.maskGenerator": (),
-    "PySide2.QtWebSockets.QWebSocket.open": [('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtWebSockets.QWebSocket.origin": (),
-    "PySide2.QtWebSockets.QWebSocket.pauseMode": (),
-    "PySide2.QtWebSockets.QWebSocket.peerAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.peerName": (),
-    "PySide2.QtWebSockets.QWebSocket.peerPort": (),
-    "PySide2.QtWebSockets.QWebSocket.ping": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.proxy": (),
-    "PySide2.QtWebSockets.QWebSocket.readBufferSize": (),
-    "PySide2.QtWebSockets.QWebSocket.request": (),
-    "PySide2.QtWebSockets.QWebSocket.requestUrl": (),
-    "PySide2.QtWebSockets.QWebSocket.resourceName": (),
-    "PySide2.QtWebSockets.QWebSocket.resume": (),
-    "PySide2.QtWebSockets.QWebSocket.sendBinaryMessage": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.sendTextMessage": ('str',),
-    "PySide2.QtWebSockets.QWebSocket.setMaskGenerator": ('PySide2.QtWebSockets.QMaskGenerator',),
-    "PySide2.QtWebSockets.QWebSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtWebSockets.QWebSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocket.setReadBufferSize": ('int',),
-    "PySide2.QtWebSockets.QWebSocket.state": (),
-    "PySide2.QtWebSockets.QWebSocket.version": (),
-# class PySide2.QtWebSockets.QWebSocketCorsAuthenticator:
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.__init__": [('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',), ('str',)],
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.allowed": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.origin": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.setAllowed": ('bool',),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.swap": ('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',),
-# class PySide2.QtWebSockets.QWebSocketProtocol:
-# class PySide2.QtWebSockets.QWebSocketProtocol.CloseCode:
-# class PySide2.QtWebSockets.QWebSocketProtocol.Version:
-# class PySide2.QtWebSockets.QWebSocketServer:
-# class PySide2.QtWebSockets.QWebSocketServer.SslMode:
-    "PySide2.QtWebSockets.QWebSocketServer.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketServer.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocketServer.close": (),
-    "PySide2.QtWebSockets.QWebSocketServer.error": (),
-    "PySide2.QtWebSockets.QWebSocketServer.errorString": (),
-    "PySide2.QtWebSockets.QWebSocketServer.handleConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtWebSockets.QWebSocketServer.handshakeTimeoutMS": (),
-    "PySide2.QtWebSockets.QWebSocketServer.hasPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.isListening": (),
-    "PySide2.QtWebSockets.QWebSocketServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtWebSockets.QWebSocketServer.maxPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nativeDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nextPendingConnection": (),
-    "PySide2.QtWebSockets.QWebSocketServer.pauseAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.proxy": (),
-    "PySide2.QtWebSockets.QWebSocketServer.resumeAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.secureMode": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverAddress": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverName": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverPort": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverUrl": (),
-    "PySide2.QtWebSockets.QWebSocketServer.setHandshakeTimeout": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setNativeDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocketServer.setServerName": ('str',),
-    "PySide2.QtWebSockets.QWebSocketServer.setSocketDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.socketDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.supportedVersions": (),
-    }) if "PySide2.QtWebSockets" in sys.modules else None
-# Module PySide2.Qt3DCore
-sig_dict.update({
-# class PySide2.Qt3DCore.Qt3DCore:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlag:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlags:
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractAspect:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.rootEntityId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.unregisterBackendType": ('PySide2.QtCore.QMetaObject',),
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton.jointCount": (),
-# class PySide2.Qt3DCore.Qt3DCore.QArmature:
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.skeleton": (),
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine:
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.aspects": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.executeCommand": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.processFrame": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.runMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.setRunMode": ('PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.unregisterAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-# class PySide2.Qt3DCore.Qt3DCore.QAspectJob:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.__init__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.run": (),
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode:
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode:
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode',),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.mode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.peerId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.setEnabled": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponent:
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.entities": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.isShareable": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.setShareable": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QEntity:
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.addComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.components": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.parentEntity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.removeComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-# class PySide2.Qt3DCore.Qt3DCore.QJoint:
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.addChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.childJoints": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.inverseBindMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.removeChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setInverseBindMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setScale": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setToIdentity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.translation": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNode:
-# class PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode:
-    "PySide2.Qt3DCore.Qt3DCore.QNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.blockNotifications": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.childNodes": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTrackings": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.defaultPropertyTrackingMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.notificationsBlocked": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.parentNode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.propertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setDefaultPropertyTrackingMode": ('PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setParent": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QObject',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setPropertyTracking": ('str', 'PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode'),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCommand:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.commandId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.data": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.inReplyTo": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setData": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setReplyToCommandId": ('int',),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.isNodeEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.parentId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode', 'typing.List[PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair]'),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.subtreeIdsAndTypes": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeId:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__copy__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.createId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.isNull": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.QtCore.QMetaObject'), ('PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__copy__": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.addedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.removedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.addedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.setAddedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.removedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.setRemovedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlag:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags:
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.ChangeFlag', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.deliveryFlags": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.setDeliveryFlags": ('PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags',),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.subjectId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.type": (),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.setRootJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader:
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.Status:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.isCreateJointsEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setCreateJointsEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.source": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.status": (),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QTransform:
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxesAndAngles": [('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.matrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateAround": ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateFromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale3D": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale3D": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.translation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.worldMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.qHash": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'int'),
-    "PySide2.Qt3DCore.Qt3DCore.qIdForNode": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    }) if "PySide2.Qt3DCore" in sys.modules else None
-# Module PySide2.Qt3DRender
-sig_dict.update({
-# class PySide2.Qt3DRender.Qt3DRender:
-# class PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface:
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.readProperty": ('typing.Any',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.id": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight.Type:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.color": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.intensity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setIntensity": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.type": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.hits": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.runMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setRunMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.addTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.generateMipMaps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.removeTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.samples": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setGenerateMipMaps": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSamples": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWrapMode": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.textureImages": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.wrapMode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.notifyDataGeneratorChanged": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setMipLevel": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest:
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.alphaFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setAlphaFunction": ('PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setReferenceValue": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType:
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'str', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.attributeType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.buffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteStride": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.count": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultColorAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointIndicesAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointWeightsAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultNormalAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultPositionAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTangentAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate1AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate2AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinateAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.divisor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setAttributeType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setBuffer": ('PySide2.Qt3DRender.Qt3DRender.QBuffer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteStride": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDivisor": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexBaseType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexBaseType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexSize": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.blendFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.setBlendFunction": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.bufferIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationRgb": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setBufferIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceRgb": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod:
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destination": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.interpolationMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestination": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setInterpolationMethod": ('PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSource": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceRect": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType:
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.accessType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.data": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.isSyncData": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setAccessType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setSyncData": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setUsage": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.updateData": ('int', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.usage": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCamera:
-# class PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption:
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.lens": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.pan": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panAboutViewCenter": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.roll": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotate": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotateAboutViewCenter": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotation": ('float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setUpVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setViewCenter": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tilt": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.transform": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translate": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translateWorld": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.upVector": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewCenter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewVector": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens:
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFrustumProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setOrthographicProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setPerspectiveProjection": ('float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewAll": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferTypeFlags:
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.buffers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearColor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearDepthValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearStencilValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.colorBuffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setBuffers": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearDepthValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearStencilValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setColorBuffer": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QClipPlane:
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.normal": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.planeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setDistance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setNormal": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setPlaneIndex": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QColorMask:
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isAlphaMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isBlueMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isGreenMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isRedMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setAlphaMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setBlueMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setGreenMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setRedMasked": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand:
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType:
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.runType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setRunType": ('PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.trigger": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace:
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode:
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.mode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.setMode": ('PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest:
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.depthFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.setDepthFunction": ('PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QDirectionalLight:
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.setWorldDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.worldDirection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDispatchCompute:
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDithering:
-    "PySide2.Qt3DRender.Qt3DRender.QDithering.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QEffect:
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.techniques": (),
-# class PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight:
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.irradiance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setIrradiance": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.specular": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFilterKey:
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.parentFrameGraphNode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.__init__": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.parentFrameGraphNodeId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace:
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection:
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.setDirection": ('PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection',),
-# class PySide2.Qt3DRender.Qt3DRender.QFrustumCulling:
-    "PySide2.Qt3DRender.Qt3DRender.QFrustumCulling.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometry:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.attributes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.boundingVolumePositionAttribute": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.maxExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.minExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.setBoundingVolumePositionAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryFactory:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryFactory.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer:
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstInstance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstVertex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.geometry": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexBufferByteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.instanceCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveRestartEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.restartIndexValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstInstance": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstVertex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexBufferByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setInstanceCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVertexCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVerticesPerPatch": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.vertexCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.verticesPerPatch": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile:
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.api": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.extensions": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.majorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.minorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.profile": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setApi": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setExtensions": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMajorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMinorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setProfile": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setVendor": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.vendor": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLayer:
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.recursive": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.setRecursive": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode:
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail:
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.createBoundingSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.currentIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCurrentIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholdType": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholds": ('typing.List[float]',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setVolumeOverride": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholdType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholds": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.volumeOverride": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.__init__": [('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',), ('PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.center": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.isEmpty": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.radius": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLineWidth:
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setSmooth": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.smooth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMaterial:
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.effect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.setEffect": ('PySide2.Qt3DRender.Qt3DRender.QEffect',),
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operation:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations:
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.setWaitOperations": ('PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.waitOperations": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMesh:
-# class PySide2.Qt3DRender.Qt3DRender.QMesh.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.meshName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setMeshName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing:
-    "PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDepthMask:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDepthMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDraw:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDraw.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoPicking:
-    "PySide2.Qt3DRender.Qt3DRender.QNoPicking.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QObjectPicker:
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.containsMouse": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isDragEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isHoverEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isPressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.priority": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setDragEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setHoverEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setPriority": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.size": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.update": ('PySide2.QtCore.QRect',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QParameter:
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('str', 'PySide2.Qt3DRender.Qt3DRender.QAbstractTexture', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('str', 'typing.Any', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Modifiers:
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.button": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.buttons": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.isAccepted": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.modifiers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.viewport": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickLineEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.edgeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex2Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickPointEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.pointIndex": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.triangleIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.uvw": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex3Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.faceOrientationPickingMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickResultMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setFaceOrientationPickingMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickMethod": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickResultMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setWorldSpaceTolerance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.worldSpaceTolerance": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPointLight:
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize:
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setSizeMode": ('PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.sizeMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPolygonOffset:
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.depthSteps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.scaleFactor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setDepthSteps": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setScaleFactor": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QProximityFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.distanceThreshold": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setDistanceThreshold": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.length": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.origin": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setLength": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.trigger": [(), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float')],
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit:
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__init__": [(), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit',), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType', 'PySide2.Qt3DCore.Qt3DCore.QNodeId', 'float', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__copy__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entityId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.primitiveIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex3Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderAspect.__init__": [('PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.requestCapture": [(), ('PySide2.QtCore.QRect',), ('int',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.captureId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.image": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.isComplete": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveImage": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveToFile": ('str',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPass:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.renderStates": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.shaderProgram": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.matchAny": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.activeFrameGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.pickingSettings": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.renderPolicy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setRenderPolicy": ('PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderState:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderStateSet:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.renderStates": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.externalRenderTargetSize": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurfacePixelRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surface": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surfacePixelRatio": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTarget:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.addOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.removeOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.attachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setOutputs": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint]',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.target": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.component": ('str', 'PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType'),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entity": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entityNames": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScissorTest:
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setBottom": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setLeft": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.setPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.trigger": [(), ('PySide2.QtCore.QPoint',)],
-# class PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap:
-    "PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence:
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handleType": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderData:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.event": ('PySide2.QtCore.QEvent',),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.access": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layered": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setAccess": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayered": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.loadSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.log": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setComputeShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setFragmentShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setGeometryShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setShaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationControlShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationEvaluationShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setVertexShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.shaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.vertexShaderCode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.enabledLayers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setComputeShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setEnabledLayers": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setFragmentShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setGeometryShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationControlShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationEvaluationShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setVertexShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.shaderProgram": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderGraph": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture:
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.setTextureId": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.textureId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy:
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType:
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.setSortTypes": [('typing.List[PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType]',), ('typing.List[int]',)],
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypesInt": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSpotLight:
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.cutOffAngle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.localDirection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setCutOffAngle": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLocalDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilMask:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.backOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.frontOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setBackOutputMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setFrontOutputMask": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.FaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.allTestsPassOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.depthTestFailureOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setAllTestsPassOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setDepthTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setStencilTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.stencilTestFailureOperation": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTest:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.comparisonMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setComparisonMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setReferenceValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setStencilFunction": ('PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.stencilFunction": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechnique:
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.graphicsApiFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.renderPasses": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.matchAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture3D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture3D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureBuffer:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureBuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.isAutoMipMapGenerationEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.cleanup": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.data": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.faces": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.isCompressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.mipLevels": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelFormat": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setData": ('PySide2.QtCore.QByteArray', 'int', 'bool'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFaces": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setImage": ('PySide2.QtGui.QImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setMipLevels": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelFormat": ('PySide2.QtGui.QOpenGLTexture.PixelFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelType": ('PySide2.QtGui.QOpenGLTexture.PixelType',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setTarget": ('PySide2.QtGui.QOpenGLTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageDataGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureLoader:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.source": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureRectangle:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureRectangle.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.__init__": [('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject'), ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject')],
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.x": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.y": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.z": (),
-# class PySide2.Qt3DRender.Qt3DRender.QViewport:
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.gamma": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.normalizedRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setGamma": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setNormalizedRect": ('PySide2.QtCore.QRectF',),
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence:
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setTimeout": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setWaitOnCPU": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.timeout": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.waitOnCPU": (),
-    }) if "PySide2.Qt3DRender" in sys.modules else None
-# Module PySide2.Qt3DInput
-sig_dict.update({
-# class PySide2.Qt3DInput.Qt3DInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.addAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisSettings": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.removeAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-# class PySide2.Qt3DInput.Qt3DInput.QAction:
-    "PySide2.Qt3DInput.Qt3DInput.QAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.isActive": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-# class PySide2.Qt3DInput.Qt3DInput.QActionInput:
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.axis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.setAxis": ('int',),
-# class PySide2.Qt3DInput.Qt3DInput.QAxis:
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.value": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator:
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setScale": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxisType": ('PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxisType": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.value": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.velocity": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisSetting:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.deadZoneRadius": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.isSmoothEnabled": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setAxes": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setDeadZoneRadius": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setSmoothEnabled": ('bool',),
-# class PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.acceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.deceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setAcceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setDeceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setScale": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputAspect:
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.availablePhysicalDevices": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.createPhysicalDevice": ('str',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputChord:
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.addChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.chords": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.removeChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSequence:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.addSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.buttonInterval": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.removeSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.sequences": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setButtonInterval": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSettings:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.eventSource": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.setEventSource": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyEvent:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.count": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAutoRepeat": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.key": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.nativeScanCode": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.text": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.type": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.activeInput": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonNames": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.focus": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setFocus": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QLogicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.actions": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice.Axis:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.sensitivity": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.setSensitivity": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.button": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.wasHeld": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.y": (),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.containsMouse": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setContainsMouse": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QMouseDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.angleDelta": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.y": (),
-    }) if "PySide2.Qt3DInput" in sys.modules else None
-# Module PySide2.Qt3DLogic
-sig_dict.update({
-# class PySide2.Qt3DLogic.Qt3DLogic:
-# class PySide2.Qt3DLogic.Qt3DLogic.QFrameAction:
-    "PySide2.Qt3DLogic.Qt3DLogic.QFrameAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect:
-    "PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect.__init__": ('PySide2.QtCore.QObject',),
-    }) if "PySide2.Qt3DLogic" in sys.modules else None
-# Module PySide2.Qt3DAnimation
-sig_dict.update({
-# class PySide2.Qt3DAnimation.Qt3DAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.AnimationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setAnimationName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setDuration": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip.duration": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractChannelMapping:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.Loops:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.clock": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.isRunning": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.loopCount": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.normalizedTime": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setClock": ('PySide2.Qt3DAnimation.Qt3DAnimation.QClock',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setLoopCount": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setNormalizedTime": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setRunning": ('bool',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.start": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.stop": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.baseClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setBaseClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.Flag:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.__init__": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.valueChanged": ('typing.Any',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.Status:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.source": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.status": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.activeAnimationGroup": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.addAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.animationGroupList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.entity": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getAnimationIndex": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionOffset": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionScale": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.recursive": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.removeAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setActiveAnimationGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setAnimationGroups": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPosition": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionOffset": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionScale": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setRecursive": ('bool',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.addAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.animationList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.name": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.removeAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setAnimations": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.blendTree": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.setBlendTree": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.clip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.setClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClock:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.playbackRate": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.setPlaybackRate": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.__init__": [(), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.coordinates": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.interpolationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.leftControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.rightControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setCoordinates": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setInterpolationType": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setLeftControlPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setRightControlPoint": ('PySide2.QtGui.QVector2D',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.addKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.endMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.framePositions": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.keyframeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.removeKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEndMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setFramePositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setKeyframes": ('typing.List[PySide2.Qt3DCore.Qt3DCore.QTransform]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setStartMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTarget": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.startMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.targetName": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.blendFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.endClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setBlendFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setEndClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setStartClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.startClip": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeNames": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.fromGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry', 'typing.Sequence[str]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.setAttributes": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QAttribute]',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.getWeights": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.method": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMethod": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setWeights": ('int', 'typing.List[float]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetPositions": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.skeleton": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetPositions": (),
-    }) if "PySide2.Qt3DAnimation" in sys.modules else None
-# Module PySide2.Qt3DExtras
-sig_dict.update({
-# class PySide2.Qt3DExtras.Qt3DExtras:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__init__": [(), ('PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__copy__": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.acceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.deceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.linearSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.lookSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setAcceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setDeceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLinearSpeed": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLookSpeed": ('float',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.currentIndex": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setCurrentIndex": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.topRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.topRadius": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setDiffuse": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setSpecular": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.extrusionLength": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.depth": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer:
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.buffersToClear": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.clearColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.externalRenderTargetSize": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.gamma": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.isFrustumCullingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setBuffersToClear": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setFrustumCullingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setGamma": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setViewportRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.surface": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.viewportRect": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.beta": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.cool": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setBeta": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setCool": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setWarm": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.warm": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.ambientOcclusion": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.baseColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.metalness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.roughness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setAmbientOcclusion": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setBaseColor": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setMetalness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setRoughness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.interpolator": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setInterpolator": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.setZoomInLimit": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.zoomInLimit": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.blendFunctionArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setBlendFunctionArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.resolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.meshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.baseName": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.extension": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.isGammaCorrectEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setBaseName": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setExtension": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setGammaCorrectEnabled": ('bool',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.columns": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.rows": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setColumns": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setRows": ('int',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.addSprite": [('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.removeSprite": ('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.setSprites": ('typing.List[PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem]',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.sprites": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setHeight": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setWidth": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setX": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setY": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.width": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.x": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.y": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.color": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.text": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureOffset": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureTransform": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureOffset": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow:
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.__init__": ('PySide2.QtGui.QScreen',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.activeFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.defaultFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.renderSettings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setRootEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    }) if "PySide2.Qt3DExtras" in sys.modules else None
-# Module testbinding
-sig_dict.update({
-# class testbinding.Enum1:
-# class testbinding.IntValue:
-    "testbinding.IntValue.__init__": [(), ('int',), ('testbinding.IntValue',)],
-    "testbinding.IntValue.__copy__": (),
-# class testbinding.PySideCPP:
-# class testbinding.PySideCPP.TestObject2WithNamespace:
-    "testbinding.PySideCPP.TestObject2WithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObject2WithNamespace.__repr__": (),
-    "testbinding.PySideCPP.TestObject2WithNamespace.name": (),
-# class testbinding.PySideCPP.TestObjectWithNamespace:
-    "testbinding.PySideCPP.TestObjectWithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignal": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithNamespace": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.name": (),
-# class testbinding.TestObject:
-    "testbinding.TestObject.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "testbinding.TestObject.addChild": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObject.checkType": ('typing.Any',),
-    "testbinding.TestObject.createApp": (),
-    "testbinding.TestObject.emitIdValueSignal": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_bool": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_void": (),
-    "testbinding.TestObject.emitSignalWithTypedefValue": ('int',),
-    "testbinding.TestObject.emitStaticMethodDoubleSignal": (),
-    "testbinding.TestObject.idValue": (),
-    "testbinding.TestObject.staticMethodDouble": ('int',),
-# class testbinding.TestObjectWithoutNamespace:
-# class testbinding.TestObjectWithoutNamespace.Enum2:
-    "testbinding.TestObjectWithoutNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObjectWithoutNamespace.callSignal": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithNamespace": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.TestObjectWithoutNamespace.name": (),
-# class testbinding.TestView:
-    "testbinding.TestView.__init__": ('PySide2.QtCore.QAbstractListModel', 'PySide2.QtCore.QObject'),
-    "testbinding.TestView.getData": (),
-    "testbinding.TestView.getEditorWidgetFromItemDelegate": (),
-    "testbinding.TestView.model": (),
-    "testbinding.TestView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "testbinding.TestView.getHiddenObject": (),
-    }) if "testbinding" in sys.modules else None
-# Module Shiboken
-sig_dict.update({
-# class Shiboken.VoidPtr:
-    }) if "Shiboken" in sys.modules else None
-# Module minimal
-sig_dict.update({
-# class minimal.ListUser:
-    "minimal.ListUser.__init__": [(), ('minimal.ListUser',)],
-    "minimal.ListUser.__copy__": (),
-    "minimal.ListUser.callCreateIntList": ('int',),
-    "minimal.ListUser.callCreateListOfIntLists": ('int',),
-    "minimal.ListUser.callCreateMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.callCreateObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.callCreateValList": ('int',),
-    "minimal.ListUser.callOredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.callSumIntList": ('typing.List[int]',),
-    "minimal.ListUser.callSumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.callSumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.callSumValList": ('typing.List[minimal.Val]',),
-    "minimal.ListUser.createIntList": ('int',),
-    "minimal.ListUser.createListOfIntLists": ('int',),
-    "minimal.ListUser.createMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.createObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.createValList": ('int',),
-    "minimal.ListUser.oredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.sumIntList": ('typing.List[int]',),
-    "minimal.ListUser.sumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.sumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.sumValList": ('typing.List[minimal.Val]',),
-# class minimal.MinBoolUser:
-    "minimal.MinBoolUser.__init__": [(), ('minimal.MinBoolUser',)],
-    "minimal.MinBoolUser.__copy__": (),
-    "minimal.MinBoolUser.callInvertedMinBool": (),
-    "minimal.MinBoolUser.invertedMinBool": (),
-    "minimal.MinBoolUser.minBool": (),
-    "minimal.MinBoolUser.setMinBool": ('bool',),
-# class minimal.Obj:
-    "minimal.Obj.__init__": ('int',),
-    "minimal.Obj.callPassObjectType": ('minimal.Obj',),
-    "minimal.Obj.callPassObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.callVirtualMethod": ('int',),
-    "minimal.Obj.objId": (),
-    "minimal.Obj.passObjectType": ('minimal.Obj',),
-    "minimal.Obj.passObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.setObjId": ('int',),
-    "minimal.Obj.virtualMethod": ('int',),
-# class minimal.Val:
-# class minimal.Val.ValEnum:
-    "minimal.Val.__init__": [('int',), ('minimal.Val',)],
-    "minimal.Val.__copy__": (),
-    "minimal.Val.callPassValueType": ('minimal.Val',),
-    "minimal.Val.callPassValueTypePointer": ('minimal.Val',),
-    "minimal.Val.callPassValueTypeReference": ('minimal.Val',),
-    "minimal.Val.oneOrTheOtherEnumValue": ('minimal.Val.ValEnum',),
-    "minimal.Val.passValueType": ('minimal.Val',),
-    "minimal.Val.passValueTypePointer": ('minimal.Val',),
-    "minimal.Val.passValueTypeReference": ('minimal.Val',),
-    "minimal.Val.setValId": ('int',),
-    "minimal.Val.valId": (),
-    "minimal.Val.arrayFunc": ('typing.List[int]',),
-    "minimal.Val.arrayFuncInt": ('typing.List[int]',),
-    "minimal.Val.arrayFuncIntReturn": ('int',),
-    "minimal.Val.arrayFuncIntReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncIntTypedef": ('typing.List[int]',),
-    "minimal.Val.arrayFuncReturn": ('int',),
-    "minimal.Val.arrayFuncReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncTypedef": ('typing.List[int]',),
-    }) if "minimal" in sys.modules else None
-# Module sample
-sig_dict.update({
-# class sample.Abstract:
-# class sample.Abstract.PrintFormat:
-# class sample.Abstract.Type:
-    "sample.Abstract.__init__": ('int',),
-    "sample.Abstract.callPureVirtual": (),
-    "sample.Abstract.callUnpureVirtual": (),
-    "sample.Abstract.callVirtualGettingEnum": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.className": (),
-    "sample.Abstract.createObject": (),
-    "sample.Abstract.getObjectId": ('sample.Abstract',),
-    "sample.Abstract.id_": (),
-    "sample.Abstract.pureVirtual": (),
-    "sample.Abstract.pureVirtualReturningVoidPtr": (),
-    "sample.Abstract.returnAnEnum": (),
-    "sample.Abstract.show": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.type": (),
-    "sample.Abstract.unpureVirtual": (),
-    "sample.Abstract.virtualGettingAEnum": ('sample.Abstract.PrintFormat',),
-# class sample.AbstractModifications:
-    "sample.AbstractModifications.__init__": (),
-    "sample.AbstractModifications.invert": ('bool',),
-    "sample.AbstractModifications.pointlessPureVirtualMethod": (),
-# class sample.ArrayModifyTest:
-    "sample.ArrayModifyTest.__init__": [(), ('sample.ArrayModifyTest',)],
-    "sample.ArrayModifyTest.__copy__": (),
-    "sample.ArrayModifyTest.sumIntArray": ('int', 'typing.Sequence[int]'),
-# class sample.Base1:
-    "sample.Base1.__init__": (),
-    "sample.Base1.base1Method": (),
-    "sample.Base1.publicMethod": (),
-# class sample.Base2:
-    "sample.Base2.__init__": (),
-    "sample.Base2.base2Method": (),
-# class sample.Base3:
-    "sample.Base3.__init__": ('int',),
-    "sample.Base3.base3Method": (),
-# class sample.Base4:
-    "sample.Base4.__init__": (),
-    "sample.Base4.base4Method": (),
-# class sample.Base5:
-    "sample.Base5.__init__": (),
-    "sample.Base5.base5Method": (),
-# class sample.Base6:
-    "sample.Base6.__init__": (),
-    "sample.Base6.base6Method": (),
-# class sample.BlackBox:
-    "sample.BlackBox.__init__": [(), ('sample.BlackBox',)],
-    "sample.BlackBox.__copy__": (),
-    "sample.BlackBox.disposeObjectType": ('int',),
-    "sample.BlackBox.disposePoint": ('int',),
-    "sample.BlackBox.keepObjectType": ('object',),
-    "sample.BlackBox.keepPoint": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.objects": (),
-    "sample.BlackBox.points": (),
-    "sample.BlackBox.referenceToObjectPointer": ('object',),
-    "sample.BlackBox.referenceToValuePointer": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.retrieveObjectType": ('int',),
-    "sample.BlackBox.retrievePoint": ('int',),
-# class sample.Bucket:
-    "sample.Bucket.__init__": (),
-    "sample.Bucket.callVirtualBlockerMethodButYouDontKnowThis": (),
-    "sample.Bucket.empty": (),
-    "sample.Bucket.lock": (),
-    "sample.Bucket.locked": (),
-    "sample.Bucket.pop": (),
-    "sample.Bucket.push": ('int',),
-    "sample.Bucket.unlock": (),
-    "sample.Bucket.virtualBlockerMethod": (),
-# class sample.ByteArray:
-    "sample.ByteArray.__init__": [(), ('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__add__": [('int',), ('sample.ByteArray',), ('str',), ('unicode',)],
-    "sample.ByteArray.__copy__": (),
-    "sample.ByteArray.__iadd__": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__repr__": (),
-    "sample.ByteArray.__str__": (),
-    "sample.ByteArray.append": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.at": ('int',),
-    "sample.ByteArray.data": (),
-    "sample.ByteArray.size": (),
-# class sample.CVListUser:
-    "sample.CVListUser.__init__": [(), ('sample.CVListUser',)],
-    "sample.CVListUser.__copy__": (),
-    "sample.CVListUser.consume": ('typing.List[sample.CVValueType]',),
-    "sample.CVListUser.produce": (),
-# class sample.CVValueType:
-    "sample.CVValueType.__copy__": (),
-# class sample.ClassWithFunctionPointer:
-    "sample.ClassWithFunctionPointer.__init__": [(), ('sample.ClassWithFunctionPointer',)],
-    "sample.ClassWithFunctionPointer.__copy__": (),
-    "sample.ClassWithFunctionPointer.doNothing": ('int',),
-# class sample.Collector:
-    "sample.Collector.__init__": (),
-    "sample.Collector.__lshift__": [('Missing("sample.ObjectType.Identifier")',), ('object',), ('sample.IntWrapper',)],
-    "sample.Collector.clear": (),
-    "sample.Collector.items": (),
-    "sample.Collector.size": (),
-# class sample.Color:
-    "sample.Color.__init__": [(), ('int',), ('sample.Color',), ('sample.SampleNamespace.InValue',)],
-    "sample.Color.__copy__": (),
-    "sample.Color.isNull": (),
-# class sample.CtorConvRule:
-    "sample.CtorConvRule.__init__": [('int',), ('sample.CtorConvRule',)],
-    "sample.CtorConvRule.__copy__": (),
-    "sample.CtorConvRule.dummyVirtualMethod": (),
-    "sample.CtorConvRule.value": (),
-# class sample.Data:
-# class sample.Data.Field:
-    "sample.Data.__init__": [('sample.Data',), ('sample.Data.Field', 'str')],
-    "sample.Data.__and__": ('sample.Union',),
-    "sample.Data.__copy__": (),
-    "sample.Data.field": (),
-    "sample.Data.value": (),
-# class sample.Derived:
-# class sample.Derived.OtherOverloadedFuncEnum:
-# class sample.Derived.SomeInnerClass:
-    "sample.Derived.SomeInnerClass.__init__": [(), ('sample.Derived.SomeInnerClass',)],
-    "sample.Derived.SomeInnerClass.__add__": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.SomeInnerClass.__copy__": (),
-    "sample.Derived.SomeInnerClass.uselessMethod": (),
-    "sample.Derived.__init__": ('int',),
-    "sample.Derived.className": (),
-    "sample.Derived.createObject": (),
-    "sample.Derived.defaultValue": ('int',),
-    "sample.Derived.getClassName": (),
-    "sample.Derived.otherOverloaded": [('int', 'float'), ('int', 'int', 'bool', 'float')],
-    "sample.Derived.overloaded": [('float',), ('int', 'int')],
-    "sample.Derived.pureVirtual": (),
-    "sample.Derived.pureVirtualReturningVoidPtr": (),
-    "sample.Derived.returnAnEnum": (),
-    "sample.Derived.returnMyParameter": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.singleArgument": ('bool',),
-    "sample.Derived.triggerAnotherImpossibleTypeDiscovery": (),
-    "sample.Derived.triggerImpossibleTypeDiscovery": (),
-    "sample.Derived.type": (),
-    "sample.Derived.unpureVirtual": (),
-# class sample.Echo:
-    "sample.Echo.__init__": [(), ('sample.Echo',)],
-    "sample.Echo.__call__": ('sample.Str', 'int'),
-    "sample.Echo.__copy__": (),
-    "sample.Echo.__lshift__": [('int',), ('object',), ('sample.Str',)],
-    "sample.Echo.doNothingWithConstBool": ('bool',),
-    "sample.Echo.echo": ('str',),
-    "sample.Echo.methodWithNamedArg": ('sample.Str',),
-# class sample.EnumOnNamespace:
-# class sample.Event:
-# class sample.Event.EventType:
-# class sample.Event.EventTypeClass:
-    "sample.Event.__init__": [('sample.Event',), ('sample.Event.EventType',)],
-    "sample.Event.__copy__": (),
-    "sample.Event.eventType": (),
-    "sample.Event.setEventType": ('sample.Event.EventType',),
-    "sample.Event.setEventTypeByConstRef": ('sample.Event.EventType',),
-# class sample.ExceptionTest:
-    "sample.ExceptionTest.__init__": (),
-    "sample.ExceptionTest.intThrowInt": ('bool',),
-    "sample.ExceptionTest.intThrowStdException": ('bool',),
-    "sample.ExceptionTest.voidThrowInt": ('bool',),
-    "sample.ExceptionTest.voidThrowStdException": ('bool',),
-# class sample.Expression:
-    "sample.Expression.__init__": [('int',), ('sample.Expression',)],
-    "sample.Expression.__add__": ('sample.Expression',),
-    "sample.Expression.__copy__": (),
-    "sample.Expression.__sub__": ('sample.Expression',),
-    "sample.Expression.toString": (),
-# class sample.Filter:
-    "sample.Filter.__init__": [(), ('sample.Filter',)],
-    "sample.Filter.__copy__": (),
-# class sample.FriendOfOnlyCopy:
-    "sample.FriendOfOnlyCopy.__init__": [(), ('sample.FriendOfOnlyCopy',)],
-    "sample.FriendOfOnlyCopy.__copy__": (),
-    "sample.FriendOfOnlyCopy.createListOfOnlyCopy": ('int',),
-    "sample.FriendOfOnlyCopy.createOnlyCopy": ('int',),
-# class sample.GlobalEnum:
-# class sample.GlobalOverloadFuncEnum:
-# class sample.HandleHolder:
-    "sample.HandleHolder.__init__": ('int',),
-    "sample.HandleHolder.compare": ('sample.HandleHolder',),
-    "sample.HandleHolder.compare2": ('sample.HandleHolder',),
-    "sample.HandleHolder.createHandle": (),
-    "sample.HandleHolder.handle": (),
-    "sample.HandleHolder.handle2": (),
-    "sample.HandleHolder.set": ('int',),
-# class sample.ImplicitBase:
-    "sample.ImplicitBase.__init__": [(), ('sample.ImplicitBase',), ('sample.ImplicitTarget',)],
-    "sample.ImplicitBase.__copy__": (),
-# class sample.ImplicitConv:
-# class sample.ImplicitConv.CtorEnum:
-# class sample.ImplicitConv.ICOverloadedFuncEnum:
-    "sample.ImplicitConv.__init__": [(), ('None',), ('float', 'bool'), ('int',), ('object',), ('sample.ImplicitConv',), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.__copy__": (),
-    "sample.ImplicitConv.ctorEnum": (),
-    "sample.ImplicitConv.implicitConvCommon": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvDefault": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvOverloading": [('int',), ('sample.ImplicitConv', 'bool'), ('sample.ImplicitConv', 'int'), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.objId": (),
-    "sample.ImplicitConv.value": (),
-# class sample.ImplicitTarget:
-    "sample.ImplicitTarget.__init__": [(), ('sample.ImplicitTarget',)],
-    "sample.ImplicitTarget.__copy__": (),
-# class sample.InjectCode:
-    "sample.InjectCode.__init__": [(), ('sample.InjectCode',)],
-    "sample.InjectCode.__copy__": (),
-    "sample.InjectCode.arrayMethod": ('int',),
-    "sample.InjectCode.callArrayMethod": ('int',),
-    "sample.InjectCode.overloadedMethod": [('int', 'bool'), ('int', 'float'), ('int', 'typing.List[str]')],
-    "sample.InjectCode.simpleMethod1": ('int', 'int'),
-    "sample.InjectCode.simpleMethod2": (),
-    "sample.InjectCode.simpleMethod3": ('int', 'typing.List[str]'),
-    "sample.InjectCode.sumArrayAndLength": (),
-    "sample.InjectCode.virtualMethod": ('int',),
-# class sample.IntArray2:
-    "sample.IntArray2.__init__": [('int',), ('sample.IntArray2',), ('typing.Sequence[int]',)],
-    "sample.IntArray2.__copy__": (),
-    "sample.IntArray2.sum": (),
-# class sample.IntArray3:
-    "sample.IntArray3.__init__": [('int',), ('sample.IntArray3',), ('typing.Sequence[int]',)],
-    "sample.IntArray3.__copy__": (),
-    "sample.IntArray3.sum": (),
-# class sample.IntList:
-# class sample.IntList.CtorEnum:
-    "sample.IntList.__init__": [(), ('int',), ('sample.IntList',), ('typing.Sequence[int]',)],
-    "sample.IntList.__copy__": (),
-    "sample.IntList.append": ('int',),
-    "sample.IntList.constructorUsed": (),
-# class sample.IntWrapper:
-    "sample.IntWrapper.__init__": [('int',), ('sample.IntWrapper',)],
-    "sample.IntWrapper.__copy__": (),
-# class sample.Intersection:
-    "sample.Intersection.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Intersection.__and__": ('sample.Intersection',),
-    "sample.Intersection.__copy__": (),
-    "sample.Intersection.addFilter": ('sample.Filter',),
-    "sample.Intersection.filters": (),
-# class sample.ListUser:
-# class sample.ListUser.ListOfSomething:
-    "sample.ListUser.__init__": [(), ('sample.ListUser',)],
-    "sample.ListUser.__copy__": (),
-    "sample.ListUser.callCreateList": (),
-    "sample.ListUser.createComplexList": ('complex', 'complex'),
-    "sample.ListUser.createList": (),
-    "sample.ListUser.getList": (),
-    "sample.ListUser.listOfPoints": [('typing.List[sample.PointF]',), ('typing.List[typing.Tuple]',)],
-    "sample.ListUser.multiplyPointList": ('typing.List[typing.Tuple]', 'float'),
-    "sample.ListUser.setList": ('typing.List[int]',),
-    "sample.ListUser.sumList": [('typing.List[float]',), ('typing.List[int]',)],
-# class sample.MDerived1:
-    "sample.MDerived1.__init__": (),
-    "sample.MDerived1.base1Method": (),
-    "sample.MDerived1.base2Method": (),
-    "sample.MDerived1.castToBase1": (),
-    "sample.MDerived1.castToBase2": (),
-    "sample.MDerived1.mderived1Method": (),
-    "sample.MDerived1.publicMethod": (),
-    "sample.MDerived1.transformFromBase1": ('sample.Base1',),
-    "sample.MDerived1.transformFromBase2": ('sample.Base2',),
-# class sample.MDerived2:
-    "sample.MDerived2.__init__": (),
-    "sample.MDerived2.base4Method": (),
-    "sample.MDerived2.castToBase3": (),
-    "sample.MDerived2.castToBase4": (),
-    "sample.MDerived2.castToBase5": (),
-    "sample.MDerived2.castToBase6": (),
-    "sample.MDerived2.mderived2Method": (),
-# class sample.MDerived3:
-    "sample.MDerived3.__init__": (),
-    "sample.MDerived3.castToBase3": (),
-    "sample.MDerived3.castToMDerived1": (),
-    "sample.MDerived3.castToMDerived2": (),
-    "sample.MDerived3.mderived3Method": (),
-# class sample.MDerived4:
-    "sample.MDerived4.__init__": (),
-    "sample.MDerived4.castToBase3": (),
-    "sample.MDerived4.castToBase4": (),
-    "sample.MDerived4.justDummyMethod": (),
-    "sample.MDerived4.mderived4Method": (),
-# class sample.MDerived5:
-    "sample.MDerived5.__init__": (),
-    "sample.MDerived5.castToBase3": (),
-    "sample.MDerived5.castToBase4": (),
-    "sample.MDerived5.mderived5Method": (),
-# class sample.MapUser:
-    "sample.MapUser.__init__": [(), ('sample.MapUser',)],
-    "sample.MapUser.__copy__": (),
-    "sample.MapUser.callCreateMap": (),
-    "sample.MapUser.createMap": (),
-    "sample.MapUser.foo": (),
-    "sample.MapUser.getMap": (),
-    "sample.MapUser.passMapIntValueType": ('typing.Dict[int, sample.ByteArray]',),
-    "sample.MapUser.pointerToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.referenceToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.setMap": ('typing.Dict[str, typing.List]',),
-    "sample.MapUser.showMap": ('typing.Dict[str, int]',),
-# class sample.ModelIndex:
-    "sample.ModelIndex.__init__": [(), ('sample.ModelIndex',)],
-    "sample.ModelIndex.__copy__": (),
-    "sample.ModelIndex.getValue": ('sample.ModelIndex',),
-    "sample.ModelIndex.setValue": ('int',),
-    "sample.ModelIndex.value": (),
-# class sample.Modifications:
-# class sample.Modifications.OverloadedModFunc:
-# class sample.Modifications.TestEnum:
-    "sample.Modifications.__init__": (),
-    "sample.Modifications.argRemoval0": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'int')],
-    "sample.Modifications.argRemoval1": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.argRemoval2": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval3": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval4": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval5": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.calculateArea": ('int', 'int'),
-    "sample.Modifications.callDifferenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.defaultEnumValue": (),
-    "sample.Modifications.differenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.doublePlus": ('int', 'int'),
-    "sample.Modifications.enumValue": (),
-    "sample.Modifications.getObject": (),
-    "sample.Modifications.getSize": ('int', 'int'),
-    "sample.Modifications.increment": ('int',),
-    "sample.Modifications.invertBoolean": ('bool',),
-    "sample.Modifications.multiplyPointCoordsPlusValue": ('typing.Tuple[float, float]', 'float'),
-    "sample.Modifications.name": (),
-    "sample.Modifications.nonConversionRuleForArgumentWithDefaultValue": ('object',),
-    "sample.Modifications.over": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Modifications.overloaded": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'float'), ('int', 'bool', 'int', 'int'), ('int', 'bool', 'int', 'typing.Tuple[float, float]')],
-    "sample.Modifications.pointToPair": ('typing.Tuple[float, float]',),
-    "sample.Modifications.power": ('int', 'int'),
-    "sample.Modifications.setEnumValue": ('sample.Modifications.TestEnum',),
-    "sample.Modifications.sumPointArray": ('int', 'typing.Sequence[typing.Tuple]'),
-    "sample.Modifications.sumPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.timesTen": ('int',),
-# class sample.ModifiedConstructor:
-    "sample.ModifiedConstructor.__init__": ('int',),
-    "sample.ModifiedConstructor.retrieveValue": (),
-# class sample.NoImplicitConversion:
-    "sample.NoImplicitConversion.__init__": [('int',), ('sample.NoImplicitConversion',)],
-    "sample.NoImplicitConversion.__copy__": (),
-    "sample.NoImplicitConversion.objId": (),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByPointer": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByReference": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByValue": ('sample.NoImplicitConversion',),
-# class sample.NonDefaultCtor:
-    "sample.NonDefaultCtor.__init__": [('int',), ('sample.NonDefaultCtor',)],
-    "sample.NonDefaultCtor.__copy__": (),
-    "sample.NonDefaultCtor.callReturnMyselfVirtual": (),
-    "sample.NonDefaultCtor.returnMyself": [(), ('int',), ('int', 'sample.NonDefaultCtor')],
-    "sample.NonDefaultCtor.returnMyselfVirtual": (),
-    "sample.NonDefaultCtor.value": (),
-# class sample.ObjTypeReference:
-    "sample.ObjTypeReference.__init__": [(), ('sample.ObjTypeReference',)],
-    "sample.ObjTypeReference.justAPureVirtualFunc": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMyFirstArg": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMySecondArg": ('int', 'sample.ObjTypeReference'),
-# class sample.ObjectModel:
-# class sample.ObjectModel.MethodCalled:
-    "sample.ObjectModel.__init__": ('object',),
-    "sample.ObjectModel.data": (),
-    "sample.ObjectModel.receivesObjectTypeFamily": [('object',), ('sample.ObjectModel',)],
-    "sample.ObjectModel.setData": ('object',),
-# class sample.ObjectType:
-    "sample.ObjectType.__init__": ('object',),
-    "sample.ObjectType.callId": (),
-    "sample.ObjectType.callInvalidateEvent": ('sample.Event',),
-    "sample.ObjectType.callVirtualCreateChild": (),
-    "sample.ObjectType.callWithEnum": [('sample.Str', 'int'), ('sample.Str', 'sample.Event.EventType', 'int')],
-    "sample.ObjectType.causeEvent": ('sample.Event.EventType',),
-    "sample.ObjectType.children": (),
-    "sample.ObjectType.create": (),
-    "sample.ObjectType.createChild": ('object',),
-    "sample.ObjectType.createObjectType": (),
-    "sample.ObjectType.createWithChild": (),
-    "sample.ObjectType.deprecatedFunction": (),
-    "sample.ObjectType.destroyCppParent": (),
-    "sample.ObjectType.event": ('sample.Event',),
-    "sample.ObjectType.findChild": ('sample.Str',),
-    "sample.ObjectType.getCppParent": (),
-    "sample.ObjectType.identifier": (),
-    "sample.ObjectType.invalidateEvent": ('sample.Event',),
-    "sample.ObjectType.isLayoutType": (),
-    "sample.ObjectType.isPython": (),
-    "sample.ObjectType.killChild": ('sample.Str',),
-    "sample.ObjectType.layout": (),
-    "sample.ObjectType.nextInFocusChain": (),
-    "sample.ObjectType.objectName": (),
-    "sample.ObjectType.parent": (),
-    "sample.ObjectType.processEvent": ('typing.List[object]', 'sample.Event'),
-    "sample.ObjectType.removeChild": ('object',),
-    "sample.ObjectType.setLayout": ('sample.ObjectTypeLayout',),
-    "sample.ObjectType.setNullObject": ('None',),
-    "sample.ObjectType.setObject": ('object',),
-    "sample.ObjectType.setObjectName": ('sample.Str',),
-    "sample.ObjectType.setObjectNameWithSize": [('sample.Str', 'int'), ('str', 'int', 'sample.Str')],
-    "sample.ObjectType.setObjectSplittedName": ('str', 'sample.Str', 'sample.Str'),
-    "sample.ObjectType.setParent": ('object',),
-    "sample.ObjectType.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeByValue:
-    "sample.ObjectTypeByValue.__init__": (),
-    "sample.ObjectTypeByValue.acceptKindOfMeAsValue": ('sample.ObjectTypeByValue',),
-    "sample.ObjectTypeByValue.acceptListOfObjectTypeByValue": ('typing.List[sample.ObjectTypeByValue]',),
-    "sample.ObjectTypeByValue.returnSomeKindOfMe": (),
-# class sample.ObjectTypeDerived:
-    "sample.ObjectTypeDerived.__init__": (),
-    "sample.ObjectTypeDerived.event": ('sample.Event',),
-# class sample.ObjectTypeHolder:
-    "sample.ObjectTypeHolder.__init__": [('sample.ObjectTypeHolder',), ('str',)],
-    "sample.ObjectTypeHolder.__copy__": (),
-    "sample.ObjectTypeHolder.callPassObjectTypeAsReference": (),
-    "sample.ObjectTypeHolder.getObjecType": (),
-    "sample.ObjectTypeHolder.passObjectTypeAsReference": ('object',),
-# class sample.ObjectTypeLayout:
-    "sample.ObjectTypeLayout.__init__": (),
-    "sample.ObjectTypeLayout.addObject": ('object',),
-    "sample.ObjectTypeLayout.create": (),
-    "sample.ObjectTypeLayout.isLayoutType": (),
-    "sample.ObjectTypeLayout.objects": (),
-    "sample.ObjectTypeLayout.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeOperators:
-    "sample.ObjectTypeOperators.__init__": ('str',),
-    "sample.ObjectTypeOperators.__add__": ('str',),
-    "sample.ObjectTypeOperators.key": (),
-# class sample.ObjectTypePtrList:
-# class sample.ObjectTypePtrList.CtorEnum:
-    "sample.ObjectTypePtrList.__init__": [(), ('object',), ('sample.ObjectTypePtrList',), ('typing.Sequence[object]',)],
-    "sample.ObjectTypePtrList.__copy__": (),
-    "sample.ObjectTypePtrList.append": ('object',),
-    "sample.ObjectTypePtrList.constructorUsed": (),
-# class sample.ObjectView:
-    "sample.ObjectView.__init__": ('sample.ObjectModel', 'object'),
-    "sample.ObjectView.displayModelData": (),
-    "sample.ObjectView.getRawModelData": (),
-    "sample.ObjectView.model": (),
-    "sample.ObjectView.modifyModelData": ('sample.Str',),
-    "sample.ObjectView.setModel": ('sample.ObjectModel',),
-# class sample.OddBoolUser:
-    "sample.OddBoolUser.__init__": [(), ('bool',), ('sample.OddBoolUser',)],
-    "sample.OddBoolUser.__copy__": (),
-    "sample.OddBoolUser.callInvertedOddBool": (),
-    "sample.OddBoolUser.getOddBool": ('sample.OddBoolUser',),
-    "sample.OddBoolUser.invertedOddBool": (),
-    "sample.OddBoolUser.oddBool": (),
-    "sample.OddBoolUser.setOddBool": ('bool',),
-# class sample.OnlyCopy:
-    "sample.OnlyCopy.__init__": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.__copy__": (),
-    "sample.OnlyCopy.getValue": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.getValueFromReference": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.value": (),
-# class sample.OtherBase:
-    "sample.OtherBase.__init__": (),
-# class sample.Overload:
-# class sample.Overload.FunctionEnum:
-# class sample.Overload.ParamEnum:
-    "sample.Overload.__init__": (),
-    "sample.Overload.acceptSequence": [(), ('int',), ('int', 'int'), ('sample.Size',), ('sample.Str', 'sample.Overload.ParamEnum'), ('typing.Sequence[str]',)],
-    "sample.Overload.differentReturnTypes": [('sample.Overload.ParamEnum',), ('sample.Overload.ParamEnum', 'int')],
-    "sample.Overload.drawText": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText2": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText3": [('int', 'int', 'int', 'int', 'int'), ('sample.Str', 'sample.Str', 'sample.Str')],
-    "sample.Overload.drawText4": [('int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "sample.Overload.intDoubleOverloads": [('float', 'float'), ('int', 'int')],
-    "sample.Overload.intOverloads": [('int', 'int'), ('int', 'int', 'float'), ('typing.Tuple[float, float]', 'float')],
-    "sample.Overload.overloaded": [(), ('sample.Size',), ('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'sample.Overload.ParamEnum')],
-    "sample.Overload.singleOverload": [(), ('typing.Tuple[float, float]',)],
-    "sample.Overload.strBufferOverloads": [(), ('sample.Str', 'int'), ('sample.Str', 'str', 'bool'), ('str', 'int')],
-    "sample.Overload.wrapperIntIntOverloads": [('sample.Polygon', 'int', 'int'), ('typing.Tuple[float, float]', 'int', 'int')],
-# class sample.Overload2:
-    "sample.Overload2.__init__": (),
-    "sample.Overload2.doNothingInPublic": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic2": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic3": [(), ('int',)],
-# class sample.OverloadedFuncEnum:
-# class sample.PairUser:
-    "sample.PairUser.__init__": [(), ('sample.PairUser',)],
-    "sample.PairUser.__copy__": (),
-    "sample.PairUser.callCreatePair": (),
-    "sample.PairUser.createComplexPair": ('complex', 'complex'),
-    "sample.PairUser.createPair": (),
-    "sample.PairUser.getPair": (),
-    "sample.PairUser.setPair": ('typing.Tuple[int, int]',),
-    "sample.PairUser.sumPair": ('typing.Tuple[int, float]',),
-# class sample.Pen:
-    "sample.Pen.__init__": [(), ('sample.Color',), ('sample.Pen',), ('sample.SampleNamespace.Option',)],
-    "sample.Pen.__copy__": (),
-    "sample.Pen.ctorType": (),
-# class sample.PersistentModelIndex:
-    "sample.PersistentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.PersistentModelIndex',)],
-    "sample.PersistentModelIndex.__copy__": (),
-    "sample.PersistentModelIndex.setValue": ('int',),
-    "sample.PersistentModelIndex.value": (),
-# class sample.Photon:
-# class sample.Photon.Base:
-    "sample.Photon.Base.__init__": [('int',), ('sample.Photon.Base',)],
-    "sample.Photon.Base.__copy__": (),
-    "sample.Photon.Base.isType": ('sample.Photon.ClassType',),
-    "sample.Photon.Base.setValue": ('int',),
-    "sample.Photon.Base.type": (),
-    "sample.Photon.Base.value": (),
-# class sample.Photon.ClassType:
-# class sample.Photon.ValueDuplicator:
-    "sample.Photon.ValueDuplicator.__init__": [('int',), ('sample.Photon.ValueDuplicator',)],
-    "sample.Photon.ValueDuplicator.__copy__": (),
-    "sample.Photon.ValueDuplicator.calculate": (),
-    "sample.Photon.ValueDuplicator.classType": (),
-    "sample.Photon.ValueDuplicator.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueDuplicator.multiplicator": (),
-    "sample.Photon.ValueDuplicator.passPointerThrough": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.type": (),
-# class sample.Photon.ValueIdentity:
-    "sample.Photon.ValueIdentity.__init__": [('int',), ('sample.Photon.ValueIdentity',)],
-    "sample.Photon.ValueIdentity.__copy__": (),
-    "sample.Photon.ValueIdentity.calculate": (),
-    "sample.Photon.ValueIdentity.classType": (),
-    "sample.Photon.ValueIdentity.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueIdentity.multiplicator": (),
-    "sample.Photon.ValueIdentity.passPointerThrough": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingPointer": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingReference": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.type": (),
-    "sample.Photon.callCalculateForValueDuplicatorPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.callCalculateForValueDuplicatorReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.countValueDuplicators": ('typing.List[sample.Photon.ValueDuplicator]',),
-    "sample.Photon.countValueIdentities": ('typing.List[sample.Photon.ValueIdentity]',),
-# class sample.Point:
-    "sample.Point.__init__": [('float', 'float'), ('int', 'int'), ('typing.Tuple[float, float]',)],
-    "sample.Point.__add__": ('typing.Tuple[float, float]',),
-    "sample.Point.__copy__": (),
-    "sample.Point.__iadd__": ('typing.Tuple[float, float]',),
-    "sample.Point.__isub__": ('typing.Tuple[float, float]',),
-    "sample.Point.__mul__": [('float',), ('int',)],
-    "sample.Point.__neg__": (),
-    "sample.Point.__reduce__": (),
-    "sample.Point.__repr__": (),
-    "sample.Point.__str__": (),
-    "sample.Point.__sub__": [('typing.Tuple[float, float]',), ('unicode',)],
-    "sample.Point.copy": (),
-    "sample.Point.getConstReferenceToSelf": (),
-    "sample.Point.getSelf": (),
-    "sample.Point.midpoint": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Point.setX": ('float',),
-    "sample.Point.setXAsUint": ('int',),
-    "sample.Point.setY": ('float',),
-    "sample.Point.setYAsUint": ('int',),
-    "sample.Point.show": (),
-    "sample.Point.x": (),
-    "sample.Point.y": (),
-# class sample.PointF:
-    "sample.PointF.__init__": [('float', 'float'), ('sample.PointF',), ('typing.Tuple[float, float]',)],
-    "sample.PointF.__add__": ('sample.PointF',),
-    "sample.PointF.__copy__": (),
-    "sample.PointF.__iadd__": ('sample.PointF',),
-    "sample.PointF.__isub__": ('sample.PointF',),
-    "sample.PointF.__mul__": [('float',), ('int',)],
-    "sample.PointF.__neg__": (),
-    "sample.PointF.__reduce__": (),
-    "sample.PointF.__repr__": (),
-    "sample.PointF.__str__": (),
-    "sample.PointF.__sub__": ('sample.PointF',),
-    "sample.PointF.midpoint": ('sample.PointF', 'sample.PointF'),
-    "sample.PointF.setX": ('float',),
-    "sample.PointF.setY": ('float',),
-    "sample.PointF.show": (),
-    "sample.PointF.x": (),
-    "sample.PointF.y": (),
-# class sample.PointValueList:
-# class sample.PointValueList.CtorEnum:
-    "sample.PointValueList.__init__": [(), ('sample.PointValueList',), ('typing.Sequence[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.PointValueList.__copy__": (),
-    "sample.PointValueList.append": ('typing.Tuple[float, float]',),
-    "sample.PointValueList.constructorUsed": (),
-# class sample.PointerHolder:
-    "sample.PointerHolder.__init__": [('object',), ('sample.PointerHolder',)],
-    "sample.PointerHolder.__copy__": (),
-    "sample.PointerHolder.pointer": (),
-# class sample.Polygon:
-    "sample.Polygon.__init__": [(), ('float', 'float'), ('sample.Polygon',), ('typing.List[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.Polygon.__copy__": (),
-    "sample.Polygon.addPoint": ('typing.Tuple[float, float]',),
-    "sample.Polygon.doublePolygonScale": ('sample.Polygon',),
-    "sample.Polygon.points": (),
-    "sample.Polygon.stealOwnershipFromPython": [('sample.Polygon',), ('typing.Tuple[float, float]',)],
-# class sample.PrimitiveStructPointerHolder:
-    "sample.PrimitiveStructPointerHolder.__init__": [(), ('sample.PrimitiveStructPointerHolder',)],
-    "sample.PrimitiveStructPointerHolder.__copy__": (),
-# class sample.PrivateCtor:
-    "sample.PrivateCtor.instance": (),
-    "sample.PrivateCtor.instanceCalls": (),
-# class sample.PrivateDtor:
-    "sample.PrivateDtor.instance": (),
-    "sample.PrivateDtor.instanceCalls": (),
-    "sample.PrivateDtor.protectedInstanceCalls": (),
-# class sample.ProtectedEnumClass:
-# class sample.ProtectedEnumClass.ProtectedEnum:
-# class sample.ProtectedEnumClass.PublicEnum:
-    "sample.ProtectedEnumClass.__init__": (),
-    "sample.ProtectedEnumClass.callProtectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.callPublicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-    "sample.ProtectedEnumClass.protectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.publicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-# class sample.ProtectedNonPolymorphic:
-    "sample.ProtectedNonPolymorphic.__init__": [('sample.ProtectedNonPolymorphic',), ('str',)],
-    "sample.ProtectedNonPolymorphic.__copy__": (),
-    "sample.ProtectedNonPolymorphic.create": (),
-    "sample.ProtectedNonPolymorphic.dataTypeName": [('int',), ('object',)],
-    "sample.ProtectedNonPolymorphic.modifiedProtectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.protectedName": (),
-    "sample.ProtectedNonPolymorphic.protectedStatic": (),
-    "sample.ProtectedNonPolymorphic.protectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphic:
-    "sample.ProtectedPolymorphic.__init__": [('sample.ProtectedPolymorphic',), ('str',)],
-    "sample.ProtectedPolymorphic.__copy__": (),
-    "sample.ProtectedPolymorphic.callProtectedName": (),
-    "sample.ProtectedPolymorphic.create": (),
-    "sample.ProtectedPolymorphic.protectedName": (),
-    "sample.ProtectedPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphicDaughter:
-    "sample.ProtectedPolymorphicDaughter.__init__": [('sample.ProtectedPolymorphicDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicDaughter.create": (),
-# class sample.ProtectedPolymorphicGrandDaughter:
-    "sample.ProtectedPolymorphicGrandDaughter.__init__": [('sample.ProtectedPolymorphicGrandDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicGrandDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicGrandDaughter.create": (),
-# class sample.ProtectedProperty:
-    "sample.ProtectedProperty.__init__": [(), ('sample.ProtectedProperty',)],
-    "sample.ProtectedProperty.__copy__": (),
-# class sample.ProtectedVirtualDestructor:
-    "sample.ProtectedVirtualDestructor.__init__": (),
-    "sample.ProtectedVirtualDestructor.create": (),
-    "sample.ProtectedVirtualDestructor.dtorCalled": (),
-    "sample.ProtectedVirtualDestructor.resetDtorCounter": (),
-# class sample.Rect:
-    "sample.Rect.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',)],
-    "sample.Rect.__copy__": (),
-    "sample.Rect.bottom": (),
-    "sample.Rect.left": (),
-    "sample.Rect.right": (),
-    "sample.Rect.top": (),
-# class sample.RectF:
-    "sample.RectF.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',), ('sample.RectF',)],
-    "sample.RectF.__copy__": (),
-    "sample.RectF.bottom": (),
-    "sample.RectF.left": (),
-    "sample.RectF.right": (),
-    "sample.RectF.top": (),
-# class sample.Reference:
-    "sample.Reference.__init__": [('int',), ('sample.Reference',)],
-    "sample.Reference.__copy__": (),
-    "sample.Reference.alterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callAlterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callUsesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.callUsesReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.multiplier": (),
-    "sample.Reference.objId": (),
-    "sample.Reference.returnMyFirstArg": ('sample.Reference',),
-    "sample.Reference.returnMySecondArg": ('int', 'sample.Reference'),
-    "sample.Reference.setObjId": ('int',),
-    "sample.Reference.show": (),
-    "sample.Reference.usesConstReference": ('sample.Reference',),
-    "sample.Reference.usesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.usesReference": ('sample.Reference',),
-    "sample.Reference.usesReferenceVirtual": ('sample.Reference', 'int'),
-# class sample.ReferentModelIndex:
-    "sample.ReferentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.ReferentModelIndex',)],
-    "sample.ReferentModelIndex.__copy__": (),
-    "sample.ReferentModelIndex.setValue": ('int',),
-    "sample.ReferentModelIndex.value": (),
-# class sample.RemovedNamespace1_Enum:
-# class sample.RemovedNamespace2_Enum:
-# class sample.SampleNamespace:
-# class sample.SampleNamespace.DerivedFromNamespace:
-    "sample.SampleNamespace.DerivedFromNamespace.__init__": (),
-    "sample.SampleNamespace.DerivedFromNamespace.methodReturningTypeFromParentScope": (),
-    "sample.SampleNamespace.DerivedFromNamespace.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.InValue:
-# class sample.SampleNamespace.Option:
-# class sample.SampleNamespace.OutValue:
-# class sample.SampleNamespace.SomeClass:
-# class sample.SampleNamespace.SomeClass.ProtectedEnum:
-# class sample.SampleNamespace.SomeClass.PublicScopedEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnumClass:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.__init__": (),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass',),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__copy__": (),
-# class sample.SampleNamespace.SomeClass.SomeOtherInnerClass:
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeOtherInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.__init__": [(), ('sample.SampleNamespace.SomeClass',)],
-    "sample.SampleNamespace.SomeClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.protectedMethodReturningPublicScopedEnum": (),
-    "sample.SampleNamespace.ImInsideANamespace": ('int', 'int'),
-    "sample.SampleNamespace.doSomethingWithArray": ('str', 'int', 'str'),
-    "sample.SampleNamespace.enumArgumentWithDefaultValue": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.enumInEnumOut": ('sample.SampleNamespace.InValue',),
-    "sample.SampleNamespace.enumItemAsDefaultValueToIntArgument": ('int',),
-    "sample.SampleNamespace.forceDecisorSideA": [('object',), ('typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.forceDecisorSideB": [('int', 'object'), ('int', 'typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.getNumber": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.passReferenceToObjectType": [('object',), ('object', 'int')],
-    "sample.SampleNamespace.passReferenceToValueType": [('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'float')],
-    "sample.SampleNamespace.powerOfTwo": ('float',),
-# class sample.SbkDate:
-    "sample.SbkDate.__init__": [('int', 'int', 'int'), ('sample.SbkDate',)],
-    "sample.SbkDate.__copy__": (),
-    "sample.SbkDate.day": (),
-    "sample.SbkDate.month": (),
-    "sample.SbkDate.toPython": (),
-    "sample.SbkDate.year": (),
-# class sample.SimpleFile:
-    "sample.SimpleFile.__init__": [('sample.SimpleFile',), ('str',)],
-    "sample.SimpleFile.__copy__": (),
-    "sample.SimpleFile.close": (),
-    "sample.SimpleFile.exists": [(), ('str',)],
-    "sample.SimpleFile.filename": (),
-    "sample.SimpleFile.open": (),
-    "sample.SimpleFile.size": (),
-# class sample.Size:
-    "sample.Size.__init__": [('float', 'float'), ('sample.Size',), ('str',)],
-    "sample.Size.__add__": ('sample.Size',),
-    "sample.Size.__copy__": (),
-    "sample.Size.__iadd__": ('sample.Size',),
-    "sample.Size.__imul__": ('float',),
-    "sample.Size.__isub__": ('sample.Size',),
-    "sample.Size.__mul__": ('float',),
-    "sample.Size.__sub__": ('sample.Size',),
-    "sample.Size.calculateArea": (),
-    "sample.Size.height": (),
-    "sample.Size.setHeight": ('float',),
-    "sample.Size.setWidth": ('float',),
-    "sample.Size.show": (),
-    "sample.Size.width": (),
-# class sample.SizeF:
-    "sample.SizeF.__init__": [('float', 'float'), ('sample.SizeF',)],
-    "sample.SizeF.__copy__": (),
-    "sample.SizeF.height": (),
-    "sample.SizeF.passTypedefOfUnsignedShort": ('int',),
-    "sample.SizeF.width": (),
-# class sample.SonOfMDerived1:
-    "sample.SonOfMDerived1.__init__": (),
-    "sample.SonOfMDerived1.castToMDerived1": (),
-    "sample.SonOfMDerived1.sonOfMDerived1Method": (),
-# class sample.SortedOverload:
-    "sample.SortedOverload.__init__": [(), ('sample.SortedOverload',)],
-    "sample.SortedOverload.__copy__": (),
-    "sample.SortedOverload.implicit_overload": ('sample.ImplicitBase',),
-    "sample.SortedOverload.overload": [('float',), ('int',), ('object',), ('sample.ImplicitBase',), ('sample.ImplicitTarget',), ('typing.List[sample.ImplicitBase]',)],
-    "sample.SortedOverload.overloadDeep": [('int', 'object'), ('int', 'sample.ImplicitBase')],
-    "sample.SortedOverload.pyObjOverload": [('int', 'int'), ('str', 'int')],
-# class sample.Str:
-    "sample.Str.__init__": [('int',), ('sample.Str',), ('str',)],
-    "sample.Str.__add__": ('int',),
-    "sample.Str.__copy__": (),
-    "sample.Str.__str__": (),
-    "sample.Str.append": ('sample.Str',),
-    "sample.Str.arg": ('sample.Str',),
-    "sample.Str.cstring": (),
-    "sample.Str.get_char": ('int',),
-    "sample.Str.prepend": ('sample.Str',),
-    "sample.Str.set_char": ('int', 'int'),
-    "sample.Str.show": (),
-    "sample.Str.size": (),
-    "sample.Str.toInt": ('int',),
-# class sample.StrList:
-# class sample.StrList.CtorEnum:
-    "sample.StrList.__init__": [(), ('sample.Str',), ('sample.StrList',), ('typing.List[sample.Str]',)],
-    "sample.StrList.__copy__": (),
-    "sample.StrList.append": ('sample.Str',),
-    "sample.StrList.constructorUsed": (),
-    "sample.StrList.join": ('sample.Str',),
-# class sample.TemplatePtr:
-    "sample.TemplatePtr.__init__": (),
-    "sample.TemplatePtr.dummy_method": ('typing.List[typing.Tuple]',),
-# class sample.Time:
-# class sample.Time.NumArgs:
-    "sample.Time.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Time',)],
-    "sample.Time.__copy__": (),
-    "sample.Time.hour": (),
-    "sample.Time.isNull": (),
-    "sample.Time.minute": (),
-    "sample.Time.msec": (),
-    "sample.Time.second": (),
-    "sample.Time.setTime": [(), ('int', 'int', 'int', 'int')],
-    "sample.Time.somethingCompletelyDifferent": [(), ('int', 'int', 'sample.ImplicitConv', 'object')],
-    "sample.Time.toString": (),
-# class sample.Union:
-    "sample.Union.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Union.__and__": ('sample.Data',),
-    "sample.Union.__copy__": (),
-    "sample.Union.addFilter": ('sample.Filter',),
-    "sample.Union.filters": (),
-# class sample.UnremovedNamespace:
-# class sample.UnremovedNamespace.RemovedNamespace3_Enum:
-# class sample.ValueAndVirtual:
-    "sample.ValueAndVirtual.__init__": [('int',), ('sample.ValueAndVirtual',)],
-    "sample.ValueAndVirtual.__call__": ('int', 'int'),
-    "sample.ValueAndVirtual.__copy__": (),
-    "sample.ValueAndVirtual.id": (),
-# class sample.VirtualDaughter:
-    "sample.VirtualDaughter.__init__": [(), ('sample.Str',), ('sample.VirtualDaughter',)],
-    "sample.VirtualDaughter.__copy__": (),
-# class sample.VirtualDaughter2:
-    "sample.VirtualDaughter2.__init__": (),
-    "sample.VirtualDaughter2.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualDaughter2.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualDtor:
-    "sample.VirtualDtor.__init__": [(), ('sample.VirtualDtor',)],
-    "sample.VirtualDtor.__copy__": (),
-    "sample.VirtualDtor.create": (),
-    "sample.VirtualDtor.dtorCalled": (),
-    "sample.VirtualDtor.resetDtorCounter": (),
-# class sample.VirtualFinalDaughter:
-    "sample.VirtualFinalDaughter.__init__": (),
-    "sample.VirtualFinalDaughter.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualFinalDaughter.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualMethods:
-    "sample.VirtualMethods.__init__": [('sample.Str',), ('sample.VirtualMethods',)],
-    "sample.VirtualMethods.__copy__": (),
-    "sample.VirtualMethods.callCallMe": (),
-    "sample.VirtualMethods.callCreateStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.callGetMargins": (),
-    "sample.VirtualMethods.callMe": (),
-    "sample.VirtualMethods.callName": (),
-    "sample.VirtualMethods.callRecursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.callStrListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.callSum0": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callVirtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-    "sample.VirtualMethods.createStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.getMargins": (),
-    "sample.VirtualMethods.name": (),
-    "sample.VirtualMethods.recursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.setMargins": ('int', 'int', 'int', 'int'),
-    "sample.VirtualMethods.strListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.sum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualMethods.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VoidHolder:
-    "sample.VoidHolder.__init__": [('int',), ('sample.VoidHolder',)],
-    "sample.VoidHolder.__copy__": (),
-    "sample.VoidHolder.gimmeMeSomeVoidPointer": (),
-    "sample.VoidHolder.takeVoidPointer": ('int',),
-    "sample.VoidHolder.voidPointer": (),
-# class sample.sample:
-# class sample.sample.sample:
-    "sample.sample.sample.__init__": [('int',), ('sample.sample.sample',)],
-    "sample.sample.sample.__copy__": (),
-    "sample.sample.sample.value": (),
-    "sample.sample.acceptDouble": ('float',),
-    "sample.sample.acceptInt": ('int',),
-    "sample.sample.acceptIntReference": ('int',),
-    "sample.sample.acceptLong": ('int',),
-    "sample.sample.acceptOddBoolReference": ('bool',),
-    "sample.sample.acceptUInt": ('int',),
-    "sample.sample.acceptULong": ('int',),
-    "sample.sample.applyHomogeneousTransform": ('typing.Tuple[float, float]', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "sample.sample.cacheSize": (),
-    "sample.sample.changePStr": ('str',),
-    "sample.sample.convertIntegersToCppAndThenToPython": ('int', 'int'),
-    "sample.sample.convertListOfIntegersToCppAndThenToPython": ('typing.List[int]',),
-    "sample.sample.convertObjectTypeToCppAndThenToPython": ('object', 'object'),
-    "sample.sample.convertValueTypeToCppAndThenToPython": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.sample.countCharacters": ('str',),
-    "sample.sample.countVarargs": ('int', 'None'),
-    "sample.sample.cppTypeIsObjectType": ('str',),
-    "sample.sample.cppTypeIsValueType": ('str',),
-    "sample.sample.createListOfPStr": ('str', 'str'),
-    "sample.sample.createPStrList": ('str', 'str'),
-    "sample.sample.createProtectedProperty": (),
-    "sample.sample.doubleLongLong": ('int',),
-    "sample.sample.doubleShort": ('int',),
-    "sample.sample.doubleUnsignedInt": ('int',),
-    "sample.sample.doubleUnsignedLongLong": ('int',),
-    "sample.sample.duplicatePStr": (),
-    "sample.sample.getConversionTypeString": ('str',),
-    "sample.sample.getPythonType": ('str',),
-    "sample.sample.gimmeComplexList": (),
-    "sample.sample.gimmeDouble": (),
-    "sample.sample.gimmeInt": (),
-    "sample.sample.makeCString": (),
-    "sample.sample.multiplyPair": ('typing.Tuple[float, float]',),
-    "sample.sample.multiplyString": ('str', 'int'),
-    "sample.sample.overloadedFunc": [('float',), ('int',)],
-    "sample.sample.returnCString": (),
-    "sample.sample.returnNullObjectTypePointer": (),
-    "sample.sample.returnNullPrimitivePointer": (),
-    "sample.sample.returnNullValueTypePointer": (),
-    "sample.sample.sum2d": ('typing.List[typing.List]',),
-    "sample.sample.sumComplexPair": ('typing.Tuple[complex, complex]',),
-    "sample.sample.sumDoubleArray": ('typing.Tuple[float, float, float, float]',),
-    "sample.sample.sumDoubleMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumIntArray": ('typing.Tuple[int, int, int, int]',),
-    "sample.sample.sumIntMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumproduct": ('typing.List[typing.Tuple]',),
-    "sample.sample.transmuteComplexIntoPoint": ('complex',),
-    "sample.sample.transmutePointIntoComplex": ('typing.Tuple[float, float]',),
-    }) if "sample" in sys.modules else None
-# Module other
-sig_dict.update({
-# class other.ExtendsNoImplicitConversion:
-    "other.ExtendsNoImplicitConversion.__init__": [('Missing("other.ExtendsNoImplicitConversion")',), ('int',)],
-    "other.ExtendsNoImplicitConversion.__copy__": (),
-    "other.ExtendsNoImplicitConversion.objId": (),
-# class other.Number:
-    "other.Number.__init__": [('int',), ('numbers.Number',)],
-    "other.Number.__copy__": (),
-    "other.Number.__mul__": ('typing.Tuple[float, float]',),
-    "other.Number.fromComplex": ('complex',),
-    "other.Number.toComplex": (),
-    "other.Number.toStr": (),
-    "other.Number.value": (),
-# class other.OtherDerived:
-    "other.OtherDerived.__init__": ('int',),
-    "other.OtherDerived.className": (),
-    "other.OtherDerived.createObject": (),
-    "other.OtherDerived.getClassName": (),
-    "other.OtherDerived.pureVirtual": (),
-    "other.OtherDerived.pureVirtualReturningVoidPtr": (),
-    "other.OtherDerived.returnAnEnum": (),
-    "other.OtherDerived.unpureVirtual": (),
-    "other.OtherDerived.useEnumTypeFromOtherModule": ('sample.OverloadedFuncEnum',),
-    "other.OtherDerived.useObjectTypeFromOtherModule": ('object',),
-    "other.OtherDerived.useValueTypeFromOtherModule": [('complex',), ('sample.Event',)],
-# class other.OtherMultipleDerived:
-    "other.OtherMultipleDerived.__init__": (),
-    "other.OtherMultipleDerived.createObject": ('str',),
-    "other.OtherMultipleDerived.returnUselessClass": (),
-# class other.OtherObjectType:
-    "other.OtherObjectType.__init__": (),
-    "other.OtherObjectType.__lshift__": ('sample.Collector',),
-    }) if "other" in sys.modules else None
-# Module smart
-sig_dict.update({
-# class smart.Integer:
-    "smart.Integer.__init__": [(), ('smart.Integer',)],
-    "smart.Integer.__copy__": (),
-    "smart.Integer.printInteger": (),
-# class smart.Integer2:
-    "smart.Integer2.__init__": [(), ('int',)],
-    "smart.Integer2.__copy__": (),
-# class smart.Obj:
-    "smart.Obj.__init__": (),
-    "smart.Obj.giveSharedPtrToInteger": (),
-    "smart.Obj.giveSharedPtrToInteger2": (),
-    "smart.Obj.giveSharedPtrToObj": (),
-    "smart.Obj.giveSharedPtrToObjList": ('int',),
-    "smart.Obj.printObj": (),
-    "smart.Obj.takeInteger": ('smart.Integer',),
-    "smart.Obj.takeSharedPtrToInteger": ('smart.SharedPtr',),
-    "smart.Obj.takeSharedPtrToObj": ('smart.SharedPtr',),
-# class smart.Registry:
-    "smart.Registry.__init__": (),
-    "smart.Registry.add": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.countIntegers": (),
-    "smart.Registry.countObjects": (),
-    "smart.Registry.getInstance": (),
-    "smart.Registry.remove": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.setShouldPrint": ('bool',),
-    "smart.Registry.shouldPrint": (),
-# class smart.SharedPtr:
-# class smart.SharedPtr.__next_in_mro__:
-# class smart.SharedPtr<Integer >:
-    "smart.SharedPtr<Integer >.__copy__": (),
-    "smart.SharedPtr<Integer >.data": (),
-    "smart.SharedPtr<Integer >.useCount": (),
-# class smart.SharedPtr<Obj >:
-    "smart.SharedPtr<Obj >.__copy__": (),
-    "smart.SharedPtr<Obj >.data": (),
-    "smart.SharedPtr<Obj >.useCount": (),
-# class smart.SharedPtr<Smart::Integer2 >:
-    "smart.SharedPtr<Smart::Integer2 >.__copy__": (),
-    "smart.SharedPtr<Smart::Integer2 >.data": (),
-    "smart.SharedPtr<Smart::Integer2 >.useCount": (),
-    }) if "smart" in sys.modules else None
-# eof
diff --git a/sources/pyside6/tests/registry/exists_win32_5_14_2_ci.py b/sources/pyside6/tests/registry/exists_win32_5_14_2_ci.py
deleted file mode 100644
index 504525ce6..000000000
--- a/sources/pyside6/tests/registry/exists_win32_5_14_2_ci.py
+++ /dev/null
@@ -1,37927 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-"""
-This file contains the simplified signatures for all functions in PySide
-for module 'exists_win32_5_14_2_ci' using
-Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)]
-Qt 5.14.2 (x86_64-little_endian-llp64 shared (dynamic) release build; by MSVC 2017)
-There are no default values, no variable names and no self
-parameter. Only types are present after simplification. The
-functions 'next' resp. '__next__' are removed to make the output
-identical for Python 2 and 3. '__div__' is also removed,
-since it exists in Python 2, only.
-"""
-import sys
-sig_dict = {}
-# Module PySide2.QtCore
-sig_dict.update({
-# class PySide2.QtCore.ClassInfo:
-    "PySide2.QtCore.ClassInfo.__init__": ('typing.Dict',),
-# class PySide2.QtCore.MetaFunction:
-    "PySide2.QtCore.MetaFunction.__call__": ('typing.Any',),
-# class PySide2.QtCore.MetaSignal:
-    "PySide2.QtCore.MetaSignal.__instancecheck__": ('object',),
-# class PySide2.QtCore.Property:
-    "PySide2.QtCore.Property.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'str', 'typing.Callable', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool'),
-    "PySide2.QtCore.Property.getter": ('typing.Callable',),
-    "PySide2.QtCore.Property.read": ('typing.Callable',),
-    "PySide2.QtCore.Property.setter": ('typing.Callable',),
-    "PySide2.QtCore.Property.write": ('typing.Callable',),
-# class PySide2.QtCore.QAbstractAnimation:
-# class PySide2.QtCore.QAbstractAnimation.DeletionPolicy:
-# class PySide2.QtCore.QAbstractAnimation.Direction:
-# class PySide2.QtCore.QAbstractAnimation.State:
-    "PySide2.QtCore.QAbstractAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractAnimation.currentLoop": (),
-    "PySide2.QtCore.QAbstractAnimation.currentLoopTime": (),
-    "PySide2.QtCore.QAbstractAnimation.currentTime": (),
-    "PySide2.QtCore.QAbstractAnimation.direction": (),
-    "PySide2.QtCore.QAbstractAnimation.duration": (),
-    "PySide2.QtCore.QAbstractAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractAnimation.group": (),
-    "PySide2.QtCore.QAbstractAnimation.loopCount": (),
-    "PySide2.QtCore.QAbstractAnimation.pause": (),
-    "PySide2.QtCore.QAbstractAnimation.resume": (),
-    "PySide2.QtCore.QAbstractAnimation.setCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.setLoopCount": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setPaused": ('bool',),
-    "PySide2.QtCore.QAbstractAnimation.start": ('PySide2.QtCore.QAbstractAnimation.DeletionPolicy',),
-    "PySide2.QtCore.QAbstractAnimation.state": (),
-    "PySide2.QtCore.QAbstractAnimation.stop": (),
-    "PySide2.QtCore.QAbstractAnimation.totalDuration": (),
-    "PySide2.QtCore.QAbstractAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QAbstractEventDispatcher:
-# class PySide2.QtCore.QAbstractEventDispatcher.TimerInfo:
-    "PySide2.QtCore.QAbstractEventDispatcher.TimerInfo.__init__": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QAbstractEventDispatcher.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.closingDown": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.filterNativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QAbstractEventDispatcher.flush": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.hasPendingEvents": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.instance": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QAbstractEventDispatcher.interrupt": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.processEvents": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerEventNotifier": ('PySide2.QtCore.QWinEventNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerTimer": [('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject'), ('int', 'int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QAbstractEventDispatcher.registeredTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.remainingTime": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.startingUp": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterEventNotifier": ('PySide2.QtCore.QWinEventNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimer": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.wakeUp": (),
-# class PySide2.QtCore.QAbstractItemModel:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOption:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOptions:
-# class PySide2.QtCore.QAbstractItemModel.LayoutChangeHint:
-    "PySide2.QtCore.QAbstractItemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndexList": ('typing.List', 'typing.List'),
-    "PySide2.QtCore.QAbstractItemModel.checkIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QAbstractItemModel.CheckIndexOptions'),
-    "PySide2.QtCore.QAbstractItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object')],
-    "PySide2.QtCore.QAbstractItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.decodeData": ('int', 'int', 'PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.encodeData": ('typing.List', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.endInsertColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endInsertRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasIndex": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QAbstractItemModel.mimeData": ('typing.List',),
-    "PySide2.QtCore.QAbstractItemModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractItemModel.moveColumn": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRow": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractItemModel.persistentIndexList": (),
-    "PySide2.QtCore.QAbstractItemModel.removeColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractItemModel.revert": (),
-    "PySide2.QtCore.QAbstractItemModel.roleNames": (),
-    "PySide2.QtCore.QAbstractItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtCore.QAbstractItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractItemModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.submit": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractListModel:
-    "PySide2.QtCore.QAbstractListModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractListModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractNativeEventFilter:
-    "PySide2.QtCore.QAbstractNativeEventFilter.__init__": (),
-    "PySide2.QtCore.QAbstractNativeEventFilter.nativeEventFilter": ('PySide2.QtCore.QByteArray', 'int'),
-# class PySide2.QtCore.QAbstractProxyModel:
-    "PySide2.QtCore.QAbstractProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeData": ('typing.List',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractProxyModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractProxyModel.revert": (),
-    "PySide2.QtCore.QAbstractProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtCore.QAbstractProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QAbstractProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractProxyModel.sourceModel": (),
-    "PySide2.QtCore.QAbstractProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.submit": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractState:
-    "PySide2.QtCore.QAbstractState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractState.active": (),
-    "PySide2.QtCore.QAbstractState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.machine": (),
-    "PySide2.QtCore.QAbstractState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.parentState": (),
-# class PySide2.QtCore.QAbstractTableModel:
-    "PySide2.QtCore.QAbstractTableModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractTableModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractTableModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractTransition:
-# class PySide2.QtCore.QAbstractTransition.TransitionType:
-    "PySide2.QtCore.QAbstractTransition.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractTransition.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.animations": (),
-    "PySide2.QtCore.QAbstractTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.machine": (),
-    "PySide2.QtCore.QAbstractTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.setTargetState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QAbstractTransition.setTargetStates": ('typing.Sequence',),
-    "PySide2.QtCore.QAbstractTransition.setTransitionType": ('PySide2.QtCore.QAbstractTransition.TransitionType',),
-    "PySide2.QtCore.QAbstractTransition.sourceState": (),
-    "PySide2.QtCore.QAbstractTransition.targetState": (),
-    "PySide2.QtCore.QAbstractTransition.targetStates": (),
-    "PySide2.QtCore.QAbstractTransition.transitionType": (),
-# class PySide2.QtCore.QAnimationGroup:
-    "PySide2.QtCore.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAnimationGroup.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.animationAt": ('int',),
-    "PySide2.QtCore.QAnimationGroup.animationCount": (),
-    "PySide2.QtCore.QAnimationGroup.clear": (),
-    "PySide2.QtCore.QAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAnimationGroup.indexOfAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.insertAnimation": ('int', 'PySide2.QtCore.QAbstractAnimation'),
-    "PySide2.QtCore.QAnimationGroup.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.takeAnimation": ('int',),
-# class PySide2.QtCore.QBasicMutex:
-    "PySide2.QtCore.QBasicMutex.__init__": (),
-    "PySide2.QtCore.QBasicMutex.isRecursive": (),
-    "PySide2.QtCore.QBasicMutex.lock": (),
-    "PySide2.QtCore.QBasicMutex.tryLock": (),
-    "PySide2.QtCore.QBasicMutex.try_lock": (),
-    "PySide2.QtCore.QBasicMutex.unlock": (),
-# class PySide2.QtCore.QBasicTimer:
-    "PySide2.QtCore.QBasicTimer.__init__": [(), ('PySide2.QtCore.QBasicTimer',)],
-    "PySide2.QtCore.QBasicTimer.__copy__": (),
-    "PySide2.QtCore.QBasicTimer.isActive": (),
-    "PySide2.QtCore.QBasicTimer.start": [('int', 'PySide2.QtCore.QObject'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QBasicTimer.stop": (),
-    "PySide2.QtCore.QBasicTimer.swap": ('PySide2.QtCore.QBasicTimer',),
-    "PySide2.QtCore.QBasicTimer.timerId": (),
-# class PySide2.QtCore.QBitArray:
-    "PySide2.QtCore.QBitArray.__init__": [(), ('PySide2.QtCore.QBitArray',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.__and__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__copy__": (),
-    "PySide2.QtCore.QBitArray.__iand__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__invert__": (),
-    "PySide2.QtCore.QBitArray.__ior__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__ixor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__or__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__xor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.at": ('int',),
-    "PySide2.QtCore.QBitArray.bits": (),
-    "PySide2.QtCore.QBitArray.clear": (),
-    "PySide2.QtCore.QBitArray.clearBit": ('int',),
-    "PySide2.QtCore.QBitArray.count": [(), ('bool',)],
-    "PySide2.QtCore.QBitArray.fill": [('bool', 'int'), ('bool', 'int', 'int')],
-    "PySide2.QtCore.QBitArray.fromBits": ('bytes', 'int'),
-    "PySide2.QtCore.QBitArray.isEmpty": (),
-    "PySide2.QtCore.QBitArray.isNull": (),
-    "PySide2.QtCore.QBitArray.resize": ('int',),
-    "PySide2.QtCore.QBitArray.setBit": [('int',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.size": (),
-    "PySide2.QtCore.QBitArray.swap": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.testBit": ('int',),
-    "PySide2.QtCore.QBitArray.toggleBit": ('int',),
-    "PySide2.QtCore.QBitArray.truncate": ('int',),
-# class PySide2.QtCore.QBuffer:
-    "PySide2.QtCore.QBuffer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QBuffer.atEnd": (),
-    "PySide2.QtCore.QBuffer.buffer": (),
-    "PySide2.QtCore.QBuffer.canReadLine": (),
-    "PySide2.QtCore.QBuffer.close": (),
-    "PySide2.QtCore.QBuffer.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.data": (),
-    "PySide2.QtCore.QBuffer.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QBuffer.pos": (),
-    "PySide2.QtCore.QBuffer.readData": ('bytes', 'int'),
-    "PySide2.QtCore.QBuffer.seek": ('int',),
-    "PySide2.QtCore.QBuffer.setBuffer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.size": (),
-    "PySide2.QtCore.QBuffer.writeData": ('bytes', 'int'),
-# class PySide2.QtCore.QByteArray:
-# class PySide2.QtCore.QByteArray.Base64Option:
-# class PySide2.QtCore.QByteArray.Base64Options:
-    "PySide2.QtCore.QByteArray.__init__": [(), ('PySide2.QtCore.QByteArray',), ('bytearray',), ('bytes',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.__add__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('bytes',), ('int',)],
-    "PySide2.QtCore.QByteArray.__copy__": (),
-    "PySide2.QtCore.QByteArray.__iadd__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',)],
-    "PySide2.QtCore.QByteArray.__reduce__": (),
-    "PySide2.QtCore.QByteArray.__repr__": (),
-    "PySide2.QtCore.QByteArray.__str__": (),
-    "PySide2.QtCore.QByteArray.append": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.at": ('int',),
-    "PySide2.QtCore.QByteArray.back": (),
-    "PySide2.QtCore.QByteArray.capacity": (),
-    "PySide2.QtCore.QByteArray.cbegin": (),
-    "PySide2.QtCore.QByteArray.cend": (),
-    "PySide2.QtCore.QByteArray.chop": ('int',),
-    "PySide2.QtCore.QByteArray.chopped": ('int',),
-    "PySide2.QtCore.QByteArray.clear": (),
-    "PySide2.QtCore.QByteArray.compare": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.Qt.CaseSensitivity'), ('bytes', 'PySide2.QtCore.Qt.CaseSensitivity')],
-    "PySide2.QtCore.QByteArray.contains": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.count": [(), ('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.data": (),
-    "PySide2.QtCore.QByteArray.endsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.fill": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.fromBase64": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray.Base64Options')],
-    "PySide2.QtCore.QByteArray.fromHex": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.fromPercentEncoding": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.fromRawData": ('bytes', 'int'),
-    "PySide2.QtCore.QByteArray.front": (),
-    "PySide2.QtCore.QByteArray.indexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.insert": [('int', 'PySide2.QtCore.QByteArray'), ('int', 'int', 'int')],
-    "PySide2.QtCore.QByteArray.isEmpty": (),
-    "PySide2.QtCore.QByteArray.isLower": (),
-    "PySide2.QtCore.QByteArray.isNull": (),
-    "PySide2.QtCore.QByteArray.isSharedWith": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.isUpper": (),
-    "PySide2.QtCore.QByteArray.lastIndexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.left": ('int',),
-    "PySide2.QtCore.QByteArray.leftJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.length": (),
-    "PySide2.QtCore.QByteArray.mid": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.number": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.prepend": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.remove": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.repeated": ('int',),
-    "PySide2.QtCore.QByteArray.replace": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('int', 'PySide2.QtCore.QByteArray'), ('int', 'int'), ('int', 'int', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtCore.QByteArray.reserve": ('int',),
-    "PySide2.QtCore.QByteArray.resize": ('int',),
-    "PySide2.QtCore.QByteArray.right": ('int',),
-    "PySide2.QtCore.QByteArray.rightJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.setNum": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.setRawData": ('bytes', 'int'),
-    "PySide2.QtCore.QByteArray.shrink_to_fit": (),
-    "PySide2.QtCore.QByteArray.simplified": (),
-    "PySide2.QtCore.QByteArray.size": (),
-    "PySide2.QtCore.QByteArray.split": ('int',),
-    "PySide2.QtCore.QByteArray.squeeze": (),
-    "PySide2.QtCore.QByteArray.startsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.swap": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.toBase64": [(), ('PySide2.QtCore.QByteArray.Base64Options',)],
-    "PySide2.QtCore.QByteArray.toDouble": (),
-    "PySide2.QtCore.QByteArray.toFloat": (),
-    "PySide2.QtCore.QByteArray.toHex": [(), ('int',)],
-    "PySide2.QtCore.QByteArray.toInt": ('int',),
-    "PySide2.QtCore.QByteArray.toLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLower": (),
-    "PySide2.QtCore.QByteArray.toPercentEncoding": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.toShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUInt": ('int',),
-    "PySide2.QtCore.QByteArray.toULong": ('int',),
-    "PySide2.QtCore.QByteArray.toULongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toUShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUpper": (),
-    "PySide2.QtCore.QByteArray.trimmed": (),
-    "PySide2.QtCore.QByteArray.truncate": ('int',),
-# class PySide2.QtCore.QByteArrayMatcher:
-    "PySide2.QtCore.QByteArrayMatcher.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArrayMatcher',), ('bytes', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.__copy__": (),
-    "PySide2.QtCore.QByteArrayMatcher.indexIn": [('PySide2.QtCore.QByteArray', 'int'), ('bytes', 'int', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.pattern": (),
-    "PySide2.QtCore.QByteArrayMatcher.setPattern": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QCalendar:
-# class PySide2.QtCore.QCalendar.System:
-# class PySide2.QtCore.QCalendar.YearMonthDay:
-    "PySide2.QtCore.QCalendar.YearMonthDay.__init__": [(), ('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.YearMonthDay.__copy__": (),
-    "PySide2.QtCore.QCalendar.YearMonthDay.isValid": (),
-    "PySide2.QtCore.QCalendar.__init__": [(), ('PySide2.QtCore.QCalendar.System',)],
-    "PySide2.QtCore.QCalendar.__copy__": (),
-    "PySide2.QtCore.QCalendar.availableCalendars": (),
-    "PySide2.QtCore.QCalendar.dateFromParts": [('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.dayOfWeek": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.daysInMonth": ('int', 'int'),
-    "PySide2.QtCore.QCalendar.daysInYear": ('int',),
-    "PySide2.QtCore.QCalendar.hasYearZero": (),
-    "PySide2.QtCore.QCalendar.isDateValid": ('int', 'int', 'int'),
-    "PySide2.QtCore.QCalendar.isGregorian": (),
-    "PySide2.QtCore.QCalendar.isLeapYear": ('int',),
-    "PySide2.QtCore.QCalendar.isLunar": (),
-    "PySide2.QtCore.QCalendar.isLuniSolar": (),
-    "PySide2.QtCore.QCalendar.isProleptic": (),
-    "PySide2.QtCore.QCalendar.isSolar": (),
-    "PySide2.QtCore.QCalendar.isValid": (),
-    "PySide2.QtCore.QCalendar.maximumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.maximumMonthsInYear": (),
-    "PySide2.QtCore.QCalendar.minimumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.monthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.monthsInYear": ('int',),
-    "PySide2.QtCore.QCalendar.name": (),
-    "PySide2.QtCore.QCalendar.partsFromDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.standaloneMonthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.standaloneWeekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.weekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-# class PySide2.QtCore.QCborArray:
-    "PySide2.QtCore.QCborArray.__init__": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborArray.__add__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__copy__": (),
-    "PySide2.QtCore.QCborArray.__iadd__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__lshift__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.append": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.at": ('int',),
-    "PySide2.QtCore.QCborArray.clear": (),
-    "PySide2.QtCore.QCborArray.compare": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.contains": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.empty": (),
-    "PySide2.QtCore.QCborArray.first": (),
-    "PySide2.QtCore.QCborArray.fromJsonArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QCborArray.fromStringList": ('typing.Sequence',),
-    "PySide2.QtCore.QCborArray.fromVariantList": ('typing.Sequence',),
-    "PySide2.QtCore.QCborArray.insert": ('int', 'PySide2.QtCore.QCborValue'),
-    "PySide2.QtCore.QCborArray.isEmpty": (),
-    "PySide2.QtCore.QCborArray.last": (),
-    "PySide2.QtCore.QCborArray.pop_back": (),
-    "PySide2.QtCore.QCborArray.pop_front": (),
-    "PySide2.QtCore.QCborArray.prepend": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_back": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_front": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.removeAt": ('int',),
-    "PySide2.QtCore.QCborArray.removeFirst": (),
-    "PySide2.QtCore.QCborArray.removeLast": (),
-    "PySide2.QtCore.QCborArray.size": (),
-    "PySide2.QtCore.QCborArray.swap": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.takeAt": ('int',),
-    "PySide2.QtCore.QCborArray.takeFirst": (),
-    "PySide2.QtCore.QCborArray.takeLast": (),
-    "PySide2.QtCore.QCborArray.toCborValue": (),
-    "PySide2.QtCore.QCborArray.toJsonArray": (),
-    "PySide2.QtCore.QCborArray.toVariantList": (),
-# class PySide2.QtCore.QCborError:
-# class PySide2.QtCore.QCborError.Code:
-    "PySide2.QtCore.QCborError.__init__": [(), ('PySide2.QtCore.QCborError',)],
-    "PySide2.QtCore.QCborError.__copy__": (),
-    "PySide2.QtCore.QCborError.toString": (),
-# class PySide2.QtCore.QCborKnownTags:
-# class PySide2.QtCore.QCborMap:
-    "PySide2.QtCore.QCborMap.__init__": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborMap.__copy__": (),
-    "PySide2.QtCore.QCborMap.clear": (),
-    "PySide2.QtCore.QCborMap.compare": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.contains": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.empty": (),
-    "PySide2.QtCore.QCborMap.fromJsonObject": ('typing.Dict',),
-    "PySide2.QtCore.QCborMap.fromVariantHash": ('typing.Dict',),
-    "PySide2.QtCore.QCborMap.fromVariantMap": ('typing.Dict',),
-    "PySide2.QtCore.QCborMap.isEmpty": (),
-    "PySide2.QtCore.QCborMap.keys": (),
-    "PySide2.QtCore.QCborMap.remove": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.size": (),
-    "PySide2.QtCore.QCborMap.swap": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.take": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.toCborValue": (),
-    "PySide2.QtCore.QCborMap.toJsonObject": (),
-    "PySide2.QtCore.QCborMap.toVariantHash": (),
-    "PySide2.QtCore.QCborMap.toVariantMap": (),
-    "PySide2.QtCore.QCborMap.value": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-# class PySide2.QtCore.QCborParserError:
-    "PySide2.QtCore.QCborParserError.__init__": [(), ('PySide2.QtCore.QCborParserError',)],
-    "PySide2.QtCore.QCborParserError.__copy__": (),
-    "PySide2.QtCore.QCborParserError.errorString": (),
-# class PySide2.QtCore.QCborSimpleType:
-# class PySide2.QtCore.QCborStreamReader:
-# class PySide2.QtCore.QCborStreamReader.StringResultCode:
-# class PySide2.QtCore.QCborStreamReader.Type:
-    "PySide2.QtCore.QCborStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytearray', 'int'), ('bytes', 'int')],
-    "PySide2.QtCore.QCborStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('bytearray', 'int'), ('bytes', 'int')],
-    "PySide2.QtCore.QCborStreamReader.clear": (),
-    "PySide2.QtCore.QCborStreamReader.containerDepth": (),
-    "PySide2.QtCore.QCborStreamReader.currentOffset": (),
-    "PySide2.QtCore.QCborStreamReader.currentStringChunkSize": (),
-    "PySide2.QtCore.QCborStreamReader.device": (),
-    "PySide2.QtCore.QCborStreamReader.enterContainer": (),
-    "PySide2.QtCore.QCborStreamReader.hasNext": (),
-    "PySide2.QtCore.QCborStreamReader.isArray": (),
-    "PySide2.QtCore.QCborStreamReader.isBool": (),
-    "PySide2.QtCore.QCborStreamReader.isByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.isContainer": (),
-    "PySide2.QtCore.QCborStreamReader.isDouble": (),
-    "PySide2.QtCore.QCborStreamReader.isFalse": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat16": (),
-    "PySide2.QtCore.QCborStreamReader.isInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isInvalid": (),
-    "PySide2.QtCore.QCborStreamReader.isLengthKnown": (),
-    "PySide2.QtCore.QCborStreamReader.isMap": (),
-    "PySide2.QtCore.QCborStreamReader.isNegativeInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isNull": (),
-    "PySide2.QtCore.QCborStreamReader.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborStreamReader.isString": (),
-    "PySide2.QtCore.QCborStreamReader.isTag": (),
-    "PySide2.QtCore.QCborStreamReader.isTrue": (),
-    "PySide2.QtCore.QCborStreamReader.isUndefined": (),
-    "PySide2.QtCore.QCborStreamReader.isUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isValid": (),
-    "PySide2.QtCore.QCborStreamReader.lastError": (),
-    "PySide2.QtCore.QCborStreamReader.leaveContainer": (),
-    "PySide2.QtCore.QCborStreamReader.length": (),
-    "PySide2.QtCore.QCborStreamReader.parentContainerType": (),
-    "PySide2.QtCore.QCborStreamReader.readByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.readString": (),
-    "PySide2.QtCore.QCborStreamReader.reparse": (),
-    "PySide2.QtCore.QCborStreamReader.reset": (),
-    "PySide2.QtCore.QCborStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamReader.toBool": (),
-    "PySide2.QtCore.QCborStreamReader.toDouble": (),
-    "PySide2.QtCore.QCborStreamReader.toFloat": (),
-    "PySide2.QtCore.QCborStreamReader.toInteger": (),
-    "PySide2.QtCore.QCborStreamReader.toSimpleType": (),
-    "PySide2.QtCore.QCborStreamReader.toUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.type": (),
-# class PySide2.QtCore.QCborStreamWriter:
-    "PySide2.QtCore.QCborStreamWriter.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QCborStreamWriter.append": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborKnownTags',), ('PySide2.QtCore.QCborSimpleType',), ('bool',), ('bytes', 'int'), ('float',), ('int',)],
-    "PySide2.QtCore.QCborStreamWriter.appendByteString": ('bytes', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendNull": (),
-    "PySide2.QtCore.QCborStreamWriter.appendTextString": ('bytes', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendUndefined": (),
-    "PySide2.QtCore.QCborStreamWriter.device": (),
-    "PySide2.QtCore.QCborStreamWriter.endArray": (),
-    "PySide2.QtCore.QCborStreamWriter.endMap": (),
-    "PySide2.QtCore.QCborStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamWriter.startArray": [(), ('int',)],
-    "PySide2.QtCore.QCborStreamWriter.startMap": [(), ('int',)],
-# class PySide2.QtCore.QCborStringResultByteArray:
-    "PySide2.QtCore.QCborStringResultByteArray.__init__": [(), ('PySide2.QtCore.QCborStringResultByteArray',)],
-    "PySide2.QtCore.QCborStringResultByteArray.__copy__": (),
-# class PySide2.QtCore.QCborStringResultString:
-    "PySide2.QtCore.QCborStringResultString.__init__": [(), ('PySide2.QtCore.QCborStringResultString',)],
-    "PySide2.QtCore.QCborStringResultString.__copy__": (),
-# class PySide2.QtCore.QCborValue:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOption:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOptions:
-# class PySide2.QtCore.QCborValue.EncodingOption:
-# class PySide2.QtCore.QCborValue.EncodingOptions:
-# class PySide2.QtCore.QCborValue.Type:
-    "PySide2.QtCore.QCborValue.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborKnownTags', 'PySide2.QtCore.QCborValue'), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborSimpleType',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QCborValue.Type',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('bool',), ('bytes',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborValue.__copy__": (),
-    "PySide2.QtCore.QCborValue.compare": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.fromCbor": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCborParserError'), ('PySide2.QtCore.QCborStreamReader',), ('bytearray', 'int', 'PySide2.QtCore.QCborParserError'), ('bytes', 'int', 'PySide2.QtCore.QCborParserError')],
-    "PySide2.QtCore.QCborValue.fromJsonValue": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QCborValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QCborValue.isArray": (),
-    "PySide2.QtCore.QCborValue.isBool": (),
-    "PySide2.QtCore.QCborValue.isByteArray": (),
-    "PySide2.QtCore.QCborValue.isContainer": (),
-    "PySide2.QtCore.QCborValue.isDateTime": (),
-    "PySide2.QtCore.QCborValue.isDouble": (),
-    "PySide2.QtCore.QCborValue.isFalse": (),
-    "PySide2.QtCore.QCborValue.isInteger": (),
-    "PySide2.QtCore.QCborValue.isInvalid": (),
-    "PySide2.QtCore.QCborValue.isMap": (),
-    "PySide2.QtCore.QCborValue.isNull": (),
-    "PySide2.QtCore.QCborValue.isRegularExpression": (),
-    "PySide2.QtCore.QCborValue.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborValue.isString": (),
-    "PySide2.QtCore.QCborValue.isTag": (),
-    "PySide2.QtCore.QCborValue.isTrue": (),
-    "PySide2.QtCore.QCborValue.isUndefined": (),
-    "PySide2.QtCore.QCborValue.isUrl": (),
-    "PySide2.QtCore.QCborValue.isUuid": (),
-    "PySide2.QtCore.QCborValue.swap": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.taggedValue": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.toArray": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborValue.toBool": ('bool',),
-    "PySide2.QtCore.QCborValue.toByteArray": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QCborValue.toCbor": [('PySide2.QtCore.QCborStreamWriter', 'PySide2.QtCore.QCborValue.EncodingOptions'), ('PySide2.QtCore.QCborValue.EncodingOptions',)],
-    "PySide2.QtCore.QCborValue.toDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QCborValue.toDiagnosticNotation": ('PySide2.QtCore.QCborValue.DiagnosticNotationOptions',),
-    "PySide2.QtCore.QCborValue.toDouble": ('float',),
-    "PySide2.QtCore.QCborValue.toInteger": ('int',),
-    "PySide2.QtCore.QCborValue.toJsonValue": (),
-    "PySide2.QtCore.QCborValue.toMap": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborValue.toRegularExpression": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QCborValue.toSimpleType": ('PySide2.QtCore.QCborSimpleType',),
-    "PySide2.QtCore.QCborValue.toString": ('str',),
-    "PySide2.QtCore.QCborValue.toUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QCborValue.toUuid": ('PySide2.QtCore.QUuid',),
-    "PySide2.QtCore.QCborValue.toVariant": (),
-    "PySide2.QtCore.QCborValue.type": (),
-# class PySide2.QtCore.QChildEvent:
-    "PySide2.QtCore.QChildEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QChildEvent.added": (),
-    "PySide2.QtCore.QChildEvent.child": (),
-    "PySide2.QtCore.QChildEvent.polished": (),
-    "PySide2.QtCore.QChildEvent.removed": (),
-# class PySide2.QtCore.QCollator:
-    "PySide2.QtCore.QCollator.__init__": [(), ('PySide2.QtCore.QCollator',), ('PySide2.QtCore.QLocale',)],
-    "PySide2.QtCore.QCollator.__call__": ('str', 'str'),
-    "PySide2.QtCore.QCollator.caseSensitivity": (),
-    "PySide2.QtCore.QCollator.compare": [('bytes', 'int', 'bytes', 'int'), ('str', 'str')],
-    "PySide2.QtCore.QCollator.ignorePunctuation": (),
-    "PySide2.QtCore.QCollator.locale": (),
-    "PySide2.QtCore.QCollator.numericMode": (),
-    "PySide2.QtCore.QCollator.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QCollator.setIgnorePunctuation": ('bool',),
-    "PySide2.QtCore.QCollator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QCollator.setNumericMode": ('bool',),
-    "PySide2.QtCore.QCollator.sortKey": ('str',),
-    "PySide2.QtCore.QCollator.swap": ('PySide2.QtCore.QCollator',),
-# class PySide2.QtCore.QCollatorSortKey:
-    "PySide2.QtCore.QCollatorSortKey.__init__": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.compare": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.swap": ('PySide2.QtCore.QCollatorSortKey',),
-# class PySide2.QtCore.QCommandLineOption:
-# class PySide2.QtCore.QCommandLineOption.Flag:
-# class PySide2.QtCore.QCommandLineOption.Flags:
-    "PySide2.QtCore.QCommandLineOption.__init__": [('PySide2.QtCore.QCommandLineOption',), ('str',), ('str', 'str', 'str', 'str'), ('typing.Sequence',), ('typing.Sequence', 'str', 'str', 'str')],
-    "PySide2.QtCore.QCommandLineOption.defaultValues": (),
-    "PySide2.QtCore.QCommandLineOption.description": (),
-    "PySide2.QtCore.QCommandLineOption.flags": (),
-    "PySide2.QtCore.QCommandLineOption.isHidden": (),
-    "PySide2.QtCore.QCommandLineOption.names": (),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValue": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValues": ('typing.Sequence',),
-    "PySide2.QtCore.QCommandLineOption.setDescription": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setFlags": ('PySide2.QtCore.QCommandLineOption.Flags',),
-    "PySide2.QtCore.QCommandLineOption.setHidden": ('bool',),
-    "PySide2.QtCore.QCommandLineOption.setValueName": ('str',),
-    "PySide2.QtCore.QCommandLineOption.swap": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineOption.valueName": (),
-# class PySide2.QtCore.QCommandLineParser:
-# class PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode:
-# class PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode:
-    "PySide2.QtCore.QCommandLineParser.__init__": (),
-    "PySide2.QtCore.QCommandLineParser.addHelpOption": (),
-    "PySide2.QtCore.QCommandLineParser.addOption": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineParser.addOptions": ('typing.Sequence',),
-    "PySide2.QtCore.QCommandLineParser.addPositionalArgument": ('str', 'str', 'str'),
-    "PySide2.QtCore.QCommandLineParser.addVersionOption": (),
-    "PySide2.QtCore.QCommandLineParser.applicationDescription": (),
-    "PySide2.QtCore.QCommandLineParser.clearPositionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.errorText": (),
-    "PySide2.QtCore.QCommandLineParser.helpText": (),
-    "PySide2.QtCore.QCommandLineParser.isSet": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.optionNames": (),
-    "PySide2.QtCore.QCommandLineParser.parse": ('typing.Sequence',),
-    "PySide2.QtCore.QCommandLineParser.positionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.process": [('PySide2.QtCore.QCoreApplication',), ('typing.Sequence',)],
-    "PySide2.QtCore.QCommandLineParser.setApplicationDescription": ('str',),
-    "PySide2.QtCore.QCommandLineParser.setOptionsAfterPositionalArgumentsMode": ('PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode',),
-    "PySide2.QtCore.QCommandLineParser.setSingleDashWordOptionMode": ('PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode',),
-    "PySide2.QtCore.QCommandLineParser.showHelp": ('int',),
-    "PySide2.QtCore.QCommandLineParser.showVersion": (),
-    "PySide2.QtCore.QCommandLineParser.unknownOptionNames": (),
-    "PySide2.QtCore.QCommandLineParser.value": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.values": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-# class PySide2.QtCore.QConcatenateTablesProxyModel:
-    "PySide2.QtCore.QConcatenateTablesProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.addSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeData": ('typing.List',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QConcatenateTablesProxyModel.removeSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QCoreApplication:
-    "PySide2.QtCore.QCoreApplication.__init__": [(), ('typing.Sequence',)],
-    "PySide2.QtCore.QCoreApplication.addLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.applicationDirPath": (),
-    "PySide2.QtCore.QCoreApplication.applicationFilePath": (),
-    "PySide2.QtCore.QCoreApplication.applicationName": (),
-    "PySide2.QtCore.QCoreApplication.applicationPid": (),
-    "PySide2.QtCore.QCoreApplication.applicationVersion": (),
-    "PySide2.QtCore.QCoreApplication.arguments": (),
-    "PySide2.QtCore.QCoreApplication.closingDown": (),
-    "PySide2.QtCore.QCoreApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QCoreApplication.eventDispatcher": (),
-    "PySide2.QtCore.QCoreApplication.exec_": (),
-    "PySide2.QtCore.QCoreApplication.exit": ('int',),
-    "PySide2.QtCore.QCoreApplication.flush": (),
-    "PySide2.QtCore.QCoreApplication.hasPendingEvents": (),
-    "PySide2.QtCore.QCoreApplication.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.installTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.instance": (),
-    "PySide2.QtCore.QCoreApplication.isQuitLockEnabled": (),
-    "PySide2.QtCore.QCoreApplication.isSetuidAllowed": (),
-    "PySide2.QtCore.QCoreApplication.libraryPaths": (),
-    "PySide2.QtCore.QCoreApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.organizationDomain": (),
-    "PySide2.QtCore.QCoreApplication.organizationName": (),
-    "PySide2.QtCore.QCoreApplication.postEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QCoreApplication.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QCoreApplication.quit": (),
-    "PySide2.QtCore.QCoreApplication.removeLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.removePostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.removeTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.sendEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.sendPostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.setApplicationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setApplicationVersion": ('str',),
-    "PySide2.QtCore.QCoreApplication.setAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute', 'bool'),
-    "PySide2.QtCore.QCoreApplication.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QCoreApplication.setLibraryPaths": ('typing.Sequence',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationDomain": ('str',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setQuitLockEnabled": ('bool',),
-    "PySide2.QtCore.QCoreApplication.setSetuidAllowed": ('bool',),
-    "PySide2.QtCore.QCoreApplication.shutdown": (),
-    "PySide2.QtCore.QCoreApplication.startingUp": (),
-    "PySide2.QtCore.QCoreApplication.testAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute',),
-    "PySide2.QtCore.QCoreApplication.translate": ('bytes', 'bytes', 'bytes', 'int'),
-# class PySide2.QtCore.QCryptographicHash:
-# class PySide2.QtCore.QCryptographicHash.Algorithm:
-    "PySide2.QtCore.QCryptographicHash.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytes', 'int')],
-    "PySide2.QtCore.QCryptographicHash.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QCryptographicHash.hashLength": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.reset": (),
-    "PySide2.QtCore.QCryptographicHash.result": (),
-# class PySide2.QtCore.QDataStream:
-# class PySide2.QtCore.QDataStream.ByteOrder:
-# class PySide2.QtCore.QDataStream.FloatingPointPrecision:
-# class PySide2.QtCore.QDataStream.Status:
-# class PySide2.QtCore.QDataStream.Version:
-    "PySide2.QtCore.QDataStream.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QDataStream.__lshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',), ('str',)],
-    "PySide2.QtCore.QDataStream.__rshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',)],
-    "PySide2.QtCore.QDataStream.abortTransaction": (),
-    "PySide2.QtCore.QDataStream.atEnd": (),
-    "PySide2.QtCore.QDataStream.byteOrder": (),
-    "PySide2.QtCore.QDataStream.commitTransaction": (),
-    "PySide2.QtCore.QDataStream.device": (),
-    "PySide2.QtCore.QDataStream.floatingPointPrecision": (),
-    "PySide2.QtCore.QDataStream.readBool": (),
-    "PySide2.QtCore.QDataStream.readDouble": (),
-    "PySide2.QtCore.QDataStream.readFloat": (),
-    "PySide2.QtCore.QDataStream.readInt16": (),
-    "PySide2.QtCore.QDataStream.readInt32": (),
-    "PySide2.QtCore.QDataStream.readInt64": (),
-    "PySide2.QtCore.QDataStream.readInt8": (),
-    "PySide2.QtCore.QDataStream.readQChar": (),
-    "PySide2.QtCore.QDataStream.readQString": (),
-    "PySide2.QtCore.QDataStream.readQStringList": (),
-    "PySide2.QtCore.QDataStream.readQVariant": (),
-    "PySide2.QtCore.QDataStream.readRawData": ('bytes', 'int'),
-    "PySide2.QtCore.QDataStream.readString": (),
-    "PySide2.QtCore.QDataStream.readUInt16": (),
-    "PySide2.QtCore.QDataStream.readUInt32": (),
-    "PySide2.QtCore.QDataStream.readUInt64": (),
-    "PySide2.QtCore.QDataStream.readUInt8": (),
-    "PySide2.QtCore.QDataStream.resetStatus": (),
-    "PySide2.QtCore.QDataStream.rollbackTransaction": (),
-    "PySide2.QtCore.QDataStream.setByteOrder": ('PySide2.QtCore.QDataStream.ByteOrder',),
-    "PySide2.QtCore.QDataStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QDataStream.setFloatingPointPrecision": ('PySide2.QtCore.QDataStream.FloatingPointPrecision',),
-    "PySide2.QtCore.QDataStream.setStatus": ('PySide2.QtCore.QDataStream.Status',),
-    "PySide2.QtCore.QDataStream.setVersion": ('int',),
-    "PySide2.QtCore.QDataStream.skipRawData": ('int',),
-    "PySide2.QtCore.QDataStream.startTransaction": (),
-    "PySide2.QtCore.QDataStream.status": (),
-    "PySide2.QtCore.QDataStream.unsetDevice": (),
-    "PySide2.QtCore.QDataStream.version": (),
-    "PySide2.QtCore.QDataStream.writeBool": ('bool',),
-    "PySide2.QtCore.QDataStream.writeDouble": ('float',),
-    "PySide2.QtCore.QDataStream.writeFloat": ('float',),
-    "PySide2.QtCore.QDataStream.writeInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt8": ('int',),
-    "PySide2.QtCore.QDataStream.writeQChar": ('str',),
-    "PySide2.QtCore.QDataStream.writeQString": ('str',),
-    "PySide2.QtCore.QDataStream.writeQStringList": ('typing.Sequence',),
-    "PySide2.QtCore.QDataStream.writeQVariant": ('typing.Any',),
-    "PySide2.QtCore.QDataStream.writeRawData": ('bytes', 'int'),
-    "PySide2.QtCore.QDataStream.writeString": ('str',),
-    "PySide2.QtCore.QDataStream.writeUInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt8": ('int',),
-# class PySide2.QtCore.QDate:
-# class PySide2.QtCore.QDate.MonthNameType:
-    "PySide2.QtCore.QDate.__init__": [(), ('PySide2.QtCore.QDate',), ('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.__copy__": (),
-    "PySide2.QtCore.QDate.__reduce__": (),
-    "PySide2.QtCore.QDate.__repr__": (),
-    "PySide2.QtCore.QDate.addDays": ('int',),
-    "PySide2.QtCore.QDate.addMonths": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.addYears": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.currentDate": (),
-    "PySide2.QtCore.QDate.day": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfWeek": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInMonth": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysTo": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDate.endOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.fromJulianDay": ('int',),
-    "PySide2.QtCore.QDate.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.getDate": (),
-    "PySide2.QtCore.QDate.isLeapYear": ('int',),
-    "PySide2.QtCore.QDate.isNull": (),
-    "PySide2.QtCore.QDate.isValid": [(), ('int', 'int', 'int')],
-    "PySide2.QtCore.QDate.longDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.longMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.month": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.setDate": [('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.shortDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.shortMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.startOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.toJulianDay": (),
-    "PySide2.QtCore.QDate.toPython": (),
-    "PySide2.QtCore.QDate.toString": [('PySide2.QtCore.Qt.DateFormat',), ('PySide2.QtCore.Qt.DateFormat', 'PySide2.QtCore.QCalendar'), ('str',), ('str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.weekNumber": (),
-    "PySide2.QtCore.QDate.year": [(), ('PySide2.QtCore.QCalendar',)],
-# class PySide2.QtCore.QDateTime:
-# class PySide2.QtCore.QDateTime.YearRange:
-    "PySide2.QtCore.QDateTime.__init__": [(), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.QTimeZone'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec', 'int'), ('PySide2.QtCore.QDateTime',), ('int', 'int', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QDateTime.__copy__": (),
-    "PySide2.QtCore.QDateTime.__reduce__": (),
-    "PySide2.QtCore.QDateTime.__repr__": (),
-    "PySide2.QtCore.QDateTime.addDays": ('int',),
-    "PySide2.QtCore.QDateTime.addMSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addMonths": ('int',),
-    "PySide2.QtCore.QDateTime.addSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addYears": ('int',),
-    "PySide2.QtCore.QDateTime.currentDateTime": (),
-    "PySide2.QtCore.QDateTime.currentDateTimeUtc": (),
-    "PySide2.QtCore.QDateTime.currentMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.currentSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.date": (),
-    "PySide2.QtCore.QDateTime.daysTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.fromMSecsSinceEpoch": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromSecsSinceEpoch": [('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDateTime.fromTime_t": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.isDaylightTime": (),
-    "PySide2.QtCore.QDateTime.isNull": (),
-    "PySide2.QtCore.QDateTime.isValid": (),
-    "PySide2.QtCore.QDateTime.msecsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.offsetFromUtc": (),
-    "PySide2.QtCore.QDateTime.secsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDateTime.setMSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.setSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QDateTime.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.setTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.setTime_t": ('int',),
-    "PySide2.QtCore.QDateTime.setUtcOffset": ('int',),
-    "PySide2.QtCore.QDateTime.swap": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.time": (),
-    "PySide2.QtCore.QDateTime.timeSpec": (),
-    "PySide2.QtCore.QDateTime.timeZone": (),
-    "PySide2.QtCore.QDateTime.timeZoneAbbreviation": (),
-    "PySide2.QtCore.QDateTime.toLocalTime": (),
-    "PySide2.QtCore.QDateTime.toMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.toPython": (),
-    "PySide2.QtCore.QDateTime.toSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-    "PySide2.QtCore.QDateTime.toTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.toTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.toTime_t": (),
-    "PySide2.QtCore.QDateTime.toUTC": (),
-    "PySide2.QtCore.QDateTime.utcOffset": (),
-# class PySide2.QtCore.QDeadlineTimer:
-# class PySide2.QtCore.QDeadlineTimer.ForeverConstant:
-    "PySide2.QtCore.QDeadlineTimer.__init__": [('PySide2.QtCore.QDeadlineTimer',), ('PySide2.QtCore.QDeadlineTimer.ForeverConstant', 'PySide2.QtCore.Qt.TimerType'), ('PySide2.QtCore.Qt.TimerType',), ('int', 'PySide2.QtCore.Qt.TimerType')],
-    "PySide2.QtCore.QDeadlineTimer.__copy__": (),
-    "PySide2.QtCore.QDeadlineTimer.__iadd__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer.__isub__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer._q_data": (),
-    "PySide2.QtCore.QDeadlineTimer.addNSecs": ('PySide2.QtCore.QDeadlineTimer', 'int'),
-    "PySide2.QtCore.QDeadlineTimer.current": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.deadline": (),
-    "PySide2.QtCore.QDeadlineTimer.deadlineNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.hasExpired": (),
-    "PySide2.QtCore.QDeadlineTimer.isForever": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTime": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTimeNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.setDeadline": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseDeadline": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseRemainingTime": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setRemainingTime": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.swap": ('PySide2.QtCore.QDeadlineTimer',),
-    "PySide2.QtCore.QDeadlineTimer.timerType": (),
-# class PySide2.QtCore.QDir:
-# class PySide2.QtCore.QDir.Filter:
-# class PySide2.QtCore.QDir.Filters:
-# class PySide2.QtCore.QDir.SortFlag:
-# class PySide2.QtCore.QDir.SortFlags:
-    "PySide2.QtCore.QDir.__init__": [('PySide2.QtCore.QDir',), ('str',), ('str', 'str', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QDir.Filters')],
-    "PySide2.QtCore.QDir.__copy__": (),
-    "PySide2.QtCore.QDir.__reduce__": (),
-    "PySide2.QtCore.QDir.absoluteFilePath": ('str',),
-    "PySide2.QtCore.QDir.absolutePath": (),
-    "PySide2.QtCore.QDir.addResourceSearchPath": ('str',),
-    "PySide2.QtCore.QDir.addSearchPath": ('str', 'str'),
-    "PySide2.QtCore.QDir.canonicalPath": (),
-    "PySide2.QtCore.QDir.cd": ('str',),
-    "PySide2.QtCore.QDir.cdUp": (),
-    "PySide2.QtCore.QDir.cleanPath": ('str',),
-    "PySide2.QtCore.QDir.count": (),
-    "PySide2.QtCore.QDir.current": (),
-    "PySide2.QtCore.QDir.currentPath": (),
-    "PySide2.QtCore.QDir.dirName": (),
-    "PySide2.QtCore.QDir.drives": (),
-    "PySide2.QtCore.QDir.entryInfoList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.entryList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.exists": [(), ('str',)],
-    "PySide2.QtCore.QDir.filePath": ('str',),
-    "PySide2.QtCore.QDir.filter": (),
-    "PySide2.QtCore.QDir.fromNativeSeparators": ('str',),
-    "PySide2.QtCore.QDir.home": (),
-    "PySide2.QtCore.QDir.homePath": (),
-    "PySide2.QtCore.QDir.isAbsolute": (),
-    "PySide2.QtCore.QDir.isAbsolutePath": ('str',),
-    "PySide2.QtCore.QDir.isEmpty": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.isReadable": (),
-    "PySide2.QtCore.QDir.isRelative": (),
-    "PySide2.QtCore.QDir.isRelativePath": ('str',),
-    "PySide2.QtCore.QDir.isRoot": (),
-    "PySide2.QtCore.QDir.listSeparator": (),
-    "PySide2.QtCore.QDir.makeAbsolute": (),
-    "PySide2.QtCore.QDir.match": [('str', 'str'), ('typing.Sequence', 'str')],
-    "PySide2.QtCore.QDir.mkdir": ('str',),
-    "PySide2.QtCore.QDir.mkpath": ('str',),
-    "PySide2.QtCore.QDir.nameFilters": (),
-    "PySide2.QtCore.QDir.nameFiltersFromString": ('str',),
-    "PySide2.QtCore.QDir.path": (),
-    "PySide2.QtCore.QDir.refresh": (),
-    "PySide2.QtCore.QDir.relativeFilePath": ('str',),
-    "PySide2.QtCore.QDir.remove": ('str',),
-    "PySide2.QtCore.QDir.removeRecursively": (),
-    "PySide2.QtCore.QDir.rename": ('str', 'str'),
-    "PySide2.QtCore.QDir.rmdir": ('str',),
-    "PySide2.QtCore.QDir.rmpath": ('str',),
-    "PySide2.QtCore.QDir.root": (),
-    "PySide2.QtCore.QDir.rootPath": (),
-    "PySide2.QtCore.QDir.searchPaths": ('str',),
-    "PySide2.QtCore.QDir.separator": (),
-    "PySide2.QtCore.QDir.setCurrent": ('str',),
-    "PySide2.QtCore.QDir.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.setNameFilters": ('typing.Sequence',),
-    "PySide2.QtCore.QDir.setPath": ('str',),
-    "PySide2.QtCore.QDir.setSearchPaths": ('str', 'typing.Sequence'),
-    "PySide2.QtCore.QDir.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtCore.QDir.sorting": (),
-    "PySide2.QtCore.QDir.swap": ('PySide2.QtCore.QDir',),
-    "PySide2.QtCore.QDir.temp": (),
-    "PySide2.QtCore.QDir.tempPath": (),
-    "PySide2.QtCore.QDir.toNativeSeparators": ('str',),
-# class PySide2.QtCore.QDirIterator:
-# class PySide2.QtCore.QDirIterator.IteratorFlag:
-# class PySide2.QtCore.QDirIterator.IteratorFlags:
-    "PySide2.QtCore.QDirIterator.__init__": [('PySide2.QtCore.QDir', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'typing.Sequence', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags')],
-    "PySide2.QtCore.QDirIterator.fileInfo": (),
-    "PySide2.QtCore.QDirIterator.fileName": (),
-    "PySide2.QtCore.QDirIterator.filePath": (),
-    "PySide2.QtCore.QDirIterator.hasNext": (),
-    "PySide2.QtCore.QDirIterator.path": (),
-# class PySide2.QtCore.QDynamicPropertyChangeEvent:
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.__init__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.propertyName": (),
-# class PySide2.QtCore.QEasingCurve:
-# class PySide2.QtCore.QEasingCurve.Type:
-    "PySide2.QtCore.QEasingCurve.__init__": [('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QEasingCurve.Type',)],
-    "PySide2.QtCore.QEasingCurve.__copy__": (),
-    "PySide2.QtCore.QEasingCurve.addCubicBezierSegment": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QEasingCurve.addTCBSegment": ('PySide2.QtCore.QPointF', 'float', 'float', 'float'),
-    "PySide2.QtCore.QEasingCurve.amplitude": (),
-    "PySide2.QtCore.QEasingCurve.customType": (),
-    "PySide2.QtCore.QEasingCurve.overshoot": (),
-    "PySide2.QtCore.QEasingCurve.period": (),
-    "PySide2.QtCore.QEasingCurve.setAmplitude": ('float',),
-    "PySide2.QtCore.QEasingCurve.setCustomType": ('object',),
-    "PySide2.QtCore.QEasingCurve.setOvershoot": ('float',),
-    "PySide2.QtCore.QEasingCurve.setPeriod": ('float',),
-    "PySide2.QtCore.QEasingCurve.setType": ('PySide2.QtCore.QEasingCurve.Type',),
-    "PySide2.QtCore.QEasingCurve.swap": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QEasingCurve.toCubicSpline": (),
-    "PySide2.QtCore.QEasingCurve.type": (),
-    "PySide2.QtCore.QEasingCurve.valueForProgress": ('float',),
-# class PySide2.QtCore.QElapsedTimer:
-# class PySide2.QtCore.QElapsedTimer.ClockType:
-    "PySide2.QtCore.QElapsedTimer.__init__": [(), ('PySide2.QtCore.QElapsedTimer',)],
-    "PySide2.QtCore.QElapsedTimer.__copy__": (),
-    "PySide2.QtCore.QElapsedTimer.clockType": (),
-    "PySide2.QtCore.QElapsedTimer.elapsed": (),
-    "PySide2.QtCore.QElapsedTimer.hasExpired": ('int',),
-    "PySide2.QtCore.QElapsedTimer.invalidate": (),
-    "PySide2.QtCore.QElapsedTimer.isMonotonic": (),
-    "PySide2.QtCore.QElapsedTimer.isValid": (),
-    "PySide2.QtCore.QElapsedTimer.msecsSinceReference": (),
-    "PySide2.QtCore.QElapsedTimer.msecsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.nsecsElapsed": (),
-    "PySide2.QtCore.QElapsedTimer.restart": (),
-    "PySide2.QtCore.QElapsedTimer.secsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.start": (),
-# class PySide2.QtCore.QEvent:
-# class PySide2.QtCore.QEvent.Type:
-    "PySide2.QtCore.QEvent.__init__": [('PySide2.QtCore.QEvent',), ('PySide2.QtCore.QEvent.Type',)],
-    "PySide2.QtCore.QEvent.accept": (),
-    "PySide2.QtCore.QEvent.ignore": (),
-    "PySide2.QtCore.QEvent.isAccepted": (),
-    "PySide2.QtCore.QEvent.registerEventType": ('int',),
-    "PySide2.QtCore.QEvent.setAccepted": ('bool',),
-    "PySide2.QtCore.QEvent.spontaneous": (),
-    "PySide2.QtCore.QEvent.type": (),
-# class PySide2.QtCore.QEventLoop:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlag:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlags:
-    "PySide2.QtCore.QEventLoop.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventLoop.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventLoop.exec_": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QEventLoop.exit": ('int',),
-    "PySide2.QtCore.QEventLoop.isRunning": (),
-    "PySide2.QtCore.QEventLoop.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QEventLoop.quit": (),
-    "PySide2.QtCore.QEventLoop.wakeUp": (),
-# class PySide2.QtCore.QEventTransition:
-    "PySide2.QtCore.QEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QEventTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventSource": (),
-    "PySide2.QtCore.QEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventType": (),
-    "PySide2.QtCore.QEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.setEventSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventTransition.setEventType": ('PySide2.QtCore.QEvent.Type',),
-# class PySide2.QtCore.QFactoryInterface:
-    "PySide2.QtCore.QFactoryInterface.__init__": (),
-    "PySide2.QtCore.QFactoryInterface.keys": (),
-# class PySide2.QtCore.QFile:
-    "PySide2.QtCore.QFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFile.copy": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.decodeName": [('PySide2.QtCore.QByteArray',), ('bytes',)],
-    "PySide2.QtCore.QFile.encodeName": ('str',),
-    "PySide2.QtCore.QFile.exists": [(), ('str',)],
-    "PySide2.QtCore.QFile.fileName": (),
-    "PySide2.QtCore.QFile.link": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.open": [('PySide2.QtCore.QIODevice.OpenMode',), ('int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtCore.QFileDevice.FileHandleFlags')],
-    "PySide2.QtCore.QFile.permissions": [(), ('str',)],
-    "PySide2.QtCore.QFile.readLink": [(), ('str',)],
-    "PySide2.QtCore.QFile.remove": [(), ('str',)],
-    "PySide2.QtCore.QFile.rename": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.resize": [('int',), ('str', 'int')],
-    "PySide2.QtCore.QFile.setFileName": ('str',),
-    "PySide2.QtCore.QFile.setPermissions": [('PySide2.QtCore.QFileDevice.Permissions',), ('str', 'PySide2.QtCore.QFileDevice.Permissions')],
-    "PySide2.QtCore.QFile.size": (),
-    "PySide2.QtCore.QFile.symLinkTarget": [(), ('str',)],
-# class PySide2.QtCore.QFileDevice:
-# class PySide2.QtCore.QFileDevice.FileError:
-# class PySide2.QtCore.QFileDevice.FileHandleFlag:
-# class PySide2.QtCore.QFileDevice.FileHandleFlags:
-# class PySide2.QtCore.QFileDevice.FileTime:
-# class PySide2.QtCore.QFileDevice.MemoryMapFlags:
-# class PySide2.QtCore.QFileDevice.Permission:
-# class PySide2.QtCore.QFileDevice.Permissions:
-    "PySide2.QtCore.QFileDevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QFileDevice.atEnd": (),
-    "PySide2.QtCore.QFileDevice.close": (),
-    "PySide2.QtCore.QFileDevice.error": (),
-    "PySide2.QtCore.QFileDevice.fileName": (),
-    "PySide2.QtCore.QFileDevice.fileTime": ('PySide2.QtCore.QFileDevice.FileTime',),
-    "PySide2.QtCore.QFileDevice.flush": (),
-    "PySide2.QtCore.QFileDevice.handle": (),
-    "PySide2.QtCore.QFileDevice.isSequential": (),
-    "PySide2.QtCore.QFileDevice.map": ('int', 'int', 'PySide2.QtCore.QFileDevice.MemoryMapFlags'),
-    "PySide2.QtCore.QFileDevice.permissions": (),
-    "PySide2.QtCore.QFileDevice.pos": (),
-    "PySide2.QtCore.QFileDevice.readData": ('bytes', 'int'),
-    "PySide2.QtCore.QFileDevice.readLineData": ('bytes', 'int'),
-    "PySide2.QtCore.QFileDevice.resize": ('int',),
-    "PySide2.QtCore.QFileDevice.seek": ('int',),
-    "PySide2.QtCore.QFileDevice.setFileTime": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QFileDevice.FileTime'),
-    "PySide2.QtCore.QFileDevice.setPermissions": ('PySide2.QtCore.QFileDevice.Permissions',),
-    "PySide2.QtCore.QFileDevice.size": (),
-    "PySide2.QtCore.QFileDevice.unmap": ('bytes',),
-    "PySide2.QtCore.QFileDevice.unsetError": (),
-    "PySide2.QtCore.QFileDevice.writeData": ('bytes', 'int'),
-# class PySide2.QtCore.QFileInfo:
-    "PySide2.QtCore.QFileInfo.__init__": [(), ('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('PySide2.QtCore.QFileInfo',), ('str',)],
-    "PySide2.QtCore.QFileInfo.__copy__": (),
-    "PySide2.QtCore.QFileInfo.__reduce__": (),
-    "PySide2.QtCore.QFileInfo.absoluteDir": (),
-    "PySide2.QtCore.QFileInfo.absoluteFilePath": (),
-    "PySide2.QtCore.QFileInfo.absolutePath": (),
-    "PySide2.QtCore.QFileInfo.baseName": (),
-    "PySide2.QtCore.QFileInfo.birthTime": (),
-    "PySide2.QtCore.QFileInfo.bundleName": (),
-    "PySide2.QtCore.QFileInfo.caching": (),
-    "PySide2.QtCore.QFileInfo.canonicalFilePath": (),
-    "PySide2.QtCore.QFileInfo.canonicalPath": (),
-    "PySide2.QtCore.QFileInfo.completeBaseName": (),
-    "PySide2.QtCore.QFileInfo.completeSuffix": (),
-    "PySide2.QtCore.QFileInfo.created": (),
-    "PySide2.QtCore.QFileInfo.dir": (),
-    "PySide2.QtCore.QFileInfo.exists": [(), ('str',)],
-    "PySide2.QtCore.QFileInfo.fileName": (),
-    "PySide2.QtCore.QFileInfo.filePath": (),
-    "PySide2.QtCore.QFileInfo.group": (),
-    "PySide2.QtCore.QFileInfo.groupId": (),
-    "PySide2.QtCore.QFileInfo.isAbsolute": (),
-    "PySide2.QtCore.QFileInfo.isBundle": (),
-    "PySide2.QtCore.QFileInfo.isDir": (),
-    "PySide2.QtCore.QFileInfo.isExecutable": (),
-    "PySide2.QtCore.QFileInfo.isFile": (),
-    "PySide2.QtCore.QFileInfo.isHidden": (),
-    "PySide2.QtCore.QFileInfo.isNativePath": (),
-    "PySide2.QtCore.QFileInfo.isReadable": (),
-    "PySide2.QtCore.QFileInfo.isRelative": (),
-    "PySide2.QtCore.QFileInfo.isRoot": (),
-    "PySide2.QtCore.QFileInfo.isShortcut": (),
-    "PySide2.QtCore.QFileInfo.isSymLink": (),
-    "PySide2.QtCore.QFileInfo.isSymbolicLink": (),
-    "PySide2.QtCore.QFileInfo.isWritable": (),
-    "PySide2.QtCore.QFileInfo.lastModified": (),
-    "PySide2.QtCore.QFileInfo.lastRead": (),
-    "PySide2.QtCore.QFileInfo.makeAbsolute": (),
-    "PySide2.QtCore.QFileInfo.metadataChangeTime": (),
-    "PySide2.QtCore.QFileInfo.owner": (),
-    "PySide2.QtCore.QFileInfo.ownerId": (),
-    "PySide2.QtCore.QFileInfo.path": (),
-    "PySide2.QtCore.QFileInfo.readLink": (),
-    "PySide2.QtCore.QFileInfo.refresh": (),
-    "PySide2.QtCore.QFileInfo.setCaching": ('bool',),
-    "PySide2.QtCore.QFileInfo.setFile": [('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QFileInfo.size": (),
-    "PySide2.QtCore.QFileInfo.suffix": (),
-    "PySide2.QtCore.QFileInfo.swap": ('PySide2.QtCore.QFileInfo',),
-    "PySide2.QtCore.QFileInfo.symLinkTarget": (),
-# class PySide2.QtCore.QFileSelector:
-    "PySide2.QtCore.QFileSelector.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QFileSelector.allSelectors": (),
-    "PySide2.QtCore.QFileSelector.extraSelectors": (),
-    "PySide2.QtCore.QFileSelector.select": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtCore.QFileSelector.setExtraSelectors": ('typing.Sequence',),
-# class PySide2.QtCore.QFileSystemWatcher:
-    "PySide2.QtCore.QFileSystemWatcher.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFileSystemWatcher.addPath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.addPaths": ('typing.Sequence',),
-    "PySide2.QtCore.QFileSystemWatcher.directories": (),
-    "PySide2.QtCore.QFileSystemWatcher.files": (),
-    "PySide2.QtCore.QFileSystemWatcher.removePath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.removePaths": ('typing.Sequence',),
-# class PySide2.QtCore.QFinalState:
-    "PySide2.QtCore.QFinalState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QFinalState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onExit": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtCore.QGenericArgument:
-    "PySide2.QtCore.QGenericArgument.__init__": [('PySide2.QtCore.QGenericArgument',), ('bytes', 'int')],
-    "PySide2.QtCore.QGenericArgument.__copy__": (),
-    "PySide2.QtCore.QGenericArgument.data": (),
-    "PySide2.QtCore.QGenericArgument.name": (),
-# class PySide2.QtCore.QGenericReturnArgument:
-    "PySide2.QtCore.QGenericReturnArgument.__init__": [('PySide2.QtCore.QGenericReturnArgument',), ('bytes', 'int')],
-    "PySide2.QtCore.QGenericReturnArgument.__copy__": (),
-# class PySide2.QtCore.QHistoryState:
-# class PySide2.QtCore.QHistoryState.HistoryType:
-    "PySide2.QtCore.QHistoryState.__init__": [('PySide2.QtCore.QHistoryState.HistoryType', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QHistoryState.defaultState": (),
-    "PySide2.QtCore.QHistoryState.defaultTransition": (),
-    "PySide2.QtCore.QHistoryState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.historyType": (),
-    "PySide2.QtCore.QHistoryState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.setDefaultState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QHistoryState.setDefaultTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QHistoryState.setHistoryType": ('PySide2.QtCore.QHistoryState.HistoryType',),
-# class PySide2.QtCore.QIODevice:
-# class PySide2.QtCore.QIODevice.OpenMode:
-# class PySide2.QtCore.QIODevice.OpenModeFlag:
-    "PySide2.QtCore.QIODevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QIODevice.atEnd": (),
-    "PySide2.QtCore.QIODevice.bytesAvailable": (),
-    "PySide2.QtCore.QIODevice.bytesToWrite": (),
-    "PySide2.QtCore.QIODevice.canReadLine": (),
-    "PySide2.QtCore.QIODevice.close": (),
-    "PySide2.QtCore.QIODevice.commitTransaction": (),
-    "PySide2.QtCore.QIODevice.currentReadChannel": (),
-    "PySide2.QtCore.QIODevice.currentWriteChannel": (),
-    "PySide2.QtCore.QIODevice.errorString": (),
-    "PySide2.QtCore.QIODevice.getChar": ('bytes',),
-    "PySide2.QtCore.QIODevice.isOpen": (),
-    "PySide2.QtCore.QIODevice.isReadable": (),
-    "PySide2.QtCore.QIODevice.isSequential": (),
-    "PySide2.QtCore.QIODevice.isTextModeEnabled": (),
-    "PySide2.QtCore.QIODevice.isTransactionStarted": (),
-    "PySide2.QtCore.QIODevice.isWritable": (),
-    "PySide2.QtCore.QIODevice.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.openMode": (),
-    "PySide2.QtCore.QIODevice.peek": ('int',),
-    "PySide2.QtCore.QIODevice.pos": (),
-    "PySide2.QtCore.QIODevice.putChar": ('int',),
-    "PySide2.QtCore.QIODevice.read": ('int',),
-    "PySide2.QtCore.QIODevice.readAll": (),
-    "PySide2.QtCore.QIODevice.readChannelCount": (),
-    "PySide2.QtCore.QIODevice.readData": ('bytes', 'int'),
-    "PySide2.QtCore.QIODevice.readLine": ('int',),
-    "PySide2.QtCore.QIODevice.readLineData": ('bytes', 'int'),
-    "PySide2.QtCore.QIODevice.reset": (),
-    "PySide2.QtCore.QIODevice.rollbackTransaction": (),
-    "PySide2.QtCore.QIODevice.seek": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentReadChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentWriteChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setErrorString": ('str',),
-    "PySide2.QtCore.QIODevice.setOpenMode": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.setTextModeEnabled": ('bool',),
-    "PySide2.QtCore.QIODevice.size": (),
-    "PySide2.QtCore.QIODevice.skip": ('int',),
-    "PySide2.QtCore.QIODevice.startTransaction": (),
-    "PySide2.QtCore.QIODevice.ungetChar": ('int',),
-    "PySide2.QtCore.QIODevice.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QIODevice.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QIODevice.write": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QIODevice.writeChannelCount": (),
-    "PySide2.QtCore.QIODevice.writeData": ('bytes', 'int'),
-# class PySide2.QtCore.QIdentityProxyModel:
-    "PySide2.QtCore.QIdentityProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QIdentityProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QIdentityProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QIdentityProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QIdentityProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QIdentityProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QItemSelection:
-    "PySide2.QtCore.QItemSelection.__init__": [(), ('PySide2.QtCore.QItemSelection',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelection.__add__": ('typing.Sequence',),
-    "PySide2.QtCore.QItemSelection.__copy__": (),
-    "PySide2.QtCore.QItemSelection.__iadd__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence',)],
-    "PySide2.QtCore.QItemSelection.__lshift__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence',)],
-    "PySide2.QtCore.QItemSelection.append": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence',)],
-    "PySide2.QtCore.QItemSelection.at": ('int',),
-    "PySide2.QtCore.QItemSelection.back": (),
-    "PySide2.QtCore.QItemSelection.clear": (),
-    "PySide2.QtCore.QItemSelection.constFirst": (),
-    "PySide2.QtCore.QItemSelection.constLast": (),
-    "PySide2.QtCore.QItemSelection.contains": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelection.count": [(), ('PySide2.QtCore.QItemSelectionRange',)],
-    "PySide2.QtCore.QItemSelection.detachShared": (),
-    "PySide2.QtCore.QItemSelection.empty": (),
-    "PySide2.QtCore.QItemSelection.endsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.first": (),
-    "PySide2.QtCore.QItemSelection.fromSet": ('typing.Set',),
-    "PySide2.QtCore.QItemSelection.fromVector": ('typing.List',),
-    "PySide2.QtCore.QItemSelection.front": (),
-    "PySide2.QtCore.QItemSelection.indexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.indexes": (),
-    "PySide2.QtCore.QItemSelection.insert": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.isEmpty": (),
-    "PySide2.QtCore.QItemSelection.isSharedWith": ('typing.Sequence',),
-    "PySide2.QtCore.QItemSelection.last": (),
-    "PySide2.QtCore.QItemSelection.lastIndexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.length": (),
-    "PySide2.QtCore.QItemSelection.merge": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelection.mid": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.move": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.pop_back": (),
-    "PySide2.QtCore.QItemSelection.pop_front": (),
-    "PySide2.QtCore.QItemSelection.prepend": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_back": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_front": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAll": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.removeFirst": (),
-    "PySide2.QtCore.QItemSelection.removeLast": (),
-    "PySide2.QtCore.QItemSelection.removeOne": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.replace": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.reserve": ('int',),
-    "PySide2.QtCore.QItemSelection.select": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelection.setSharable": ('bool',),
-    "PySide2.QtCore.QItemSelection.size": (),
-    "PySide2.QtCore.QItemSelection.split": ('PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelection.startsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.swap": [('int', 'int'), ('typing.Sequence',)],
-    "PySide2.QtCore.QItemSelection.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.takeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.takeFirst": (),
-    "PySide2.QtCore.QItemSelection.takeLast": (),
-    "PySide2.QtCore.QItemSelection.toSet": (),
-    "PySide2.QtCore.QItemSelection.toVector": (),
-    "PySide2.QtCore.QItemSelection.value": [('int',), ('int', 'PySide2.QtCore.QItemSelectionRange')],
-# class PySide2.QtCore.QItemSelectionModel:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlag:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlags:
-    "PySide2.QtCore.QItemSelectionModel.__init__": [('PySide2.QtCore.QAbstractItemModel',), ('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QItemSelectionModel.clear": (),
-    "PySide2.QtCore.QItemSelectionModel.clearCurrentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.clearSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.columnIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.currentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.emitSelectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelectionModel.hasSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.isColumnSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isRowSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isSelected": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelectionModel.model": (),
-    "PySide2.QtCore.QItemSelectionModel.reset": (),
-    "PySide2.QtCore.QItemSelectionModel.rowIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.select": [('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtCore.QItemSelectionModel.selectedColumns": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selectedIndexes": (),
-    "PySide2.QtCore.QItemSelectionModel.selectedRows": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selection": (),
-    "PySide2.QtCore.QItemSelectionModel.setCurrentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelectionModel.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-# class PySide2.QtCore.QItemSelectionRange:
-    "PySide2.QtCore.QItemSelectionRange.__init__": [(), ('PySide2.QtCore.QItemSelectionRange',), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.__copy__": (),
-    "PySide2.QtCore.QItemSelectionRange.bottom": (),
-    "PySide2.QtCore.QItemSelectionRange.bottomRight": (),
-    "PySide2.QtCore.QItemSelectionRange.contains": [('PySide2.QtCore.QModelIndex',), ('int', 'int', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.height": (),
-    "PySide2.QtCore.QItemSelectionRange.indexes": (),
-    "PySide2.QtCore.QItemSelectionRange.intersected": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.intersects": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.isEmpty": (),
-    "PySide2.QtCore.QItemSelectionRange.isValid": (),
-    "PySide2.QtCore.QItemSelectionRange.left": (),
-    "PySide2.QtCore.QItemSelectionRange.model": (),
-    "PySide2.QtCore.QItemSelectionRange.parent": (),
-    "PySide2.QtCore.QItemSelectionRange.right": (),
-    "PySide2.QtCore.QItemSelectionRange.swap": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.top": (),
-    "PySide2.QtCore.QItemSelectionRange.topLeft": (),
-    "PySide2.QtCore.QItemSelectionRange.width": (),
-# class PySide2.QtCore.QJsonArray:
-    "PySide2.QtCore.QJsonArray.__init__": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonArray.__add__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__copy__": (),
-    "PySide2.QtCore.QJsonArray.__iadd__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__lshift__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.append": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.at": ('int',),
-    "PySide2.QtCore.QJsonArray.contains": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.count": (),
-    "PySide2.QtCore.QJsonArray.empty": (),
-    "PySide2.QtCore.QJsonArray.first": (),
-    "PySide2.QtCore.QJsonArray.fromStringList": ('typing.Sequence',),
-    "PySide2.QtCore.QJsonArray.fromVariantList": ('typing.Sequence',),
-    "PySide2.QtCore.QJsonArray.insert": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.isEmpty": (),
-    "PySide2.QtCore.QJsonArray.last": (),
-    "PySide2.QtCore.QJsonArray.pop_back": (),
-    "PySide2.QtCore.QJsonArray.pop_front": (),
-    "PySide2.QtCore.QJsonArray.prepend": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_back": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_front": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.removeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.removeFirst": (),
-    "PySide2.QtCore.QJsonArray.removeLast": (),
-    "PySide2.QtCore.QJsonArray.replace": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.size": (),
-    "PySide2.QtCore.QJsonArray.swap": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonArray.takeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.toVariantList": (),
-# class PySide2.QtCore.QJsonDocument:
-# class PySide2.QtCore.QJsonDocument.DataValidation:
-# class PySide2.QtCore.QJsonDocument.JsonFormat:
-    "PySide2.QtCore.QJsonDocument.__init__": [(), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('typing.Dict',)],
-    "PySide2.QtCore.QJsonDocument.__copy__": (),
-    "PySide2.QtCore.QJsonDocument.array": (),
-    "PySide2.QtCore.QJsonDocument.fromBinaryData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromJson": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonParseError'),
-    "PySide2.QtCore.QJsonDocument.fromRawData": ('bytes', 'int', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonDocument.isArray": (),
-    "PySide2.QtCore.QJsonDocument.isEmpty": (),
-    "PySide2.QtCore.QJsonDocument.isNull": (),
-    "PySide2.QtCore.QJsonDocument.isObject": (),
-    "PySide2.QtCore.QJsonDocument.object": (),
-    "PySide2.QtCore.QJsonDocument.rawData": (),
-    "PySide2.QtCore.QJsonDocument.setArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonDocument.setObject": ('typing.Dict',),
-    "PySide2.QtCore.QJsonDocument.swap": ('PySide2.QtCore.QJsonDocument',),
-    "PySide2.QtCore.QJsonDocument.toBinaryData": (),
-    "PySide2.QtCore.QJsonDocument.toJson": [(), ('PySide2.QtCore.QJsonDocument.JsonFormat',)],
-    "PySide2.QtCore.QJsonDocument.toVariant": (),
-# class PySide2.QtCore.QJsonParseError:
-# class PySide2.QtCore.QJsonParseError.ParseError:
-    "PySide2.QtCore.QJsonParseError.__init__": [(), ('PySide2.QtCore.QJsonParseError',)],
-    "PySide2.QtCore.QJsonParseError.__copy__": (),
-    "PySide2.QtCore.QJsonParseError.errorString": (),
-# class PySide2.QtCore.QJsonValue:
-# class PySide2.QtCore.QJsonValue.Type:
-    "PySide2.QtCore.QJsonValue.__init__": [('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QJsonValue.Type',), ('bool',), ('bytes',), ('float',), ('int',), ('str',), ('typing.Dict',)],
-    "PySide2.QtCore.QJsonValue.__copy__": (),
-    "PySide2.QtCore.QJsonValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonValue.isArray": (),
-    "PySide2.QtCore.QJsonValue.isBool": (),
-    "PySide2.QtCore.QJsonValue.isDouble": (),
-    "PySide2.QtCore.QJsonValue.isNull": (),
-    "PySide2.QtCore.QJsonValue.isObject": (),
-    "PySide2.QtCore.QJsonValue.isString": (),
-    "PySide2.QtCore.QJsonValue.isUndefined": (),
-    "PySide2.QtCore.QJsonValue.swap": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonValue.toArray": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonValue.toBool": ('bool',),
-    "PySide2.QtCore.QJsonValue.toDouble": ('float',),
-    "PySide2.QtCore.QJsonValue.toInt": ('int',),
-    "PySide2.QtCore.QJsonValue.toObject": [(), ('typing.Dict',)],
-    "PySide2.QtCore.QJsonValue.toString": [(), ('str',)],
-    "PySide2.QtCore.QJsonValue.toVariant": (),
-    "PySide2.QtCore.QJsonValue.type": (),
-# class PySide2.QtCore.QLibraryInfo:
-# class PySide2.QtCore.QLibraryInfo.LibraryLocation:
-    "PySide2.QtCore.QLibraryInfo.build": (),
-    "PySide2.QtCore.QLibraryInfo.buildDate": (),
-    "PySide2.QtCore.QLibraryInfo.isDebugBuild": (),
-    "PySide2.QtCore.QLibraryInfo.licensedProducts": (),
-    "PySide2.QtCore.QLibraryInfo.licensee": (),
-    "PySide2.QtCore.QLibraryInfo.location": ('PySide2.QtCore.QLibraryInfo.LibraryLocation',),
-    "PySide2.QtCore.QLibraryInfo.platformPluginArguments": ('str',),
-    "PySide2.QtCore.QLibraryInfo.version": (),
-# class PySide2.QtCore.QLine:
-    "PySide2.QtCore.QLine.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QLine.__copy__": (),
-    "PySide2.QtCore.QLine.__reduce__": (),
-    "PySide2.QtCore.QLine.__repr__": (),
-    "PySide2.QtCore.QLine.center": (),
-    "PySide2.QtCore.QLine.dx": (),
-    "PySide2.QtCore.QLine.dy": (),
-    "PySide2.QtCore.QLine.isNull": (),
-    "PySide2.QtCore.QLine.p1": (),
-    "PySide2.QtCore.QLine.p2": (),
-    "PySide2.QtCore.QLine.setLine": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QLine.setP1": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setP2": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setPoints": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QLine.toTuple": (),
-    "PySide2.QtCore.QLine.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.x1": (),
-    "PySide2.QtCore.QLine.x2": (),
-    "PySide2.QtCore.QLine.y1": (),
-    "PySide2.QtCore.QLine.y2": (),
-# class PySide2.QtCore.QLineF:
-# class PySide2.QtCore.QLineF.IntersectType:
-    "PySide2.QtCore.QLineF.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QLineF.__copy__": (),
-    "PySide2.QtCore.QLineF.__reduce__": (),
-    "PySide2.QtCore.QLineF.__repr__": (),
-    "PySide2.QtCore.QLineF.angle": [(), ('PySide2.QtCore.QLineF',)],
-    "PySide2.QtCore.QLineF.angleTo": ('PySide2.QtCore.QLineF',),
-    "PySide2.QtCore.QLineF.center": (),
-    "PySide2.QtCore.QLineF.dx": (),
-    "PySide2.QtCore.QLineF.dy": (),
-    "PySide2.QtCore.QLineF.fromPolar": ('float', 'float'),
-    "PySide2.QtCore.QLineF.intersect": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.intersects": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.isNull": (),
-    "PySide2.QtCore.QLineF.length": (),
-    "PySide2.QtCore.QLineF.normalVector": (),
-    "PySide2.QtCore.QLineF.p1": (),
-    "PySide2.QtCore.QLineF.p2": (),
-    "PySide2.QtCore.QLineF.pointAt": ('float',),
-    "PySide2.QtCore.QLineF.setAngle": ('float',),
-    "PySide2.QtCore.QLineF.setLength": ('float',),
-    "PySide2.QtCore.QLineF.setLine": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QLineF.setP1": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setP2": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setPoints": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.toLine": (),
-    "PySide2.QtCore.QLineF.toTuple": (),
-    "PySide2.QtCore.QLineF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.unitVector": (),
-    "PySide2.QtCore.QLineF.x1": (),
-    "PySide2.QtCore.QLineF.x2": (),
-    "PySide2.QtCore.QLineF.y1": (),
-    "PySide2.QtCore.QLineF.y2": (),
-# class PySide2.QtCore.QLocale:
-# class PySide2.QtCore.QLocale.Country:
-# class PySide2.QtCore.QLocale.CurrencySymbolFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormats:
-# class PySide2.QtCore.QLocale.FloatingPointPrecisionOption:
-# class PySide2.QtCore.QLocale.FormatType:
-# class PySide2.QtCore.QLocale.Language:
-# class PySide2.QtCore.QLocale.MeasurementSystem:
-# class PySide2.QtCore.QLocale.NumberOption:
-# class PySide2.QtCore.QLocale.NumberOptions:
-# class PySide2.QtCore.QLocale.QuotationStyle:
-# class PySide2.QtCore.QLocale.Script:
-    "PySide2.QtCore.QLocale.__init__": [(), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Country'), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'), ('str',)],
-    "PySide2.QtCore.QLocale.__copy__": (),
-    "PySide2.QtCore.QLocale.amText": (),
-    "PySide2.QtCore.QLocale.bcp47Name": (),
-    "PySide2.QtCore.QLocale.c": (),
-    "PySide2.QtCore.QLocale.collation": (),
-    "PySide2.QtCore.QLocale.countriesForLanguage": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.country": (),
-    "PySide2.QtCore.QLocale.countryToString": ('PySide2.QtCore.QLocale.Country',),
-    "PySide2.QtCore.QLocale.createSeparatedList": ('typing.Sequence',),
-    "PySide2.QtCore.QLocale.currencySymbol": ('PySide2.QtCore.QLocale.CurrencySymbolFormat',),
-    "PySide2.QtCore.QLocale.dateFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dateTimeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.decimalPoint": (),
-    "PySide2.QtCore.QLocale.exponential": (),
-    "PySide2.QtCore.QLocale.firstDayOfWeek": (),
-    "PySide2.QtCore.QLocale.formattedDataSize": ('int', 'int', 'PySide2.QtCore.QLocale.DataSizeFormats'),
-    "PySide2.QtCore.QLocale.groupSeparator": (),
-    "PySide2.QtCore.QLocale.language": (),
-    "PySide2.QtCore.QLocale.languageToString": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.matchingLocales": ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'),
-    "PySide2.QtCore.QLocale.measurementSystem": (),
-    "PySide2.QtCore.QLocale.monthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.name": (),
-    "PySide2.QtCore.QLocale.nativeCountryName": (),
-    "PySide2.QtCore.QLocale.nativeLanguageName": (),
-    "PySide2.QtCore.QLocale.negativeSign": (),
-    "PySide2.QtCore.QLocale.numberOptions": (),
-    "PySide2.QtCore.QLocale.percent": (),
-    "PySide2.QtCore.QLocale.pmText": (),
-    "PySide2.QtCore.QLocale.positiveSign": (),
-    "PySide2.QtCore.QLocale.quoteString": ('str', 'PySide2.QtCore.QLocale.QuotationStyle'),
-    "PySide2.QtCore.QLocale.script": (),
-    "PySide2.QtCore.QLocale.scriptToString": ('PySide2.QtCore.QLocale.Script',),
-    "PySide2.QtCore.QLocale.setDefault": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.setNumberOptions": ('PySide2.QtCore.QLocale.NumberOptions',),
-    "PySide2.QtCore.QLocale.standaloneDayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.standaloneMonthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.swap": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.system": (),
-    "PySide2.QtCore.QLocale.textDirection": (),
-    "PySide2.QtCore.QLocale.timeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.toCurrencyString": [('float', 'str'), ('float', 'str', 'int'), ('int', 'str')],
-    "PySide2.QtCore.QLocale.toDate": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDateTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDouble": ('str',),
-    "PySide2.QtCore.QLocale.toFloat": ('str',),
-    "PySide2.QtCore.QLocale.toInt": ('str',),
-    "PySide2.QtCore.QLocale.toLong": ('str',),
-    "PySide2.QtCore.QLocale.toLongLong": ('str',),
-    "PySide2.QtCore.QLocale.toLower": ('str',),
-    "PySide2.QtCore.QLocale.toShort": ('str',),
-    "PySide2.QtCore.QLocale.toString": [('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDate', 'str'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDateTime', 'str'), ('PySide2.QtCore.QTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QTime', 'str'), ('float', 'int', 'int'), ('int',)],
-    "PySide2.QtCore.QLocale.toTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toUInt": ('str',),
-    "PySide2.QtCore.QLocale.toULong": ('str',),
-    "PySide2.QtCore.QLocale.toULongLong": ('str',),
-    "PySide2.QtCore.QLocale.toUShort": ('str',),
-    "PySide2.QtCore.QLocale.toUpper": ('str',),
-    "PySide2.QtCore.QLocale.uiLanguages": (),
-    "PySide2.QtCore.QLocale.weekdays": (),
-    "PySide2.QtCore.QLocale.zeroDigit": (),
-# class PySide2.QtCore.QLockFile:
-# class PySide2.QtCore.QLockFile.LockError:
-    "PySide2.QtCore.QLockFile.__init__": ('str',),
-    "PySide2.QtCore.QLockFile.error": (),
-    "PySide2.QtCore.QLockFile.getLockInfo": (),
-    "PySide2.QtCore.QLockFile.isLocked": (),
-    "PySide2.QtCore.QLockFile.lock": (),
-    "PySide2.QtCore.QLockFile.removeStaleLockFile": (),
-    "PySide2.QtCore.QLockFile.setStaleLockTime": ('int',),
-    "PySide2.QtCore.QLockFile.staleLockTime": (),
-    "PySide2.QtCore.QLockFile.tryLock": ('int',),
-    "PySide2.QtCore.QLockFile.unlock": (),
-# class PySide2.QtCore.QMargins:
-    "PySide2.QtCore.QMargins.__init__": [(), ('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QMargins.__add__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__copy__": (),
-    "PySide2.QtCore.QMargins.__iadd__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__isub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__neg__": (),
-    "PySide2.QtCore.QMargins.__pos__": (),
-    "PySide2.QtCore.QMargins.__sub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.bottom": (),
-    "PySide2.QtCore.QMargins.isNull": (),
-    "PySide2.QtCore.QMargins.left": (),
-    "PySide2.QtCore.QMargins.right": (),
-    "PySide2.QtCore.QMargins.setBottom": ('int',),
-    "PySide2.QtCore.QMargins.setLeft": ('int',),
-    "PySide2.QtCore.QMargins.setRight": ('int',),
-    "PySide2.QtCore.QMargins.setTop": ('int',),
-    "PySide2.QtCore.QMargins.top": (),
-# class PySide2.QtCore.QMarginsF:
-    "PySide2.QtCore.QMarginsF.__init__": [(), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QMarginsF.__add__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__copy__": (),
-    "PySide2.QtCore.QMarginsF.__iadd__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__imul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__isub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__mul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__neg__": (),
-    "PySide2.QtCore.QMarginsF.__pos__": (),
-    "PySide2.QtCore.QMarginsF.__sub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.bottom": (),
-    "PySide2.QtCore.QMarginsF.isNull": (),
-    "PySide2.QtCore.QMarginsF.left": (),
-    "PySide2.QtCore.QMarginsF.right": (),
-    "PySide2.QtCore.QMarginsF.setBottom": ('float',),
-    "PySide2.QtCore.QMarginsF.setLeft": ('float',),
-    "PySide2.QtCore.QMarginsF.setRight": ('float',),
-    "PySide2.QtCore.QMarginsF.setTop": ('float',),
-    "PySide2.QtCore.QMarginsF.toMargins": (),
-    "PySide2.QtCore.QMarginsF.top": (),
-# class PySide2.QtCore.QMessageAuthenticationCode:
-    "PySide2.QtCore.QMessageAuthenticationCode.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMessageAuthenticationCode.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytes', 'int')],
-    "PySide2.QtCore.QMessageAuthenticationCode.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QMessageAuthenticationCode.reset": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.result": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.setKey": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QMessageLogContext:
-    "PySide2.QtCore.QMessageLogContext.__init__": [(), ('bytes', 'int', 'bytes', 'bytes')],
-# class PySide2.QtCore.QMetaClassInfo:
-    "PySide2.QtCore.QMetaClassInfo.__init__": [(), ('PySide2.QtCore.QMetaClassInfo',)],
-    "PySide2.QtCore.QMetaClassInfo.__copy__": (),
-    "PySide2.QtCore.QMetaClassInfo.name": (),
-    "PySide2.QtCore.QMetaClassInfo.value": (),
-# class PySide2.QtCore.QMetaEnum:
-    "PySide2.QtCore.QMetaEnum.__init__": [(), ('PySide2.QtCore.QMetaEnum',)],
-    "PySide2.QtCore.QMetaEnum.__copy__": (),
-    "PySide2.QtCore.QMetaEnum.enumName": (),
-    "PySide2.QtCore.QMetaEnum.isFlag": (),
-    "PySide2.QtCore.QMetaEnum.isScoped": (),
-    "PySide2.QtCore.QMetaEnum.isValid": (),
-    "PySide2.QtCore.QMetaEnum.key": ('int',),
-    "PySide2.QtCore.QMetaEnum.keyCount": (),
-    "PySide2.QtCore.QMetaEnum.keyToValue": ('bytes',),
-    "PySide2.QtCore.QMetaEnum.keysToValue": ('bytes',),
-    "PySide2.QtCore.QMetaEnum.name": (),
-    "PySide2.QtCore.QMetaEnum.scope": (),
-    "PySide2.QtCore.QMetaEnum.value": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKey": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKeys": ('int',),
-# class PySide2.QtCore.QMetaMethod:
-# class PySide2.QtCore.QMetaMethod.Access:
-# class PySide2.QtCore.QMetaMethod.MethodType:
-    "PySide2.QtCore.QMetaMethod.__init__": [(), ('PySide2.QtCore.QMetaMethod',)],
-    "PySide2.QtCore.QMetaMethod.__copy__": (),
-    "PySide2.QtCore.QMetaMethod.access": (),
-    "PySide2.QtCore.QMetaMethod.enclosingMetaObject": (),
-    "PySide2.QtCore.QMetaMethod.invoke": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.invokeOnGadget": [('int', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('int', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.isValid": (),
-    "PySide2.QtCore.QMetaMethod.methodIndex": (),
-    "PySide2.QtCore.QMetaMethod.methodSignature": (),
-    "PySide2.QtCore.QMetaMethod.methodType": (),
-    "PySide2.QtCore.QMetaMethod.name": (),
-    "PySide2.QtCore.QMetaMethod.parameterCount": (),
-    "PySide2.QtCore.QMetaMethod.parameterNames": (),
-    "PySide2.QtCore.QMetaMethod.parameterType": ('int',),
-    "PySide2.QtCore.QMetaMethod.parameterTypes": (),
-    "PySide2.QtCore.QMetaMethod.returnType": (),
-    "PySide2.QtCore.QMetaMethod.revision": (),
-    "PySide2.QtCore.QMetaMethod.tag": (),
-    "PySide2.QtCore.QMetaMethod.typeName": (),
-# class PySide2.QtCore.QMetaObject:
-# class PySide2.QtCore.QMetaObject.Call:
-# class PySide2.QtCore.QMetaObject.Connection:
-    "PySide2.QtCore.QMetaObject.Connection.__init__": [(), ('PySide2.QtCore.QMetaObject.Connection',)],
-    "PySide2.QtCore.QMetaObject.__init__": (),
-    "PySide2.QtCore.QMetaObject.cast": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.checkConnectArgs": [('PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QMetaMethod'), ('bytes', 'bytes')],
-    "PySide2.QtCore.QMetaObject.classInfo": ('int',),
-    "PySide2.QtCore.QMetaObject.classInfoCount": (),
-    "PySide2.QtCore.QMetaObject.classInfoOffset": (),
-    "PySide2.QtCore.QMetaObject.className": (),
-    "PySide2.QtCore.QMetaObject.connectSlotsByName": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.constructor": ('int',),
-    "PySide2.QtCore.QMetaObject.constructorCount": (),
-    "PySide2.QtCore.QMetaObject.disconnect": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.disconnectOne": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.enumerator": ('int',),
-    "PySide2.QtCore.QMetaObject.enumeratorCount": (),
-    "PySide2.QtCore.QMetaObject.enumeratorOffset": (),
-    "PySide2.QtCore.QMetaObject.indexOfClassInfo": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfConstructor": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfEnumerator": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfMethod": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfProperty": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfSignal": ('bytes',),
-    "PySide2.QtCore.QMetaObject.indexOfSlot": ('bytes',),
-    "PySide2.QtCore.QMetaObject.inherits": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtCore.QMetaObject.invokeMethod": [('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaObject.method": ('int',),
-    "PySide2.QtCore.QMetaObject.methodCount": (),
-    "PySide2.QtCore.QMetaObject.methodOffset": (),
-    "PySide2.QtCore.QMetaObject.newInstance": ('PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'),
-    "PySide2.QtCore.QMetaObject.normalizedSignature": ('bytes',),
-    "PySide2.QtCore.QMetaObject.normalizedType": ('bytes',),
-    "PySide2.QtCore.QMetaObject.property": ('int',),
-    "PySide2.QtCore.QMetaObject.propertyCount": (),
-    "PySide2.QtCore.QMetaObject.propertyOffset": (),
-    "PySide2.QtCore.QMetaObject.superClass": (),
-    "PySide2.QtCore.QMetaObject.userProperty": (),
-# class PySide2.QtCore.QMetaProperty:
-    "PySide2.QtCore.QMetaProperty.__init__": [(), ('PySide2.QtCore.QMetaProperty',)],
-    "PySide2.QtCore.QMetaProperty.__copy__": (),
-    "PySide2.QtCore.QMetaProperty.enumerator": (),
-    "PySide2.QtCore.QMetaProperty.hasNotifySignal": (),
-    "PySide2.QtCore.QMetaProperty.hasStdCppSet": (),
-    "PySide2.QtCore.QMetaProperty.isConstant": (),
-    "PySide2.QtCore.QMetaProperty.isDesignable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEditable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEnumType": (),
-    "PySide2.QtCore.QMetaProperty.isFinal": (),
-    "PySide2.QtCore.QMetaProperty.isFlagType": (),
-    "PySide2.QtCore.QMetaProperty.isReadable": (),
-    "PySide2.QtCore.QMetaProperty.isResettable": (),
-    "PySide2.QtCore.QMetaProperty.isScriptable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isStored": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isUser": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isValid": (),
-    "PySide2.QtCore.QMetaProperty.isWritable": (),
-    "PySide2.QtCore.QMetaProperty.name": (),
-    "PySide2.QtCore.QMetaProperty.notifySignal": (),
-    "PySide2.QtCore.QMetaProperty.notifySignalIndex": (),
-    "PySide2.QtCore.QMetaProperty.propertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.read": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.readOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.relativePropertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.reset": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.resetOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.revision": (),
-    "PySide2.QtCore.QMetaProperty.type": (),
-    "PySide2.QtCore.QMetaProperty.typeName": (),
-    "PySide2.QtCore.QMetaProperty.userType": (),
-    "PySide2.QtCore.QMetaProperty.write": ('PySide2.QtCore.QObject', 'typing.Any'),
-    "PySide2.QtCore.QMetaProperty.writeOnGadget": ('int', 'typing.Any'),
-# class PySide2.QtCore.QMimeData:
-    "PySide2.QtCore.QMimeData.__init__": (),
-    "PySide2.QtCore.QMimeData.clear": (),
-    "PySide2.QtCore.QMimeData.colorData": (),
-    "PySide2.QtCore.QMimeData.data": ('str',),
-    "PySide2.QtCore.QMimeData.formats": (),
-    "PySide2.QtCore.QMimeData.hasColor": (),
-    "PySide2.QtCore.QMimeData.hasFormat": ('str',),
-    "PySide2.QtCore.QMimeData.hasHtml": (),
-    "PySide2.QtCore.QMimeData.hasImage": (),
-    "PySide2.QtCore.QMimeData.hasText": (),
-    "PySide2.QtCore.QMimeData.hasUrls": (),
-    "PySide2.QtCore.QMimeData.html": (),
-    "PySide2.QtCore.QMimeData.imageData": (),
-    "PySide2.QtCore.QMimeData.removeFormat": ('str',),
-    "PySide2.QtCore.QMimeData.retrieveData": ('str', 'type'),
-    "PySide2.QtCore.QMimeData.setColorData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setData": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMimeData.setHtml": ('str',),
-    "PySide2.QtCore.QMimeData.setImageData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setText": ('str',),
-    "PySide2.QtCore.QMimeData.setUrls": ('typing.Sequence',),
-    "PySide2.QtCore.QMimeData.text": (),
-    "PySide2.QtCore.QMimeData.urls": (),
-# class PySide2.QtCore.QMimeDatabase:
-# class PySide2.QtCore.QMimeDatabase.MatchMode:
-    "PySide2.QtCore.QMimeDatabase.__init__": (),
-    "PySide2.QtCore.QMimeDatabase.allMimeTypes": (),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFile": [('PySide2.QtCore.QFileInfo', 'PySide2.QtCore.QMimeDatabase.MatchMode'), ('str', 'PySide2.QtCore.QMimeDatabase.MatchMode')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFileNameAndData": [('str', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QIODevice')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypesForFileName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.suffixForFileName": ('str',),
-# class PySide2.QtCore.QMimeType:
-    "PySide2.QtCore.QMimeType.__init__": [(), ('PySide2.QtCore.QMimeType',)],
-    "PySide2.QtCore.QMimeType.__copy__": (),
-    "PySide2.QtCore.QMimeType.aliases": (),
-    "PySide2.QtCore.QMimeType.allAncestors": (),
-    "PySide2.QtCore.QMimeType.comment": (),
-    "PySide2.QtCore.QMimeType.filterString": (),
-    "PySide2.QtCore.QMimeType.genericIconName": (),
-    "PySide2.QtCore.QMimeType.globPatterns": (),
-    "PySide2.QtCore.QMimeType.iconName": (),
-    "PySide2.QtCore.QMimeType.inherits": ('str',),
-    "PySide2.QtCore.QMimeType.isDefault": (),
-    "PySide2.QtCore.QMimeType.isValid": (),
-    "PySide2.QtCore.QMimeType.name": (),
-    "PySide2.QtCore.QMimeType.parentMimeTypes": (),
-    "PySide2.QtCore.QMimeType.preferredSuffix": (),
-    "PySide2.QtCore.QMimeType.suffixes": (),
-    "PySide2.QtCore.QMimeType.swap": ('PySide2.QtCore.QMimeType',),
-# class PySide2.QtCore.QModelIndex:
-    "PySide2.QtCore.QModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QModelIndex.__copy__": (),
-    "PySide2.QtCore.QModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.column": (),
-    "PySide2.QtCore.QModelIndex.data": ('int',),
-    "PySide2.QtCore.QModelIndex.flags": (),
-    "PySide2.QtCore.QModelIndex.internalId": (),
-    "PySide2.QtCore.QModelIndex.internalPointer": (),
-    "PySide2.QtCore.QModelIndex.isValid": (),
-    "PySide2.QtCore.QModelIndex.model": (),
-    "PySide2.QtCore.QModelIndex.parent": (),
-    "PySide2.QtCore.QModelIndex.row": (),
-    "PySide2.QtCore.QModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.siblingAtColumn": ('int',),
-    "PySide2.QtCore.QModelIndex.siblingAtRow": ('int',),
-# class PySide2.QtCore.QMutex:
-# class PySide2.QtCore.QMutex.RecursionMode:
-    "PySide2.QtCore.QMutex.__init__": [(), ('PySide2.QtCore.QMutex.RecursionMode',)],
-    "PySide2.QtCore.QMutex.isRecursive": (),
-    "PySide2.QtCore.QMutex.lock": (),
-    "PySide2.QtCore.QMutex.tryLock": [(), ('int',)],
-    "PySide2.QtCore.QMutex.try_lock": (),
-    "PySide2.QtCore.QMutex.unlock": (),
-# class PySide2.QtCore.QMutexLocker:
-    "PySide2.QtCore.QMutexLocker.__init__": [('PySide2.QtCore.QBasicMutex',), ('PySide2.QtCore.QRecursiveMutex',)],
-    "PySide2.QtCore.QMutexLocker.__enter__": (),
-    "PySide2.QtCore.QMutexLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QMutexLocker.mutex": (),
-    "PySide2.QtCore.QMutexLocker.relock": (),
-    "PySide2.QtCore.QMutexLocker.unlock": (),
-# class PySide2.QtCore.QObject:
-    "PySide2.QtCore.QObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.blockSignals": ('bool',),
-    "PySide2.QtCore.QObject.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtCore.QObject.children": (),
-    "PySide2.QtCore.QObject.connect": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'bytes', 'bytes', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'bytes', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType'), ('bytes', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType'), ('bytes', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType')],
-    "PySide2.QtCore.QObject.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.customEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.deleteLater": (),
-    "PySide2.QtCore.QObject.disconnect": [('PySide2.QtCore.QMetaObject.Connection',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod'), ('PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtCore.QObject', 'bytes', 'typing.Callable'), ('bytes', 'PySide2.QtCore.QObject', 'bytes'), ('bytes', 'typing.Callable')],
-    "PySide2.QtCore.QObject.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.dumpObjectInfo": (),
-    "PySide2.QtCore.QObject.dumpObjectTree": (),
-    "PySide2.QtCore.QObject.dynamicPropertyNames": (),
-    "PySide2.QtCore.QObject.emit": ('bytes', 'None'),
-    "PySide2.QtCore.QObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QObject.findChild": ('type', 'str'),
-    "PySide2.QtCore.QObject.findChildren": [('type', 'PySide2.QtCore.QRegExp'), ('type', 'str')],
-    "PySide2.QtCore.QObject.inherits": ('bytes',),
-    "PySide2.QtCore.QObject.installEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.isSignalConnected": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.isWidgetType": (),
-    "PySide2.QtCore.QObject.isWindowType": (),
-    "PySide2.QtCore.QObject.killTimer": ('int',),
-    "PySide2.QtCore.QObject.metaObject": (),
-    "PySide2.QtCore.QObject.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QObject.objectName": (),
-    "PySide2.QtCore.QObject.parent": (),
-    "PySide2.QtCore.QObject.property": ('bytes',),
-    "PySide2.QtCore.QObject.receivers": ('bytes',),
-    "PySide2.QtCore.QObject.registerUserData": (),
-    "PySide2.QtCore.QObject.removeEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.sender": (),
-    "PySide2.QtCore.QObject.senderSignalIndex": (),
-    "PySide2.QtCore.QObject.setObjectName": ('str',),
-    "PySide2.QtCore.QObject.setParent": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.setProperty": ('bytes', 'typing.Any'),
-    "PySide2.QtCore.QObject.signalsBlocked": (),
-    "PySide2.QtCore.QObject.startTimer": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QObject.thread": (),
-    "PySide2.QtCore.QObject.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QObject.tr": ('bytes', 'bytes', 'int'),
-# class PySide2.QtCore.QOperatingSystemVersion:
-# class PySide2.QtCore.QOperatingSystemVersion.OSType:
-    "PySide2.QtCore.QOperatingSystemVersion.__init__": [('PySide2.QtCore.QOperatingSystemVersion',), ('PySide2.QtCore.QOperatingSystemVersion.OSType', 'int', 'int', 'int')],
-    "PySide2.QtCore.QOperatingSystemVersion.__copy__": (),
-    "PySide2.QtCore.QOperatingSystemVersion.current": (),
-    "PySide2.QtCore.QOperatingSystemVersion.currentType": (),
-    "PySide2.QtCore.QOperatingSystemVersion.majorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.microVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.minorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.name": (),
-    "PySide2.QtCore.QOperatingSystemVersion.segmentCount": (),
-    "PySide2.QtCore.QOperatingSystemVersion.type": (),
-# class PySide2.QtCore.QParallelAnimationGroup:
-    "PySide2.QtCore.QParallelAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QParallelAnimationGroup.duration": (),
-    "PySide2.QtCore.QParallelAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QPauseAnimation:
-    "PySide2.QtCore.QPauseAnimation.__init__": [('PySide2.QtCore.QObject',), ('int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPauseAnimation.duration": (),
-    "PySide2.QtCore.QPauseAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPauseAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QPauseAnimation.updateCurrentTime": ('int',),
-# class PySide2.QtCore.QPersistentModelIndex:
-    "PySide2.QtCore.QPersistentModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QPersistentModelIndex',)],
-    "PySide2.QtCore.QPersistentModelIndex.__copy__": (),
-    "PySide2.QtCore.QPersistentModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.column": (),
-    "PySide2.QtCore.QPersistentModelIndex.data": ('int',),
-    "PySide2.QtCore.QPersistentModelIndex.flags": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalId": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalPointer": (),
-    "PySide2.QtCore.QPersistentModelIndex.isValid": (),
-    "PySide2.QtCore.QPersistentModelIndex.model": (),
-    "PySide2.QtCore.QPersistentModelIndex.parent": (),
-    "PySide2.QtCore.QPersistentModelIndex.row": (),
-    "PySide2.QtCore.QPersistentModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.swap": ('PySide2.QtCore.QPersistentModelIndex',),
-# class PySide2.QtCore.QPluginLoader:
-    "PySide2.QtCore.QPluginLoader.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPluginLoader.errorString": (),
-    "PySide2.QtCore.QPluginLoader.fileName": (),
-    "PySide2.QtCore.QPluginLoader.instance": (),
-    "PySide2.QtCore.QPluginLoader.isLoaded": (),
-    "PySide2.QtCore.QPluginLoader.load": (),
-    "PySide2.QtCore.QPluginLoader.metaData": (),
-    "PySide2.QtCore.QPluginLoader.setFileName": ('str',),
-    "PySide2.QtCore.QPluginLoader.staticInstances": (),
-    "PySide2.QtCore.QPluginLoader.unload": (),
-# class PySide2.QtCore.QPoint:
-    "PySide2.QtCore.QPoint.__init__": [(), ('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QPoint.__add__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__copy__": (),
-    "PySide2.QtCore.QPoint.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__isub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__neg__": (),
-    "PySide2.QtCore.QPoint.__pos__": (),
-    "PySide2.QtCore.QPoint.__reduce__": (),
-    "PySide2.QtCore.QPoint.__repr__": (),
-    "PySide2.QtCore.QPoint.__sub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.dotProduct": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QPoint.isNull": (),
-    "PySide2.QtCore.QPoint.manhattanLength": (),
-    "PySide2.QtCore.QPoint.setX": ('int',),
-    "PySide2.QtCore.QPoint.setY": ('int',),
-    "PySide2.QtCore.QPoint.toTuple": (),
-    "PySide2.QtCore.QPoint.transposed": (),
-    "PySide2.QtCore.QPoint.x": (),
-    "PySide2.QtCore.QPoint.y": (),
-# class PySide2.QtCore.QPointF:
-    "PySide2.QtCore.QPointF.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QPointF.__add__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__copy__": (),
-    "PySide2.QtCore.QPointF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__imul__": ('float',),
-    "PySide2.QtCore.QPointF.__isub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__mul__": ('float',),
-    "PySide2.QtCore.QPointF.__neg__": (),
-    "PySide2.QtCore.QPointF.__pos__": (),
-    "PySide2.QtCore.QPointF.__reduce__": (),
-    "PySide2.QtCore.QPointF.__repr__": (),
-    "PySide2.QtCore.QPointF.__sub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.dotProduct": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QPointF.isNull": (),
-    "PySide2.QtCore.QPointF.manhattanLength": (),
-    "PySide2.QtCore.QPointF.setX": ('float',),
-    "PySide2.QtCore.QPointF.setY": ('float',),
-    "PySide2.QtCore.QPointF.toPoint": (),
-    "PySide2.QtCore.QPointF.toTuple": (),
-    "PySide2.QtCore.QPointF.transposed": (),
-    "PySide2.QtCore.QPointF.x": (),
-    "PySide2.QtCore.QPointF.y": (),
-# class PySide2.QtCore.QProcess:
-# class PySide2.QtCore.QProcess.ExitStatus:
-# class PySide2.QtCore.QProcess.InputChannelMode:
-# class PySide2.QtCore.QProcess.ProcessChannel:
-# class PySide2.QtCore.QProcess.ProcessChannelMode:
-# class PySide2.QtCore.QProcess.ProcessError:
-# class PySide2.QtCore.QProcess.ProcessState:
-    "PySide2.QtCore.QProcess.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QProcess.arguments": (),
-    "PySide2.QtCore.QProcess.atEnd": (),
-    "PySide2.QtCore.QProcess.bytesAvailable": (),
-    "PySide2.QtCore.QProcess.bytesToWrite": (),
-    "PySide2.QtCore.QProcess.canReadLine": (),
-    "PySide2.QtCore.QProcess.close": (),
-    "PySide2.QtCore.QProcess.closeReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.closeWriteChannel": (),
-    "PySide2.QtCore.QProcess.environment": (),
-    "PySide2.QtCore.QProcess.error": (),
-    "PySide2.QtCore.QProcess.execute": [('str',), ('str', 'typing.Sequence')],
-    "PySide2.QtCore.QProcess.exitCode": (),
-    "PySide2.QtCore.QProcess.exitStatus": (),
-    "PySide2.QtCore.QProcess.inputChannelMode": (),
-    "PySide2.QtCore.QProcess.isSequential": (),
-    "PySide2.QtCore.QProcess.kill": (),
-    "PySide2.QtCore.QProcess.nativeArguments": (),
-    "PySide2.QtCore.QProcess.nullDevice": (),
-    "PySide2.QtCore.QProcess.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QProcess.pid": (),
-    "PySide2.QtCore.QProcess.processChannelMode": (),
-    "PySide2.QtCore.QProcess.processEnvironment": (),
-    "PySide2.QtCore.QProcess.processId": (),
-    "PySide2.QtCore.QProcess.program": (),
-    "PySide2.QtCore.QProcess.readAllStandardError": (),
-    "PySide2.QtCore.QProcess.readAllStandardOutput": (),
-    "PySide2.QtCore.QProcess.readChannel": (),
-    "PySide2.QtCore.QProcess.readData": ('bytes', 'int'),
-    "PySide2.QtCore.QProcess.setArguments": ('typing.Sequence',),
-    "PySide2.QtCore.QProcess.setEnvironment": ('typing.Sequence',),
-    "PySide2.QtCore.QProcess.setInputChannelMode": ('PySide2.QtCore.QProcess.InputChannelMode',),
-    "PySide2.QtCore.QProcess.setNativeArguments": ('str',),
-    "PySide2.QtCore.QProcess.setProcessChannelMode": ('PySide2.QtCore.QProcess.ProcessChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessEnvironment": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcess.setProcessState": ('PySide2.QtCore.QProcess.ProcessState',),
-    "PySide2.QtCore.QProcess.setProgram": ('str',),
-    "PySide2.QtCore.QProcess.setReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.setStandardErrorFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardInputFile": ('str',),
-    "PySide2.QtCore.QProcess.setStandardOutputFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardOutputProcess": ('PySide2.QtCore.QProcess',),
-    "PySide2.QtCore.QProcess.setWorkingDirectory": ('str',),
-    "PySide2.QtCore.QProcess.setupChildProcess": (),
-    "PySide2.QtCore.QProcess.start": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'typing.Sequence', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtCore.QProcess.startDetached": [(), ('str',), ('str', 'typing.Sequence'), ('str', 'typing.Sequence', 'str')],
-    "PySide2.QtCore.QProcess.state": (),
-    "PySide2.QtCore.QProcess.systemEnvironment": (),
-    "PySide2.QtCore.QProcess.terminate": (),
-    "PySide2.QtCore.QProcess.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QProcess.waitForFinished": ('int',),
-    "PySide2.QtCore.QProcess.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QProcess.waitForStarted": ('int',),
-    "PySide2.QtCore.QProcess.workingDirectory": (),
-    "PySide2.QtCore.QProcess.writeData": ('bytes', 'int'),
-# class PySide2.QtCore.QProcessEnvironment:
-    "PySide2.QtCore.QProcessEnvironment.__init__": [(), ('PySide2.QtCore.QProcessEnvironment',)],
-    "PySide2.QtCore.QProcessEnvironment.__copy__": (),
-    "PySide2.QtCore.QProcessEnvironment.clear": (),
-    "PySide2.QtCore.QProcessEnvironment.contains": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.insert": [('PySide2.QtCore.QProcessEnvironment',), ('str', 'str')],
-    "PySide2.QtCore.QProcessEnvironment.isEmpty": (),
-    "PySide2.QtCore.QProcessEnvironment.keys": (),
-    "PySide2.QtCore.QProcessEnvironment.remove": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.swap": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcessEnvironment.systemEnvironment": (),
-    "PySide2.QtCore.QProcessEnvironment.toStringList": (),
-    "PySide2.QtCore.QProcessEnvironment.value": ('str', 'str'),
-# class PySide2.QtCore.QPropertyAnimation:
-    "PySide2.QtCore.QPropertyAnimation.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPropertyAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPropertyAnimation.propertyName": (),
-    "PySide2.QtCore.QPropertyAnimation.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QPropertyAnimation.setTargetObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QPropertyAnimation.targetObject": (),
-    "PySide2.QtCore.QPropertyAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QPropertyAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QRandomGenerator:
-    "PySide2.QtCore.QRandomGenerator.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.bounded": [('float',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator.generate": (),
-    "PySide2.QtCore.QRandomGenerator.generate64": (),
-    "PySide2.QtCore.QRandomGenerator.generateDouble": (),
-    "PySide2.QtCore.QRandomGenerator.global_": (),
-    "PySide2.QtCore.QRandomGenerator.max": (),
-    "PySide2.QtCore.QRandomGenerator.min": (),
-    "PySide2.QtCore.QRandomGenerator.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator.seed": ('int',),
-    "PySide2.QtCore.QRandomGenerator.system": (),
-# class PySide2.QtCore.QRandomGenerator64:
-    "PySide2.QtCore.QRandomGenerator64.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator64.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator64.generate": (),
-    "PySide2.QtCore.QRandomGenerator64.global_": (),
-    "PySide2.QtCore.QRandomGenerator64.max": (),
-    "PySide2.QtCore.QRandomGenerator64.min": (),
-    "PySide2.QtCore.QRandomGenerator64.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator64.system": (),
-# class PySide2.QtCore.QReadLocker:
-    "PySide2.QtCore.QReadLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QReadLocker.__enter__": (),
-    "PySide2.QtCore.QReadLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QReadLocker.readWriteLock": (),
-    "PySide2.QtCore.QReadLocker.relock": (),
-    "PySide2.QtCore.QReadLocker.unlock": (),
-# class PySide2.QtCore.QReadWriteLock:
-# class PySide2.QtCore.QReadWriteLock.RecursionMode:
-    "PySide2.QtCore.QReadWriteLock.__init__": ('PySide2.QtCore.QReadWriteLock.RecursionMode',),
-    "PySide2.QtCore.QReadWriteLock.lockForRead": (),
-    "PySide2.QtCore.QReadWriteLock.lockForWrite": (),
-    "PySide2.QtCore.QReadWriteLock.tryLockForRead": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.tryLockForWrite": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.unlock": (),
-# class PySide2.QtCore.QRect:
-    "PySide2.QtCore.QRect.__init__": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QSize'), ('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QRect.__add__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__and__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__copy__": (),
-    "PySide2.QtCore.QRect.__iadd__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__iand__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__ior__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__isub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__or__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__reduce__": (),
-    "PySide2.QtCore.QRect.__repr__": (),
-    "PySide2.QtCore.QRect.__sub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.adjust": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.adjusted": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.bottom": (),
-    "PySide2.QtCore.QRect.bottomLeft": (),
-    "PySide2.QtCore.QRect.bottomRight": (),
-    "PySide2.QtCore.QRect.center": (),
-    "PySide2.QtCore.QRect.contains": [('PySide2.QtCore.QPoint', 'bool'), ('PySide2.QtCore.QRect', 'bool'), ('int', 'int'), ('int', 'int', 'bool')],
-    "PySide2.QtCore.QRect.getCoords": (),
-    "PySide2.QtCore.QRect.getRect": (),
-    "PySide2.QtCore.QRect.height": (),
-    "PySide2.QtCore.QRect.intersected": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.intersects": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.isEmpty": (),
-    "PySide2.QtCore.QRect.isNull": (),
-    "PySide2.QtCore.QRect.isValid": (),
-    "PySide2.QtCore.QRect.left": (),
-    "PySide2.QtCore.QRect.marginsAdded": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.marginsRemoved": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.moveBottom": ('int',),
-    "PySide2.QtCore.QRect.moveBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveCenter": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveLeft": ('int',),
-    "PySide2.QtCore.QRect.moveRight": ('int',),
-    "PySide2.QtCore.QRect.moveTo": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.moveTop": ('int',),
-    "PySide2.QtCore.QRect.moveTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.normalized": (),
-    "PySide2.QtCore.QRect.right": (),
-    "PySide2.QtCore.QRect.setBottom": ('int',),
-    "PySide2.QtCore.QRect.setBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setCoords": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setHeight": ('int',),
-    "PySide2.QtCore.QRect.setLeft": ('int',),
-    "PySide2.QtCore.QRect.setRect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setRight": ('int',),
-    "PySide2.QtCore.QRect.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QRect.setTop": ('int',),
-    "PySide2.QtCore.QRect.setTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setWidth": ('int',),
-    "PySide2.QtCore.QRect.setX": ('int',),
-    "PySide2.QtCore.QRect.setY": ('int',),
-    "PySide2.QtCore.QRect.size": (),
-    "PySide2.QtCore.QRect.top": (),
-    "PySide2.QtCore.QRect.topLeft": (),
-    "PySide2.QtCore.QRect.topRight": (),
-    "PySide2.QtCore.QRect.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.transposed": (),
-    "PySide2.QtCore.QRect.united": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.width": (),
-    "PySide2.QtCore.QRect.x": (),
-    "PySide2.QtCore.QRect.y": (),
-# class PySide2.QtCore.QRectF:
-    "PySide2.QtCore.QRectF.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QSizeF'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QRectF.__add__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__and__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__copy__": (),
-    "PySide2.QtCore.QRectF.__iadd__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__iand__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__ior__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__isub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__or__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__reduce__": (),
-    "PySide2.QtCore.QRectF.__repr__": (),
-    "PySide2.QtCore.QRectF.__sub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.adjust": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.adjusted": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.bottom": (),
-    "PySide2.QtCore.QRectF.bottomLeft": (),
-    "PySide2.QtCore.QRectF.bottomRight": (),
-    "PySide2.QtCore.QRectF.center": (),
-    "PySide2.QtCore.QRectF.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.getCoords": (),
-    "PySide2.QtCore.QRectF.getRect": (),
-    "PySide2.QtCore.QRectF.height": (),
-    "PySide2.QtCore.QRectF.intersected": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.intersects": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.isEmpty": (),
-    "PySide2.QtCore.QRectF.isNull": (),
-    "PySide2.QtCore.QRectF.isValid": (),
-    "PySide2.QtCore.QRectF.left": (),
-    "PySide2.QtCore.QRectF.marginsAdded": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.marginsRemoved": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.moveBottom": ('float',),
-    "PySide2.QtCore.QRectF.moveBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveCenter": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveLeft": ('float',),
-    "PySide2.QtCore.QRectF.moveRight": ('float',),
-    "PySide2.QtCore.QRectF.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.moveTop": ('float',),
-    "PySide2.QtCore.QRectF.moveTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.normalized": (),
-    "PySide2.QtCore.QRectF.right": (),
-    "PySide2.QtCore.QRectF.setBottom": ('float',),
-    "PySide2.QtCore.QRectF.setBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setCoords": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setHeight": ('float',),
-    "PySide2.QtCore.QRectF.setLeft": ('float',),
-    "PySide2.QtCore.QRectF.setRect": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setRight": ('float',),
-    "PySide2.QtCore.QRectF.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QRectF.setTop": ('float',),
-    "PySide2.QtCore.QRectF.setTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setWidth": ('float',),
-    "PySide2.QtCore.QRectF.setX": ('float',),
-    "PySide2.QtCore.QRectF.setY": ('float',),
-    "PySide2.QtCore.QRectF.size": (),
-    "PySide2.QtCore.QRectF.toAlignedRect": (),
-    "PySide2.QtCore.QRectF.toRect": (),
-    "PySide2.QtCore.QRectF.top": (),
-    "PySide2.QtCore.QRectF.topLeft": (),
-    "PySide2.QtCore.QRectF.topRight": (),
-    "PySide2.QtCore.QRectF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.transposed": (),
-    "PySide2.QtCore.QRectF.united": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.width": (),
-    "PySide2.QtCore.QRectF.x": (),
-    "PySide2.QtCore.QRectF.y": (),
-# class PySide2.QtCore.QRecursiveMutex:
-    "PySide2.QtCore.QRecursiveMutex.__init__": (),
-# class PySide2.QtCore.QRegExp:
-# class PySide2.QtCore.QRegExp.CaretMode:
-# class PySide2.QtCore.QRegExp.PatternSyntax:
-    "PySide2.QtCore.QRegExp.__init__": [(), ('PySide2.QtCore.QRegExp',), ('str', 'PySide2.QtCore.Qt.CaseSensitivity', 'PySide2.QtCore.QRegExp.PatternSyntax')],
-    "PySide2.QtCore.QRegExp.__copy__": (),
-    "PySide2.QtCore.QRegExp.__reduce__": (),
-    "PySide2.QtCore.QRegExp.__repr__": (),
-    "PySide2.QtCore.QRegExp.cap": ('int',),
-    "PySide2.QtCore.QRegExp.captureCount": (),
-    "PySide2.QtCore.QRegExp.capturedTexts": (),
-    "PySide2.QtCore.QRegExp.caseSensitivity": (),
-    "PySide2.QtCore.QRegExp.errorString": (),
-    "PySide2.QtCore.QRegExp.escape": ('str',),
-    "PySide2.QtCore.QRegExp.exactMatch": ('str',),
-    "PySide2.QtCore.QRegExp.indexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.isEmpty": (),
-    "PySide2.QtCore.QRegExp.isMinimal": (),
-    "PySide2.QtCore.QRegExp.isValid": (),
-    "PySide2.QtCore.QRegExp.lastIndexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.matchedLength": (),
-    "PySide2.QtCore.QRegExp.pattern": (),
-    "PySide2.QtCore.QRegExp.patternSyntax": (),
-    "PySide2.QtCore.QRegExp.pos": ('int',),
-    "PySide2.QtCore.QRegExp.replace": ('str', 'str'),
-    "PySide2.QtCore.QRegExp.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QRegExp.setMinimal": ('bool',),
-    "PySide2.QtCore.QRegExp.setPattern": ('str',),
-    "PySide2.QtCore.QRegExp.setPatternSyntax": ('PySide2.QtCore.QRegExp.PatternSyntax',),
-    "PySide2.QtCore.QRegExp.swap": ('PySide2.QtCore.QRegExp',),
-# class PySide2.QtCore.QRegularExpression:
-# class PySide2.QtCore.QRegularExpression.MatchOption:
-# class PySide2.QtCore.QRegularExpression.MatchOptions:
-# class PySide2.QtCore.QRegularExpression.MatchType:
-# class PySide2.QtCore.QRegularExpression.PatternOption:
-# class PySide2.QtCore.QRegularExpression.PatternOptions:
-    "PySide2.QtCore.QRegularExpression.__init__": [(), ('PySide2.QtCore.QRegularExpression',), ('str', 'PySide2.QtCore.QRegularExpression.PatternOptions')],
-    "PySide2.QtCore.QRegularExpression.__copy__": (),
-    "PySide2.QtCore.QRegularExpression.anchoredPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.captureCount": (),
-    "PySide2.QtCore.QRegularExpression.errorString": (),
-    "PySide2.QtCore.QRegularExpression.escape": ('str',),
-    "PySide2.QtCore.QRegularExpression.globalMatch": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.isValid": (),
-    "PySide2.QtCore.QRegularExpression.match": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.namedCaptureGroups": (),
-    "PySide2.QtCore.QRegularExpression.optimize": (),
-    "PySide2.QtCore.QRegularExpression.pattern": (),
-    "PySide2.QtCore.QRegularExpression.patternErrorOffset": (),
-    "PySide2.QtCore.QRegularExpression.patternOptions": (),
-    "PySide2.QtCore.QRegularExpression.setPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.setPatternOptions": ('PySide2.QtCore.QRegularExpression.PatternOptions',),
-    "PySide2.QtCore.QRegularExpression.swap": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QRegularExpression.wildcardToRegularExpression": ('str',),
-# class PySide2.QtCore.QRegularExpressionMatch:
-    "PySide2.QtCore.QRegularExpressionMatch.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatch',)],
-    "PySide2.QtCore.QRegularExpressionMatch.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatch.captured": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedEnd": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedLength": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedRef": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedStart": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedTexts": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasPartialMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatch.lastCapturedIndex": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatch.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatch.swap": ('PySide2.QtCore.QRegularExpressionMatch',),
-# class PySide2.QtCore.QRegularExpressionMatchIterator:
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatchIterator',)],
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.hasNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.peekNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.swap": ('PySide2.QtCore.QRegularExpressionMatchIterator',),
-# class PySide2.QtCore.QResource:
-# class PySide2.QtCore.QResource.Compression:
-    "PySide2.QtCore.QResource.__init__": ('str', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtCore.QResource.absoluteFilePath": (),
-    "PySide2.QtCore.QResource.addSearchPath": ('str',),
-    "PySide2.QtCore.QResource.children": (),
-    "PySide2.QtCore.QResource.compressionAlgorithm": (),
-    "PySide2.QtCore.QResource.data": (),
-    "PySide2.QtCore.QResource.fileName": (),
-    "PySide2.QtCore.QResource.isCompressed": (),
-    "PySide2.QtCore.QResource.isDir": (),
-    "PySide2.QtCore.QResource.isFile": (),
-    "PySide2.QtCore.QResource.isValid": (),
-    "PySide2.QtCore.QResource.lastModified": (),
-    "PySide2.QtCore.QResource.locale": (),
-    "PySide2.QtCore.QResource.registerResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.registerResourceData": ('bytes', 'str'),
-    "PySide2.QtCore.QResource.searchPaths": (),
-    "PySide2.QtCore.QResource.setFileName": ('str',),
-    "PySide2.QtCore.QResource.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QResource.size": (),
-    "PySide2.QtCore.QResource.unregisterResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.unregisterResourceData": ('bytes', 'str'),
-# class PySide2.QtCore.QRunnable:
-    "PySide2.QtCore.QRunnable.__init__": (),
-    "PySide2.QtCore.QRunnable.autoDelete": (),
-    "PySide2.QtCore.QRunnable.run": (),
-    "PySide2.QtCore.QRunnable.setAutoDelete": ('bool',),
-# class PySide2.QtCore.QSaveFile:
-    "PySide2.QtCore.QSaveFile.__init__": [('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSaveFile.cancelWriting": (),
-    "PySide2.QtCore.QSaveFile.close": (),
-    "PySide2.QtCore.QSaveFile.commit": (),
-    "PySide2.QtCore.QSaveFile.directWriteFallback": (),
-    "PySide2.QtCore.QSaveFile.fileName": (),
-    "PySide2.QtCore.QSaveFile.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QSaveFile.setDirectWriteFallback": ('bool',),
-    "PySide2.QtCore.QSaveFile.setFileName": ('str',),
-    "PySide2.QtCore.QSaveFile.writeData": ('bytes', 'int'),
-# class PySide2.QtCore.QSemaphore:
-    "PySide2.QtCore.QSemaphore.__init__": ('int',),
-    "PySide2.QtCore.QSemaphore.acquire": ('int',),
-    "PySide2.QtCore.QSemaphore.available": (),
-    "PySide2.QtCore.QSemaphore.release": ('int',),
-    "PySide2.QtCore.QSemaphore.tryAcquire": [('int',), ('int', 'int')],
-# class PySide2.QtCore.QSemaphoreReleaser:
-    "PySide2.QtCore.QSemaphoreReleaser.__init__": [(), ('PySide2.QtCore.QSemaphore', 'int')],
-    "PySide2.QtCore.QSemaphoreReleaser.cancel": (),
-    "PySide2.QtCore.QSemaphoreReleaser.semaphore": (),
-    "PySide2.QtCore.QSemaphoreReleaser.swap": ('PySide2.QtCore.QSemaphoreReleaser',),
-# class PySide2.QtCore.QSequentialAnimationGroup:
-    "PySide2.QtCore.QSequentialAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSequentialAnimationGroup.addPause": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.currentAnimation": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.duration": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSequentialAnimationGroup.insertPause": ('int', 'int'),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QSettings:
-# class PySide2.QtCore.QSettings.Format:
-# class PySide2.QtCore.QSettings.Scope:
-# class PySide2.QtCore.QSettings.Status:
-    "PySide2.QtCore.QSettings.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QObject'), ('str', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSettings.allKeys": (),
-    "PySide2.QtCore.QSettings.applicationName": (),
-    "PySide2.QtCore.QSettings.beginGroup": ('str',),
-    "PySide2.QtCore.QSettings.beginReadArray": ('str',),
-    "PySide2.QtCore.QSettings.beginWriteArray": ('str', 'int'),
-    "PySide2.QtCore.QSettings.childGroups": (),
-    "PySide2.QtCore.QSettings.childKeys": (),
-    "PySide2.QtCore.QSettings.clear": (),
-    "PySide2.QtCore.QSettings.contains": ('str',),
-    "PySide2.QtCore.QSettings.defaultFormat": (),
-    "PySide2.QtCore.QSettings.endArray": (),
-    "PySide2.QtCore.QSettings.endGroup": (),
-    "PySide2.QtCore.QSettings.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSettings.fallbacksEnabled": (),
-    "PySide2.QtCore.QSettings.fileName": (),
-    "PySide2.QtCore.QSettings.format": (),
-    "PySide2.QtCore.QSettings.group": (),
-    "PySide2.QtCore.QSettings.iniCodec": (),
-    "PySide2.QtCore.QSettings.isAtomicSyncRequired": (),
-    "PySide2.QtCore.QSettings.isWritable": (),
-    "PySide2.QtCore.QSettings.organizationName": (),
-    "PySide2.QtCore.QSettings.remove": ('str',),
-    "PySide2.QtCore.QSettings.scope": (),
-    "PySide2.QtCore.QSettings.setArrayIndex": ('int',),
-    "PySide2.QtCore.QSettings.setAtomicSyncRequired": ('bool',),
-    "PySide2.QtCore.QSettings.setDefaultFormat": ('PySide2.QtCore.QSettings.Format',),
-    "PySide2.QtCore.QSettings.setFallbacksEnabled": ('bool',),
-    "PySide2.QtCore.QSettings.setIniCodec": [('PySide2.QtCore.QTextCodec',), ('bytes',)],
-    "PySide2.QtCore.QSettings.setPath": ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str'),
-    "PySide2.QtCore.QSettings.setValue": ('str', 'typing.Any'),
-    "PySide2.QtCore.QSettings.status": (),
-    "PySide2.QtCore.QSettings.sync": (),
-    "PySide2.QtCore.QSettings.value": ('str', 'typing.Any', 'object'),
-# class PySide2.QtCore.QSignalBlocker:
-    "PySide2.QtCore.QSignalBlocker.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalBlocker.reblock": (),
-    "PySide2.QtCore.QSignalBlocker.unblock": (),
-# class PySide2.QtCore.QSignalMapper:
-    "PySide2.QtCore.QSignalMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.map": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QSignalMapper.mapping": [('PySide2.QtCore.QObject',), ('int',), ('str',)],
-    "PySide2.QtCore.QSignalMapper.removeMappings": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.setMapping": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-# class PySide2.QtCore.QSignalTransition:
-    "PySide2.QtCore.QSignalTransition.__init__": [('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',), ('object', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QSignalTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.senderObject": (),
-    "PySide2.QtCore.QSignalTransition.setSenderObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalTransition.setSignal": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QSignalTransition.signal": (),
-# class PySide2.QtCore.QSize:
-    "PySide2.QtCore.QSize.__init__": [(), ('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtCore.QSize.__add__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__copy__": (),
-    "PySide2.QtCore.QSize.__iadd__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__imul__": ('float',),
-    "PySide2.QtCore.QSize.__isub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__mul__": ('float',),
-    "PySide2.QtCore.QSize.__reduce__": (),
-    "PySide2.QtCore.QSize.__repr__": (),
-    "PySide2.QtCore.QSize.__sub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.boundedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.expandedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.grownBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.height": (),
-    "PySide2.QtCore.QSize.isEmpty": (),
-    "PySide2.QtCore.QSize.isNull": (),
-    "PySide2.QtCore.QSize.isValid": (),
-    "PySide2.QtCore.QSize.scale": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.setHeight": ('int',),
-    "PySide2.QtCore.QSize.setWidth": ('int',),
-    "PySide2.QtCore.QSize.shrunkBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.toTuple": (),
-    "PySide2.QtCore.QSize.transpose": (),
-    "PySide2.QtCore.QSize.transposed": (),
-    "PySide2.QtCore.QSize.width": (),
-# class PySide2.QtCore.QSizeF:
-    "PySide2.QtCore.QSizeF.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtCore.QSizeF.__add__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__copy__": (),
-    "PySide2.QtCore.QSizeF.__iadd__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__imul__": ('float',),
-    "PySide2.QtCore.QSizeF.__isub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__mul__": ('float',),
-    "PySide2.QtCore.QSizeF.__reduce__": (),
-    "PySide2.QtCore.QSizeF.__repr__": (),
-    "PySide2.QtCore.QSizeF.__sub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.boundedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.expandedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.grownBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.height": (),
-    "PySide2.QtCore.QSizeF.isEmpty": (),
-    "PySide2.QtCore.QSizeF.isNull": (),
-    "PySide2.QtCore.QSizeF.isValid": (),
-    "PySide2.QtCore.QSizeF.scale": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.scaled": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.setHeight": ('float',),
-    "PySide2.QtCore.QSizeF.setWidth": ('float',),
-    "PySide2.QtCore.QSizeF.shrunkBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.toSize": (),
-    "PySide2.QtCore.QSizeF.toTuple": (),
-    "PySide2.QtCore.QSizeF.transpose": (),
-    "PySide2.QtCore.QSizeF.transposed": (),
-    "PySide2.QtCore.QSizeF.width": (),
-# class PySide2.QtCore.QSocketNotifier:
-# class PySide2.QtCore.QSocketNotifier.Type:
-    "PySide2.QtCore.QSocketNotifier.__init__": [('int', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject'), ('object', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSocketNotifier.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSocketNotifier.isEnabled": (),
-    "PySide2.QtCore.QSocketNotifier.setEnabled": ('bool',),
-    "PySide2.QtCore.QSocketNotifier.socket": (),
-    "PySide2.QtCore.QSocketNotifier.type": (),
-# class PySide2.QtCore.QSortFilterProxyModel:
-    "PySide2.QtCore.QSortFilterProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSortFilterProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.dynamicSortFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterKeyColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegExp": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegularExpression": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidate": (),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidateFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isRecursiveFilteringEnabled": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isSortLocaleAware": (),
-    "PySide2.QtCore.QSortFilterProxyModel.lessThan": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeData": ('typing.List',),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QSortFilterProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QSortFilterProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setDynamicSortFilter": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterFixedString": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterKeyColumn": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegExp": [('PySide2.QtCore.QRegExp',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegularExpression": [('PySide2.QtCore.QRegularExpression',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterWildcard": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setRecursiveFilteringEnabled": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortLocaleAware": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QSortFilterProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QSortFilterProxyModel.sortCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortOrder": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QStandardPaths:
-# class PySide2.QtCore.QStandardPaths.LocateOption:
-# class PySide2.QtCore.QStandardPaths.LocateOptions:
-# class PySide2.QtCore.QStandardPaths.StandardLocation:
-    "PySide2.QtCore.QStandardPaths.displayName": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.enableTestMode": ('bool',),
-    "PySide2.QtCore.QStandardPaths.findExecutable": ('str', 'typing.Sequence'),
-    "PySide2.QtCore.QStandardPaths.isTestModeEnabled": (),
-    "PySide2.QtCore.QStandardPaths.locate": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.locateAll": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.setTestModeEnabled": ('bool',),
-    "PySide2.QtCore.QStandardPaths.standardLocations": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.writableLocation": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-# class PySide2.QtCore.QState:
-# class PySide2.QtCore.QState.ChildMode:
-# class PySide2.QtCore.QState.RestorePolicy:
-    "PySide2.QtCore.QState.__init__": [('PySide2.QtCore.QState',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QState.addTransition": [('PySide2.QtCore.QAbstractState',), ('PySide2.QtCore.QAbstractTransition',), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.QAbstractState'), ('object', 'PySide2.QtCore.QAbstractState')],
-    "PySide2.QtCore.QState.assignProperty": ('PySide2.QtCore.QObject', 'bytes', 'typing.Any'),
-    "PySide2.QtCore.QState.childMode": (),
-    "PySide2.QtCore.QState.errorState": (),
-    "PySide2.QtCore.QState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.initialState": (),
-    "PySide2.QtCore.QState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.removeTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QState.setChildMode": ('PySide2.QtCore.QState.ChildMode',),
-    "PySide2.QtCore.QState.setErrorState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.setInitialState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.transitions": (),
-# class PySide2.QtCore.QStateMachine:
-# class PySide2.QtCore.QStateMachine.Error:
-# class PySide2.QtCore.QStateMachine.EventPriority:
-# class PySide2.QtCore.QStateMachine.SignalEvent:
-    "PySide2.QtCore.QStateMachine.SignalEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'typing.Sequence'), ('PySide2.QtCore.QStateMachine.SignalEvent',)],
-    "PySide2.QtCore.QStateMachine.SignalEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.arguments": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.sender": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.signalIndex": (),
-# class PySide2.QtCore.QStateMachine.WrappedEvent:
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'), ('PySide2.QtCore.QStateMachine.WrappedEvent',)],
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.event": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.object": (),
-    "PySide2.QtCore.QStateMachine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStateMachine.addDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.addState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.beginMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.beginSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.cancelDelayedEvent": ('int',),
-    "PySide2.QtCore.QStateMachine.clearError": (),
-    "PySide2.QtCore.QStateMachine.configuration": (),
-    "PySide2.QtCore.QStateMachine.defaultAnimations": (),
-    "PySide2.QtCore.QStateMachine.endMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.endSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.error": (),
-    "PySide2.QtCore.QStateMachine.errorString": (),
-    "PySide2.QtCore.QStateMachine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QStateMachine.globalRestorePolicy": (),
-    "PySide2.QtCore.QStateMachine.isAnimated": (),
-    "PySide2.QtCore.QStateMachine.isRunning": (),
-    "PySide2.QtCore.QStateMachine.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.postDelayedEvent": ('PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QStateMachine.postEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QStateMachine.EventPriority'),
-    "PySide2.QtCore.QStateMachine.removeDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.removeState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.setAnimated": ('bool',),
-    "PySide2.QtCore.QStateMachine.setGlobalRestorePolicy": ('PySide2.QtCore.QState.RestorePolicy',),
-    "PySide2.QtCore.QStateMachine.setRunning": ('bool',),
-    "PySide2.QtCore.QStateMachine.start": (),
-    "PySide2.QtCore.QStateMachine.stop": (),
-# class PySide2.QtCore.QStorageInfo:
-    "PySide2.QtCore.QStorageInfo.__init__": [(), ('PySide2.QtCore.QDir',), ('PySide2.QtCore.QStorageInfo',), ('str',)],
-    "PySide2.QtCore.QStorageInfo.__copy__": (),
-    "PySide2.QtCore.QStorageInfo.blockSize": (),
-    "PySide2.QtCore.QStorageInfo.bytesAvailable": (),
-    "PySide2.QtCore.QStorageInfo.bytesFree": (),
-    "PySide2.QtCore.QStorageInfo.bytesTotal": (),
-    "PySide2.QtCore.QStorageInfo.device": (),
-    "PySide2.QtCore.QStorageInfo.displayName": (),
-    "PySide2.QtCore.QStorageInfo.fileSystemType": (),
-    "PySide2.QtCore.QStorageInfo.isReadOnly": (),
-    "PySide2.QtCore.QStorageInfo.isReady": (),
-    "PySide2.QtCore.QStorageInfo.isRoot": (),
-    "PySide2.QtCore.QStorageInfo.isValid": (),
-    "PySide2.QtCore.QStorageInfo.mountedVolumes": (),
-    "PySide2.QtCore.QStorageInfo.name": (),
-    "PySide2.QtCore.QStorageInfo.refresh": (),
-    "PySide2.QtCore.QStorageInfo.root": (),
-    "PySide2.QtCore.QStorageInfo.rootPath": (),
-    "PySide2.QtCore.QStorageInfo.setPath": ('str',),
-    "PySide2.QtCore.QStorageInfo.subvolume": (),
-    "PySide2.QtCore.QStorageInfo.swap": ('PySide2.QtCore.QStorageInfo',),
-# class PySide2.QtCore.QStringListModel:
-    "PySide2.QtCore.QStringListModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStringListModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QStringListModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtCore.QStringListModel.setStringList": ('typing.Sequence',),
-    "PySide2.QtCore.QStringListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QStringListModel.stringList": (),
-    "PySide2.QtCore.QStringListModel.supportedDropActions": (),
-# class PySide2.QtCore.QSysInfo:
-# class PySide2.QtCore.QSysInfo.Endian:
-# class PySide2.QtCore.QSysInfo.Sizes:
-# class PySide2.QtCore.QSysInfo.WinVersion:
-    "PySide2.QtCore.QSysInfo.__init__": (),
-    "PySide2.QtCore.QSysInfo.bootUniqueId": (),
-    "PySide2.QtCore.QSysInfo.buildAbi": (),
-    "PySide2.QtCore.QSysInfo.buildCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.currentCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.kernelType": (),
-    "PySide2.QtCore.QSysInfo.kernelVersion": (),
-    "PySide2.QtCore.QSysInfo.machineHostName": (),
-    "PySide2.QtCore.QSysInfo.machineUniqueId": (),
-    "PySide2.QtCore.QSysInfo.prettyProductName": (),
-    "PySide2.QtCore.QSysInfo.productType": (),
-    "PySide2.QtCore.QSysInfo.productVersion": (),
-    "PySide2.QtCore.QSysInfo.windowsVersion": (),
-# class PySide2.QtCore.QSystemSemaphore:
-# class PySide2.QtCore.QSystemSemaphore.AccessMode:
-# class PySide2.QtCore.QSystemSemaphore.SystemSemaphoreError:
-    "PySide2.QtCore.QSystemSemaphore.__init__": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-    "PySide2.QtCore.QSystemSemaphore.acquire": (),
-    "PySide2.QtCore.QSystemSemaphore.error": (),
-    "PySide2.QtCore.QSystemSemaphore.errorString": (),
-    "PySide2.QtCore.QSystemSemaphore.key": (),
-    "PySide2.QtCore.QSystemSemaphore.release": ('int',),
-    "PySide2.QtCore.QSystemSemaphore.setKey": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-# class PySide2.QtCore.QTemporaryDir:
-    "PySide2.QtCore.QTemporaryDir.__init__": [(), ('str',)],
-    "PySide2.QtCore.QTemporaryDir.autoRemove": (),
-    "PySide2.QtCore.QTemporaryDir.errorString": (),
-    "PySide2.QtCore.QTemporaryDir.filePath": ('str',),
-    "PySide2.QtCore.QTemporaryDir.isValid": (),
-    "PySide2.QtCore.QTemporaryDir.path": (),
-    "PySide2.QtCore.QTemporaryDir.remove": (),
-    "PySide2.QtCore.QTemporaryDir.setAutoRemove": ('bool',),
-# class PySide2.QtCore.QTemporaryFile:
-    "PySide2.QtCore.QTemporaryFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QTemporaryFile.autoRemove": (),
-    "PySide2.QtCore.QTemporaryFile.createLocalFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.createNativeFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.fileName": (),
-    "PySide2.QtCore.QTemporaryFile.fileTemplate": (),
-    "PySide2.QtCore.QTemporaryFile.open": [(), ('PySide2.QtCore.QIODevice.OpenMode',)],
-    "PySide2.QtCore.QTemporaryFile.rename": ('str',),
-    "PySide2.QtCore.QTemporaryFile.setAutoRemove": ('bool',),
-    "PySide2.QtCore.QTemporaryFile.setFileTemplate": ('str',),
-# class PySide2.QtCore.QTextBoundaryFinder:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReason:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReasons:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryType:
-    "PySide2.QtCore.QTextBoundaryFinder.__init__": [(), ('PySide2.QtCore.QTextBoundaryFinder',), ('PySide2.QtCore.QTextBoundaryFinder.BoundaryType', 'str')],
-    "PySide2.QtCore.QTextBoundaryFinder.__copy__": (),
-    "PySide2.QtCore.QTextBoundaryFinder.boundaryReasons": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isAtBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isValid": (),
-    "PySide2.QtCore.QTextBoundaryFinder.position": (),
-    "PySide2.QtCore.QTextBoundaryFinder.setPosition": ('int',),
-    "PySide2.QtCore.QTextBoundaryFinder.string": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toEnd": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toNextBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toPreviousBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toStart": (),
-    "PySide2.QtCore.QTextBoundaryFinder.type": (),
-# class PySide2.QtCore.QTextCodec:
-# class PySide2.QtCore.QTextCodec.ConversionFlag:
-# class PySide2.QtCore.QTextCodec.ConversionFlags:
-# class PySide2.QtCore.QTextCodec.ConverterState:
-    "PySide2.QtCore.QTextCodec.ConverterState.__init__": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.__init__": (),
-    "PySide2.QtCore.QTextCodec.aliases": (),
-    "PySide2.QtCore.QTextCodec.availableCodecs": (),
-    "PySide2.QtCore.QTextCodec.availableMibs": (),
-    "PySide2.QtCore.QTextCodec.canEncode": ('str',),
-    "PySide2.QtCore.QTextCodec.codecForHtml": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.codecForLocale": (),
-    "PySide2.QtCore.QTextCodec.codecForMib": ('int',),
-    "PySide2.QtCore.QTextCodec.codecForName": [('PySide2.QtCore.QByteArray',), ('bytes',)],
-    "PySide2.QtCore.QTextCodec.codecForUtfText": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.convertToUnicode": ('bytes', 'int', 'PySide2.QtCore.QTextCodec.ConverterState'),
-    "PySide2.QtCore.QTextCodec.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextCodec.makeDecoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.makeEncoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.mibEnum": (),
-    "PySide2.QtCore.QTextCodec.name": (),
-    "PySide2.QtCore.QTextCodec.setCodecForLocale": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtCore.QTextCodec.toUnicode": [('PySide2.QtCore.QByteArray',), ('bytes',), ('bytes', 'int', 'PySide2.QtCore.QTextCodec.ConverterState')],
-# class PySide2.QtCore.QTextDecoder:
-    "PySide2.QtCore.QTextDecoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextDecoder.hasFailure": (),
-    "PySide2.QtCore.QTextDecoder.needsMoreData": (),
-    "PySide2.QtCore.QTextDecoder.toUnicode": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QTextEncoder:
-    "PySide2.QtCore.QTextEncoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextEncoder.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextEncoder.hasFailure": (),
-# class PySide2.QtCore.QTextStream:
-# class PySide2.QtCore.QTextStream.FieldAlignment:
-# class PySide2.QtCore.QTextStream.NumberFlag:
-# class PySide2.QtCore.QTextStream.NumberFlags:
-# class PySide2.QtCore.QTextStream.RealNumberNotation:
-# class PySide2.QtCore.QTextStream.Status:
-    "PySide2.QtCore.QTextStream.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QTextStream.__lshift__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QTextStreamManipulator',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QTextStream.__rshift__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTextStream.atEnd": (),
-    "PySide2.QtCore.QTextStream.autoDetectUnicode": (),
-    "PySide2.QtCore.QTextStream.codec": (),
-    "PySide2.QtCore.QTextStream.device": (),
-    "PySide2.QtCore.QTextStream.fieldAlignment": (),
-    "PySide2.QtCore.QTextStream.fieldWidth": (),
-    "PySide2.QtCore.QTextStream.flush": (),
-    "PySide2.QtCore.QTextStream.generateByteOrderMark": (),
-    "PySide2.QtCore.QTextStream.integerBase": (),
-    "PySide2.QtCore.QTextStream.locale": (),
-    "PySide2.QtCore.QTextStream.numberFlags": (),
-    "PySide2.QtCore.QTextStream.padChar": (),
-    "PySide2.QtCore.QTextStream.pos": (),
-    "PySide2.QtCore.QTextStream.read": ('int',),
-    "PySide2.QtCore.QTextStream.readAll": (),
-    "PySide2.QtCore.QTextStream.readLine": ('int',),
-    "PySide2.QtCore.QTextStream.realNumberNotation": (),
-    "PySide2.QtCore.QTextStream.realNumberPrecision": (),
-    "PySide2.QtCore.QTextStream.reset": (),
-    "PySide2.QtCore.QTextStream.resetStatus": (),
-    "PySide2.QtCore.QTextStream.seek": ('int',),
-    "PySide2.QtCore.QTextStream.setAutoDetectUnicode": ('bool',),
-    "PySide2.QtCore.QTextStream.setCodec": [('PySide2.QtCore.QTextCodec',), ('bytes',)],
-    "PySide2.QtCore.QTextStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QTextStream.setFieldAlignment": ('PySide2.QtCore.QTextStream.FieldAlignment',),
-    "PySide2.QtCore.QTextStream.setFieldWidth": ('int',),
-    "PySide2.QtCore.QTextStream.setGenerateByteOrderMark": ('bool',),
-    "PySide2.QtCore.QTextStream.setIntegerBase": ('int',),
-    "PySide2.QtCore.QTextStream.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QTextStream.setNumberFlags": ('PySide2.QtCore.QTextStream.NumberFlags',),
-    "PySide2.QtCore.QTextStream.setPadChar": ('str',),
-    "PySide2.QtCore.QTextStream.setRealNumberNotation": ('PySide2.QtCore.QTextStream.RealNumberNotation',),
-    "PySide2.QtCore.QTextStream.setRealNumberPrecision": ('int',),
-    "PySide2.QtCore.QTextStream.setStatus": ('PySide2.QtCore.QTextStream.Status',),
-    "PySide2.QtCore.QTextStream.skipWhiteSpace": (),
-    "PySide2.QtCore.QTextStream.status": (),
-    "PySide2.QtCore.QTextStream.string": (),
-# class PySide2.QtCore.QTextStreamManipulator:
-    "PySide2.QtCore.QTextStreamManipulator.__copy__": (),
-    "PySide2.QtCore.QTextStreamManipulator.exec_": ('PySide2.QtCore.QTextStream',),
-# class PySide2.QtCore.QThread:
-# class PySide2.QtCore.QThread.Priority:
-    "PySide2.QtCore.QThread.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThread.currentThread": (),
-    "PySide2.QtCore.QThread.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QThread.eventDispatcher": (),
-    "PySide2.QtCore.QThread.exec_": (),
-    "PySide2.QtCore.QThread.exit": ('int',),
-    "PySide2.QtCore.QThread.idealThreadCount": (),
-    "PySide2.QtCore.QThread.isFinished": (),
-    "PySide2.QtCore.QThread.isInterruptionRequested": (),
-    "PySide2.QtCore.QThread.isRunning": (),
-    "PySide2.QtCore.QThread.loopLevel": (),
-    "PySide2.QtCore.QThread.msleep": ('int',),
-    "PySide2.QtCore.QThread.priority": (),
-    "PySide2.QtCore.QThread.quit": (),
-    "PySide2.QtCore.QThread.requestInterruption": (),
-    "PySide2.QtCore.QThread.run": (),
-    "PySide2.QtCore.QThread.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QThread.setPriority": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.setStackSize": ('int',),
-    "PySide2.QtCore.QThread.setTerminationEnabled": ('bool',),
-    "PySide2.QtCore.QThread.sleep": ('int',),
-    "PySide2.QtCore.QThread.stackSize": (),
-    "PySide2.QtCore.QThread.start": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.terminate": (),
-    "PySide2.QtCore.QThread.usleep": ('int',),
-    "PySide2.QtCore.QThread.wait": ('int',),
-    "PySide2.QtCore.QThread.yieldCurrentThread": (),
-# class PySide2.QtCore.QThreadPool:
-    "PySide2.QtCore.QThreadPool.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThreadPool.activeThreadCount": (),
-    "PySide2.QtCore.QThreadPool.cancel": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.clear": (),
-    "PySide2.QtCore.QThreadPool.expiryTimeout": (),
-    "PySide2.QtCore.QThreadPool.globalInstance": (),
-    "PySide2.QtCore.QThreadPool.maxThreadCount": (),
-    "PySide2.QtCore.QThreadPool.releaseThread": (),
-    "PySide2.QtCore.QThreadPool.reserveThread": (),
-    "PySide2.QtCore.QThreadPool.setExpiryTimeout": ('int',),
-    "PySide2.QtCore.QThreadPool.setMaxThreadCount": ('int',),
-    "PySide2.QtCore.QThreadPool.setStackSize": ('int',),
-    "PySide2.QtCore.QThreadPool.stackSize": (),
-    "PySide2.QtCore.QThreadPool.start": ('PySide2.QtCore.QRunnable', 'int'),
-    "PySide2.QtCore.QThreadPool.tryStart": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.tryTake": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.waitForDone": ('int',),
-# class PySide2.QtCore.QTime:
-    "PySide2.QtCore.QTime.__init__": [(), ('PySide2.QtCore.QTime',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.__copy__": (),
-    "PySide2.QtCore.QTime.__reduce__": (),
-    "PySide2.QtCore.QTime.__repr__": (),
-    "PySide2.QtCore.QTime.addMSecs": ('int',),
-    "PySide2.QtCore.QTime.addSecs": ('int',),
-    "PySide2.QtCore.QTime.currentTime": (),
-    "PySide2.QtCore.QTime.elapsed": (),
-    "PySide2.QtCore.QTime.fromMSecsSinceStartOfDay": ('int',),
-    "PySide2.QtCore.QTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str')],
-    "PySide2.QtCore.QTime.hour": (),
-    "PySide2.QtCore.QTime.isNull": (),
-    "PySide2.QtCore.QTime.isValid": [(), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.minute": (),
-    "PySide2.QtCore.QTime.msec": (),
-    "PySide2.QtCore.QTime.msecsSinceStartOfDay": (),
-    "PySide2.QtCore.QTime.msecsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.restart": (),
-    "PySide2.QtCore.QTime.second": (),
-    "PySide2.QtCore.QTime.secsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.setHMS": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QTime.start": (),
-    "PySide2.QtCore.QTime.toPython": (),
-    "PySide2.QtCore.QTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-# class PySide2.QtCore.QTimeLine:
-# class PySide2.QtCore.QTimeLine.CurveShape:
-# class PySide2.QtCore.QTimeLine.Direction:
-# class PySide2.QtCore.QTimeLine.State:
-    "PySide2.QtCore.QTimeLine.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QTimeLine.currentFrame": (),
-    "PySide2.QtCore.QTimeLine.currentTime": (),
-    "PySide2.QtCore.QTimeLine.currentValue": (),
-    "PySide2.QtCore.QTimeLine.curveShape": (),
-    "PySide2.QtCore.QTimeLine.direction": (),
-    "PySide2.QtCore.QTimeLine.duration": (),
-    "PySide2.QtCore.QTimeLine.easingCurve": (),
-    "PySide2.QtCore.QTimeLine.endFrame": (),
-    "PySide2.QtCore.QTimeLine.frameForTime": ('int',),
-    "PySide2.QtCore.QTimeLine.loopCount": (),
-    "PySide2.QtCore.QTimeLine.resume": (),
-    "PySide2.QtCore.QTimeLine.setCurrentTime": ('int',),
-    "PySide2.QtCore.QTimeLine.setCurveShape": ('PySide2.QtCore.QTimeLine.CurveShape',),
-    "PySide2.QtCore.QTimeLine.setDirection": ('PySide2.QtCore.QTimeLine.Direction',),
-    "PySide2.QtCore.QTimeLine.setDuration": ('int',),
-    "PySide2.QtCore.QTimeLine.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QTimeLine.setEndFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setFrameRange": ('int', 'int'),
-    "PySide2.QtCore.QTimeLine.setLoopCount": ('int',),
-    "PySide2.QtCore.QTimeLine.setPaused": ('bool',),
-    "PySide2.QtCore.QTimeLine.setStartFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setUpdateInterval": ('int',),
-    "PySide2.QtCore.QTimeLine.start": (),
-    "PySide2.QtCore.QTimeLine.startFrame": (),
-    "PySide2.QtCore.QTimeLine.state": (),
-    "PySide2.QtCore.QTimeLine.stop": (),
-    "PySide2.QtCore.QTimeLine.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimeLine.toggleDirection": (),
-    "PySide2.QtCore.QTimeLine.updateInterval": (),
-    "PySide2.QtCore.QTimeLine.valueForTime": ('int',),
-# class PySide2.QtCore.QTimeZone:
-# class PySide2.QtCore.QTimeZone.NameType:
-# class PySide2.QtCore.QTimeZone.OffsetData:
-    "PySide2.QtCore.QTimeZone.OffsetData.__init__": [(), ('PySide2.QtCore.QTimeZone.OffsetData',)],
-    "PySide2.QtCore.QTimeZone.OffsetData.__copy__": (),
-# class PySide2.QtCore.QTimeZone.TimeType:
-    "PySide2.QtCore.QTimeZone.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'int', 'str', 'str', 'PySide2.QtCore.QLocale.Country', 'str'), ('PySide2.QtCore.QTimeZone',), ('int',)],
-    "PySide2.QtCore.QTimeZone.__copy__": (),
-    "PySide2.QtCore.QTimeZone.abbreviation": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.availableTimeZoneIds": [(), ('PySide2.QtCore.QLocale.Country',), ('int',)],
-    "PySide2.QtCore.QTimeZone.comment": (),
-    "PySide2.QtCore.QTimeZone.country": (),
-    "PySide2.QtCore.QTimeZone.daylightTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.displayName": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale'), ('PySide2.QtCore.QTimeZone.TimeType', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale')],
-    "PySide2.QtCore.QTimeZone.hasDaylightTime": (),
-    "PySide2.QtCore.QTimeZone.hasTransitions": (),
-    "PySide2.QtCore.QTimeZone.ianaIdToWindowsId": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.id": (),
-    "PySide2.QtCore.QTimeZone.isDaylightTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.isTimeZoneIdAvailable": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.isValid": (),
-    "PySide2.QtCore.QTimeZone.nextTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetData": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetFromUtc": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.previousTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.standardTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.swap": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QTimeZone.systemTimeZone": (),
-    "PySide2.QtCore.QTimeZone.systemTimeZoneId": (),
-    "PySide2.QtCore.QTimeZone.transitions": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtCore.QTimeZone.utc": (),
-    "PySide2.QtCore.QTimeZone.windowsIdToDefaultIanaId": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-    "PySide2.QtCore.QTimeZone.windowsIdToIanaIds": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-# class PySide2.QtCore.QTimer:
-    "PySide2.QtCore.QTimer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTimer.interval": (),
-    "PySide2.QtCore.QTimer.isActive": (),
-    "PySide2.QtCore.QTimer.isSingleShot": (),
-    "PySide2.QtCore.QTimer.killTimer": ('int',),
-    "PySide2.QtCore.QTimer.remainingTime": (),
-    "PySide2.QtCore.QTimer.setInterval": ('int',),
-    "PySide2.QtCore.QTimer.setSingleShot": ('bool',),
-    "PySide2.QtCore.QTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QTimer.singleShot": [('int', 'PySide2.QtCore.QObject', 'bytes'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject', 'bytes'), ('int', 'typing.Callable')],
-    "PySide2.QtCore.QTimer.start": [(), ('int',)],
-    "PySide2.QtCore.QTimer.stop": (),
-    "PySide2.QtCore.QTimer.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimer.timerId": (),
-    "PySide2.QtCore.QTimer.timerType": (),
-# class PySide2.QtCore.QTimerEvent:
-    "PySide2.QtCore.QTimerEvent.__init__": ('int',),
-    "PySide2.QtCore.QTimerEvent.timerId": (),
-# class PySide2.QtCore.QTranslator:
-    "PySide2.QtCore.QTranslator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTranslator.isEmpty": (),
-    "PySide2.QtCore.QTranslator.load": [('PySide2.QtCore.QLocale', 'str', 'str', 'str', 'str'), ('bytes', 'int', 'str'), ('str', 'str', 'str', 'str')],
-    "PySide2.QtCore.QTranslator.translate": ('bytes', 'bytes', 'bytes', 'int'),
-# class PySide2.QtCore.QTransposeProxyModel:
-    "PySide2.QtCore.QTransposeProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTransposeProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QTransposeProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtCore.QTransposeProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QTransposeProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QTransposeProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QUrl:
-# class PySide2.QtCore.QUrl.ComponentFormattingOption:
-# class PySide2.QtCore.QUrl.FormattingOptions:
-# class PySide2.QtCore.QUrl.ParsingMode:
-# class PySide2.QtCore.QUrl.UrlFormattingOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOptions:
-    "PySide2.QtCore.QUrl.__init__": [(), ('PySide2.QtCore.QUrl',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.__copy__": (),
-    "PySide2.QtCore.QUrl.__reduce__": (),
-    "PySide2.QtCore.QUrl.__repr__": (),
-    "PySide2.QtCore.QUrl.adjusted": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.authority": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.clear": (),
-    "PySide2.QtCore.QUrl.errorString": (),
-    "PySide2.QtCore.QUrl.fileName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fragment": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fromAce": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromEncoded": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromLocalFile": ('str',),
-    "PySide2.QtCore.QUrl.fromPercentEncoding": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromStringList": ('typing.Sequence', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromUserInput": [('str',), ('str', 'str', 'PySide2.QtCore.QUrl.UserInputResolutionOptions')],
-    "PySide2.QtCore.QUrl.hasFragment": (),
-    "PySide2.QtCore.QUrl.hasQuery": (),
-    "PySide2.QtCore.QUrl.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.idnWhitelist": (),
-    "PySide2.QtCore.QUrl.isEmpty": (),
-    "PySide2.QtCore.QUrl.isLocalFile": (),
-    "PySide2.QtCore.QUrl.isParentOf": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.isRelative": (),
-    "PySide2.QtCore.QUrl.isValid": (),
-    "PySide2.QtCore.QUrl.matches": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.password": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.path": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.port": ('int',),
-    "PySide2.QtCore.QUrl.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.resolved": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.scheme": (),
-    "PySide2.QtCore.QUrl.setAuthority": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setFragment": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setIdnWhitelist": ('typing.Sequence',),
-    "PySide2.QtCore.QUrl.setPassword": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPath": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPort": ('int',),
-    "PySide2.QtCore.QUrl.setQuery": [('PySide2.QtCore.QUrlQuery',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.setScheme": ('str',),
-    "PySide2.QtCore.QUrl.setUrl": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserInfo": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserName": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.swap": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.toAce": ('str',),
-    "PySide2.QtCore.QUrl.toDisplayString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toEncoded": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toLocalFile": (),
-    "PySide2.QtCore.QUrl.toPercentEncoding": ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QUrl.toString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toStringList": ('typing.Sequence', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.topLevelDomain": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.url": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.userInfo": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.userName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUrlQuery:
-    "PySide2.QtCore.QUrlQuery.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrlQuery',), ('str',)],
-    "PySide2.QtCore.QUrlQuery.__copy__": (),
-    "PySide2.QtCore.QUrlQuery.addQueryItem": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.allQueryItemValues": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.clear": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.hasQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.isEmpty": (),
-    "PySide2.QtCore.QUrlQuery.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryItemValue": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.queryItems": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.queryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.removeAllQueryItems": ('str',),
-    "PySide2.QtCore.QUrlQuery.removeQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQuery": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQueryDelimiters": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.setQueryItems": ('typing.Sequence',),
-    "PySide2.QtCore.QUrlQuery.swap": ('PySide2.QtCore.QUrlQuery',),
-    "PySide2.QtCore.QUrlQuery.toString": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUuid:
-# class PySide2.QtCore.QUuid.StringFormat:
-# class PySide2.QtCore.QUuid.Variant:
-# class PySide2.QtCore.QUuid.Version:
-    "PySide2.QtCore.QUuid.__init__": [(), ('PySide2.QtCore.QByteArray',), ('bytes',), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'), ('str',)],
-    "PySide2.QtCore.QUuid.__copy__": (),
-    "PySide2.QtCore.QUuid.__reduce__": (),
-    "PySide2.QtCore.QUuid.__repr__": (),
-    "PySide2.QtCore.QUuid.createUuid": (),
-    "PySide2.QtCore.QUuid.createUuidV3": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.createUuidV5": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.fromRfc4122": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUuid.isNull": (),
-    "PySide2.QtCore.QUuid.toByteArray": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.toRfc4122": (),
-    "PySide2.QtCore.QUuid.toString": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.variant": (),
-    "PySide2.QtCore.QUuid.version": (),
-# class PySide2.QtCore.QVariantAnimation:
-    "PySide2.QtCore.QVariantAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QVariantAnimation.currentValue": (),
-    "PySide2.QtCore.QVariantAnimation.duration": (),
-    "PySide2.QtCore.QVariantAnimation.easingCurve": (),
-    "PySide2.QtCore.QVariantAnimation.endValue": (),
-    "PySide2.QtCore.QVariantAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QVariantAnimation.interpolated": ('typing.Any', 'typing.Any', 'float'),
-    "PySide2.QtCore.QVariantAnimation.keyValueAt": ('float',),
-    "PySide2.QtCore.QVariantAnimation.keyValues": (),
-    "PySide2.QtCore.QVariantAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QVariantAnimation.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QVariantAnimation.setEndValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.setKeyValueAt": ('float', 'typing.Any'),
-    "PySide2.QtCore.QVariantAnimation.setKeyValues": ('typing.List',),
-    "PySide2.QtCore.QVariantAnimation.setStartValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.startValue": (),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QVersionNumber:
-    "PySide2.QtCore.QVersionNumber.__init__": [(), ('int',), ('int', 'int'), ('int', 'int', 'int'), ('typing.List',)],
-    "PySide2.QtCore.QVersionNumber.__copy__": (),
-    "PySide2.QtCore.QVersionNumber.commonPrefix": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.compare": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.fromString": ('str',),
-    "PySide2.QtCore.QVersionNumber.isNormalized": (),
-    "PySide2.QtCore.QVersionNumber.isNull": (),
-    "PySide2.QtCore.QVersionNumber.isPrefixOf": ('PySide2.QtCore.QVersionNumber',),
-    "PySide2.QtCore.QVersionNumber.majorVersion": (),
-    "PySide2.QtCore.QVersionNumber.microVersion": (),
-    "PySide2.QtCore.QVersionNumber.minorVersion": (),
-    "PySide2.QtCore.QVersionNumber.normalized": (),
-    "PySide2.QtCore.QVersionNumber.segmentAt": ('int',),
-    "PySide2.QtCore.QVersionNumber.segmentCount": (),
-    "PySide2.QtCore.QVersionNumber.segments": (),
-    "PySide2.QtCore.QVersionNumber.toString": (),
-# class PySide2.QtCore.QWaitCondition:
-    "PySide2.QtCore.QWaitCondition.__init__": (),
-    "PySide2.QtCore.QWaitCondition.notify_all": (),
-    "PySide2.QtCore.QWaitCondition.notify_one": (),
-    "PySide2.QtCore.QWaitCondition.wait": [('PySide2.QtCore.QMutex', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QMutex', 'int'), ('PySide2.QtCore.QReadWriteLock', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QReadWriteLock', 'int')],
-    "PySide2.QtCore.QWaitCondition.wakeAll": (),
-    "PySide2.QtCore.QWaitCondition.wakeOne": (),
-# class PySide2.QtCore.QWinEventNotifier:
-    "PySide2.QtCore.QWinEventNotifier.__init__": [('PySide2.QtCore.QObject',), ('int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QWinEventNotifier.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QWinEventNotifier.handle": (),
-    "PySide2.QtCore.QWinEventNotifier.isEnabled": (),
-    "PySide2.QtCore.QWinEventNotifier.setEnabled": ('bool',),
-    "PySide2.QtCore.QWinEventNotifier.setHandle": ('int',),
-# class PySide2.QtCore.QWriteLocker:
-    "PySide2.QtCore.QWriteLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QWriteLocker.__enter__": (),
-    "PySide2.QtCore.QWriteLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QWriteLocker.readWriteLock": (),
-    "PySide2.QtCore.QWriteLocker.relock": (),
-    "PySide2.QtCore.QWriteLocker.unlock": (),
-# class PySide2.QtCore.QXmlStreamAttribute:
-    "PySide2.QtCore.QXmlStreamAttribute.__init__": [(), ('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttribute.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttribute.isDefault": (),
-    "PySide2.QtCore.QXmlStreamAttribute.name": (),
-    "PySide2.QtCore.QXmlStreamAttribute.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamAttribute.prefix": (),
-    "PySide2.QtCore.QXmlStreamAttribute.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamAttribute.value": (),
-# class PySide2.QtCore.QXmlStreamAttributes:
-    "PySide2.QtCore.QXmlStreamAttributes.__init__": [(), ('PySide2.QtCore.QXmlStreamAttributes',)],
-    "PySide2.QtCore.QXmlStreamAttributes.__add__": ('typing.List',),
-    "PySide2.QtCore.QXmlStreamAttributes.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttributes.__iadd__": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.__lshift__": [('PySide2.QtCore.QXmlStreamAttribute',), ('typing.List',)],
-    "PySide2.QtCore.QXmlStreamAttributes.append": [('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.at": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.back": (),
-    "PySide2.QtCore.QXmlStreamAttributes.capacity": (),
-    "PySide2.QtCore.QXmlStreamAttributes.clear": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constData": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.contains": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.count": [(), ('PySide2.QtCore.QXmlStreamAttribute',)],
-    "PySide2.QtCore.QXmlStreamAttributes.data": (),
-    "PySide2.QtCore.QXmlStreamAttributes.empty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.endsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.fill": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.first": (),
-    "PySide2.QtCore.QXmlStreamAttributes.front": (),
-    "PySide2.QtCore.QXmlStreamAttributes.hasAttribute": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.indexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.insert": [('int', 'PySide2.QtCore.QXmlStreamAttribute'), ('int', 'int', 'PySide2.QtCore.QXmlStreamAttribute')],
-    "PySide2.QtCore.QXmlStreamAttributes.isEmpty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.isSharedWith": ('typing.List',),
-    "PySide2.QtCore.QXmlStreamAttributes.last": (),
-    "PySide2.QtCore.QXmlStreamAttributes.lastIndexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.length": (),
-    "PySide2.QtCore.QXmlStreamAttributes.mid": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.move": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.prepend": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.remove": [('int',), ('int', 'int')],
-    "PySide2.QtCore.QXmlStreamAttributes.removeAll": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeOne": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.replace": ('int', 'PySide2.QtCore.QXmlStreamAttribute'),
-    "PySide2.QtCore.QXmlStreamAttributes.reserve": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.resize": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.setSharable": ('bool',),
-    "PySide2.QtCore.QXmlStreamAttributes.shrink_to_fit": (),
-    "PySide2.QtCore.QXmlStreamAttributes.size": (),
-    "PySide2.QtCore.QXmlStreamAttributes.squeeze": (),
-    "PySide2.QtCore.QXmlStreamAttributes.startsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.swap": ('typing.List',),
-    "PySide2.QtCore.QXmlStreamAttributes.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.takeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.takeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.takeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.value": [('str',), ('str', 'str')],
-# class PySide2.QtCore.QXmlStreamEntityDeclaration:
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamEntityDeclaration',)],
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.notationName": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.systemId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.value": (),
-# class PySide2.QtCore.QXmlStreamEntityResolver:
-    "PySide2.QtCore.QXmlStreamEntityResolver.__init__": (),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveEntity": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveUndeclaredEntity": ('str',),
-# class PySide2.QtCore.QXmlStreamNamespaceDeclaration:
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.prefix": (),
-# class PySide2.QtCore.QXmlStreamNotationDeclaration:
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNotationDeclaration',)],
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.systemId": (),
-# class PySide2.QtCore.QXmlStreamReader:
-# class PySide2.QtCore.QXmlStreamReader.Error:
-# class PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour:
-# class PySide2.QtCore.QXmlStreamReader.TokenType:
-    "PySide2.QtCore.QXmlStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytes',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclaration": ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',),
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclarations": ('typing.List',),
-    "PySide2.QtCore.QXmlStreamReader.atEnd": (),
-    "PySide2.QtCore.QXmlStreamReader.attributes": (),
-    "PySide2.QtCore.QXmlStreamReader.characterOffset": (),
-    "PySide2.QtCore.QXmlStreamReader.clear": (),
-    "PySide2.QtCore.QXmlStreamReader.columnNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.device": (),
-    "PySide2.QtCore.QXmlStreamReader.documentEncoding": (),
-    "PySide2.QtCore.QXmlStreamReader.documentVersion": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdName": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdPublicId": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdSystemId": (),
-    "PySide2.QtCore.QXmlStreamReader.entityDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.entityResolver": (),
-    "PySide2.QtCore.QXmlStreamReader.error": (),
-    "PySide2.QtCore.QXmlStreamReader.errorString": (),
-    "PySide2.QtCore.QXmlStreamReader.hasError": (),
-    "PySide2.QtCore.QXmlStreamReader.isCDATA": (),
-    "PySide2.QtCore.QXmlStreamReader.isCharacters": (),
-    "PySide2.QtCore.QXmlStreamReader.isComment": (),
-    "PySide2.QtCore.QXmlStreamReader.isDTD": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isEntityReference": (),
-    "PySide2.QtCore.QXmlStreamReader.isProcessingInstruction": (),
-    "PySide2.QtCore.QXmlStreamReader.isStandaloneDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isWhitespace": (),
-    "PySide2.QtCore.QXmlStreamReader.lineNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.name": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceProcessing": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamReader.notationDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.prefix": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionData": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionTarget": (),
-    "PySide2.QtCore.QXmlStreamReader.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamReader.raiseError": ('str',),
-    "PySide2.QtCore.QXmlStreamReader.readElementText": ('PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour',),
-    "PySide2.QtCore.QXmlStreamReader.readNext": (),
-    "PySide2.QtCore.QXmlStreamReader.readNextStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamReader.setEntityResolver": ('PySide2.QtCore.QXmlStreamEntityResolver',),
-    "PySide2.QtCore.QXmlStreamReader.setNamespaceProcessing": ('bool',),
-    "PySide2.QtCore.QXmlStreamReader.skipCurrentElement": (),
-    "PySide2.QtCore.QXmlStreamReader.text": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenString": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenType": (),
-# class PySide2.QtCore.QXmlStreamWriter:
-    "PySide2.QtCore.QXmlStreamWriter.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QXmlStreamWriter.autoFormatting": (),
-    "PySide2.QtCore.QXmlStreamWriter.autoFormattingIndent": (),
-    "PySide2.QtCore.QXmlStreamWriter.codec": (),
-    "PySide2.QtCore.QXmlStreamWriter.device": (),
-    "PySide2.QtCore.QXmlStreamWriter.hasError": (),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormatting": ('bool',),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormattingIndent": ('int',),
-    "PySide2.QtCore.QXmlStreamWriter.setCodec": [('PySide2.QtCore.QTextCodec',), ('bytes',)],
-    "PySide2.QtCore.QXmlStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamWriter.writeAttribute": [('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeAttributes": ('PySide2.QtCore.QXmlStreamAttributes',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCDATA": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCharacters": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeComment": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCurrentToken": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDTD": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDefaultNamespace": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeEmptyElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeEndDocument": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEndElement": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEntityReference": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeNamespace": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeProcessingInstruction": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeStartDocument": [(), ('str',), ('str', 'bool')],
-    "PySide2.QtCore.QXmlStreamWriter.writeStartElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeTextElement": [('str', 'str'), ('str', 'str', 'str')],
-# class PySide2.QtCore.Qt:
-# class PySide2.QtCore.Qt.Alignment:
-# class PySide2.QtCore.Qt.AlignmentFlag:
-# class PySide2.QtCore.Qt.AnchorPoint:
-# class PySide2.QtCore.Qt.ApplicationAttribute:
-# class PySide2.QtCore.Qt.ApplicationState:
-# class PySide2.QtCore.Qt.ApplicationStates:
-# class PySide2.QtCore.Qt.ArrowType:
-# class PySide2.QtCore.Qt.AspectRatioMode:
-# class PySide2.QtCore.Qt.Axis:
-# class PySide2.QtCore.Qt.BGMode:
-# class PySide2.QtCore.Qt.BrushStyle:
-# class PySide2.QtCore.Qt.CaseSensitivity:
-# class PySide2.QtCore.Qt.CheckState:
-# class PySide2.QtCore.Qt.ChecksumType:
-# class PySide2.QtCore.Qt.ClipOperation:
-# class PySide2.QtCore.Qt.ConnectionType:
-# class PySide2.QtCore.Qt.ContextMenuPolicy:
-# class PySide2.QtCore.Qt.CoordinateSystem:
-# class PySide2.QtCore.Qt.Corner:
-# class PySide2.QtCore.Qt.CursorMoveStyle:
-# class PySide2.QtCore.Qt.CursorShape:
-# class PySide2.QtCore.Qt.DateFormat:
-# class PySide2.QtCore.Qt.DayOfWeek:
-# class PySide2.QtCore.Qt.DockWidgetArea:
-# class PySide2.QtCore.Qt.DockWidgetAreaSizes:
-# class PySide2.QtCore.Qt.DockWidgetAreas:
-# class PySide2.QtCore.Qt.DropAction:
-# class PySide2.QtCore.Qt.DropActions:
-# class PySide2.QtCore.Qt.Edge:
-# class PySide2.QtCore.Qt.Edges:
-# class PySide2.QtCore.Qt.EnterKeyType:
-# class PySide2.QtCore.Qt.EventPriority:
-# class PySide2.QtCore.Qt.FillRule:
-# class PySide2.QtCore.Qt.FindChildOption:
-# class PySide2.QtCore.Qt.FindChildOptions:
-# class PySide2.QtCore.Qt.FocusPolicy:
-# class PySide2.QtCore.Qt.FocusReason:
-# class PySide2.QtCore.Qt.GestureFlag:
-# class PySide2.QtCore.Qt.GestureFlags:
-# class PySide2.QtCore.Qt.GestureState:
-# class PySide2.QtCore.Qt.GestureType:
-# class PySide2.QtCore.Qt.GlobalColor:
-# class PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy:
-# class PySide2.QtCore.Qt.HitTestAccuracy:
-# class PySide2.QtCore.Qt.ImageConversionFlag:
-# class PySide2.QtCore.Qt.ImageConversionFlags:
-# class PySide2.QtCore.Qt.InputMethodHint:
-# class PySide2.QtCore.Qt.InputMethodHints:
-# class PySide2.QtCore.Qt.InputMethodQueries:
-# class PySide2.QtCore.Qt.InputMethodQuery:
-# class PySide2.QtCore.Qt.ItemDataRole:
-# class PySide2.QtCore.Qt.ItemFlag:
-# class PySide2.QtCore.Qt.ItemFlags:
-# class PySide2.QtCore.Qt.ItemSelectionMode:
-# class PySide2.QtCore.Qt.ItemSelectionOperation:
-# class PySide2.QtCore.Qt.Key:
-# class PySide2.QtCore.Qt.KeyboardModifier:
-# class PySide2.QtCore.Qt.KeyboardModifiers:
-# class PySide2.QtCore.Qt.LayoutDirection:
-# class PySide2.QtCore.Qt.MaskMode:
-# class PySide2.QtCore.Qt.MatchFlag:
-# class PySide2.QtCore.Qt.MatchFlags:
-# class PySide2.QtCore.Qt.Modifier:
-# class PySide2.QtCore.Qt.MouseButton:
-# class PySide2.QtCore.Qt.MouseButtons:
-# class PySide2.QtCore.Qt.MouseEventFlag:
-# class PySide2.QtCore.Qt.MouseEventFlags:
-# class PySide2.QtCore.Qt.MouseEventSource:
-# class PySide2.QtCore.Qt.NativeGestureType:
-# class PySide2.QtCore.Qt.NavigationMode:
-# class PySide2.QtCore.Qt.Orientation:
-# class PySide2.QtCore.Qt.Orientations:
-# class PySide2.QtCore.Qt.PenCapStyle:
-# class PySide2.QtCore.Qt.PenJoinStyle:
-# class PySide2.QtCore.Qt.PenStyle:
-# class PySide2.QtCore.Qt.ScreenOrientation:
-# class PySide2.QtCore.Qt.ScreenOrientations:
-# class PySide2.QtCore.Qt.ScrollBarPolicy:
-# class PySide2.QtCore.Qt.ScrollPhase:
-# class PySide2.QtCore.Qt.ShortcutContext:
-# class PySide2.QtCore.Qt.SizeHint:
-# class PySide2.QtCore.Qt.SizeMode:
-# class PySide2.QtCore.Qt.SortOrder:
-# class PySide2.QtCore.Qt.SplitBehavior:
-# class PySide2.QtCore.Qt.SplitBehaviorFlags:
-# class PySide2.QtCore.Qt.TabFocusBehavior:
-# class PySide2.QtCore.Qt.TextElideMode:
-# class PySide2.QtCore.Qt.TextFlag:
-# class PySide2.QtCore.Qt.TextFormat:
-# class PySide2.QtCore.Qt.TextInteractionFlag:
-# class PySide2.QtCore.Qt.TextInteractionFlags:
-# class PySide2.QtCore.Qt.TileRule:
-# class PySide2.QtCore.Qt.TimeSpec:
-# class PySide2.QtCore.Qt.TimerType:
-# class PySide2.QtCore.Qt.ToolBarArea:
-# class PySide2.QtCore.Qt.ToolBarAreaSizes:
-# class PySide2.QtCore.Qt.ToolBarAreas:
-# class PySide2.QtCore.Qt.ToolButtonStyle:
-# class PySide2.QtCore.Qt.TouchPointState:
-# class PySide2.QtCore.Qt.TouchPointStates:
-# class PySide2.QtCore.Qt.TransformationMode:
-# class PySide2.QtCore.Qt.UIEffect:
-# class PySide2.QtCore.Qt.WhiteSpaceMode:
-# class PySide2.QtCore.Qt.WidgetAttribute:
-# class PySide2.QtCore.Qt.WindowFlags:
-# class PySide2.QtCore.Qt.WindowFrameSection:
-# class PySide2.QtCore.Qt.WindowModality:
-# class PySide2.QtCore.Qt.WindowState:
-# class PySide2.QtCore.Qt.WindowStates:
-# class PySide2.QtCore.Qt.WindowType:
-# class PySide2.QtCore.QtMsgType:
-# class PySide2.QtCore.Signal:
-    "PySide2.QtCore.Signal.__init__": ('type', 'str', 'str'),
-# class PySide2.QtCore.SignalInstance:
-    "PySide2.QtCore.SignalInstance.connect": ('object', 'type'),
-    "PySide2.QtCore.SignalInstance.disconnect": ('object',),
-    "PySide2.QtCore.SignalInstance.emit": ('typing.Any',),
-# class PySide2.QtCore.Slot:
-    "PySide2.QtCore.Slot.__init__": ('type', 'str', 'str'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP": ('object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP3": ('object', 'object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.SIGNAL": ('bytes',),
-    "PySide2.QtCore.Slot.SLOT": ('bytes',),
-    "PySide2.QtCore.Slot.__moduleShutdown": (),
-    "PySide2.QtCore.Slot.qAbs": ('float',),
-    "PySide2.QtCore.Slot.qAcos": ('float',),
-    "PySide2.QtCore.Slot.qAddPostRoutine": ('object',),
-    "PySide2.QtCore.Slot.qAsin": ('float',),
-    "PySide2.QtCore.Slot.qAtan": ('float',),
-    "PySide2.QtCore.Slot.qAtan2": ('float', 'float'),
-    "PySide2.QtCore.Slot.qChecksum": ('bytes', 'int'),
-    "PySide2.QtCore.Slot.qCompress": [('PySide2.QtCore.QByteArray', 'int'), ('bytes', 'int', 'int')],
-    "PySide2.QtCore.Slot.qCritical": ('bytes',),
-    "PySide2.QtCore.Slot.qDebug": ('bytes',),
-    "PySide2.QtCore.Slot.qExp": ('float',),
-    "PySide2.QtCore.Slot.qFabs": ('float',),
-    "PySide2.QtCore.Slot.qFastCos": ('float',),
-    "PySide2.QtCore.Slot.qFastSin": ('float',),
-    "PySide2.QtCore.Slot.qFatal": ('bytes',),
-    "PySide2.QtCore.Slot.qFuzzyCompare": ('float', 'float'),
-    "PySide2.QtCore.Slot.qFuzzyIsNull": ('float',),
-    "PySide2.QtCore.Slot.qInstallMessageHandler": ('object',),
-    "PySide2.QtCore.Slot.qIsFinite": ('float',),
-    "PySide2.QtCore.Slot.qIsInf": ('float',),
-    "PySide2.QtCore.Slot.qIsNaN": ('float',),
-    "PySide2.QtCore.Slot.qIsNull": ('float',),
-    "PySide2.QtCore.Slot.qRegisterResourceData": ('int', 'bytes', 'bytes', 'bytes'),
-    "PySide2.QtCore.Slot.qTan": ('float',),
-    "PySide2.QtCore.Slot.qUncompress": [('PySide2.QtCore.QByteArray',), ('bytes', 'int')],
-    "PySide2.QtCore.Slot.qUnregisterResourceData": ('int', 'bytes', 'bytes', 'bytes'),
-    "PySide2.QtCore.Slot.qVersion": (),
-    "PySide2.QtCore.Slot.qWarning": ('bytes',),
-    "PySide2.QtCore.Slot.qrand": (),
-    "PySide2.QtCore.Slot.qsrand": ('int',),
-    "PySide2.QtCore.Slot.qtTrId": ('bytes', 'int'),
-    }) if "PySide2.QtCore" in sys.modules else None
-# Module PySide2.QtGui
-sig_dict.update({
-# class PySide2.QtGui.QAbstractOpenGLFunctions:
-    "PySide2.QtGui.QAbstractOpenGLFunctions.__init__": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.isInitialized": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.owningContext": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.setOwningContext": ('PySide2.QtGui.QOpenGLContext',),
-# class PySide2.QtGui.QAbstractTextDocumentLayout:
-# class PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__copy__": (),
-# class PySide2.QtGui.QAbstractTextDocumentLayout.Selection:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.Selection',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__copy__": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.anchorAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockWithMarkerAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.document": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentSize": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.drawInlineObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.format": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatIndex": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.handlerForObject": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.imageAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.pageCount": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.paintDevice": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.positionInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.registerHandler": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.resizeInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.setPaintDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.unregisterHandler": ('int', 'PySide2.QtCore.QObject'),
-# class PySide2.QtGui.QAccessible:
-# class PySide2.QtGui.QAccessible.Event:
-# class PySide2.QtGui.QAccessible.InterfaceType:
-# class PySide2.QtGui.QAccessible.Relation:
-# class PySide2.QtGui.QAccessible.RelationFlag:
-# class PySide2.QtGui.QAccessible.Role:
-# class PySide2.QtGui.QAccessible.State:
-    "PySide2.QtGui.QAccessible.State.__init__": [(), ('PySide2.QtGui.QAccessible.State',)],
-    "PySide2.QtGui.QAccessible.State.__copy__": (),
-# class PySide2.QtGui.QAccessible.Text:
-# class PySide2.QtGui.QAccessible.TextBoundaryType:
-    "PySide2.QtGui.QAccessible.__copy__": (),
-    "PySide2.QtGui.QAccessible.accessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.cleanup": (),
-    "PySide2.QtGui.QAccessible.deleteAccessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.isActive": (),
-    "PySide2.QtGui.QAccessible.qAccessibleTextBoundaryHelper": ('PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessible.queryAccessibleInterface": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.registerAccessibleInterface": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.setActive": ('bool',),
-    "PySide2.QtGui.QAccessible.setRootObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.uniqueId": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.updateAccessibility": ('PySide2.QtGui.QAccessibleEvent',),
-# class PySide2.QtGui.QAccessibleEditableTextInterface:
-    "PySide2.QtGui.QAccessibleEditableTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.deleteText": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.insertText": ('int', 'str'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.replaceText": ('int', 'int', 'str'),
-# class PySide2.QtGui.QAccessibleEvent:
-    "PySide2.QtGui.QAccessibleEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.Event'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.Event')],
-    "PySide2.QtGui.QAccessibleEvent.accessibleInterface": (),
-    "PySide2.QtGui.QAccessibleEvent.child": (),
-    "PySide2.QtGui.QAccessibleEvent.object": (),
-    "PySide2.QtGui.QAccessibleEvent.setChild": ('int',),
-    "PySide2.QtGui.QAccessibleEvent.type": (),
-    "PySide2.QtGui.QAccessibleEvent.uniqueId": (),
-# class PySide2.QtGui.QAccessibleInterface:
-    "PySide2.QtGui.QAccessibleInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleInterface.backgroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.child": ('int',),
-    "PySide2.QtGui.QAccessibleInterface.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.childCount": (),
-    "PySide2.QtGui.QAccessibleInterface.editableTextInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.focusChild": (),
-    "PySide2.QtGui.QAccessibleInterface.foregroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessibleInterface.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtGui.QAccessibleInterface.isValid": (),
-    "PySide2.QtGui.QAccessibleInterface.object": (),
-    "PySide2.QtGui.QAccessibleInterface.parent": (),
-    "PySide2.QtGui.QAccessibleInterface.rect": (),
-    "PySide2.QtGui.QAccessibleInterface.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtGui.QAccessibleInterface.role": (),
-    "PySide2.QtGui.QAccessibleInterface.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-    "PySide2.QtGui.QAccessibleInterface.state": (),
-    "PySide2.QtGui.QAccessibleInterface.tableCellInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtGui.QAccessibleInterface.textInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.valueInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.virtual_hook": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.window": (),
-# class PySide2.QtGui.QAccessibleObject:
-    "PySide2.QtGui.QAccessibleObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessibleObject.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleObject.isValid": (),
-    "PySide2.QtGui.QAccessibleObject.object": (),
-    "PySide2.QtGui.QAccessibleObject.rect": (),
-    "PySide2.QtGui.QAccessibleObject.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-# class PySide2.QtGui.QAccessibleStateChangeEvent:
-    "PySide2.QtGui.QAccessibleStateChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.State'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.State')],
-    "PySide2.QtGui.QAccessibleStateChangeEvent.changedStates": (),
-# class PySide2.QtGui.QAccessibleTableCellInterface:
-    "PySide2.QtGui.QAccessibleTableCellInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.isSelected": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.table": (),
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent:
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType:
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType')],
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.modelChangeType": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setModelChangeType": ('PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType',),
-# class PySide2.QtGui.QAccessibleTextCursorEvent:
-    "PySide2.QtGui.QAccessibleTextCursorEvent.__init__": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int')],
-    "PySide2.QtGui.QAccessibleTextCursorEvent.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextCursorEvent.setCursorPosition": ('int',),
-# class PySide2.QtGui.QAccessibleTextInsertEvent:
-    "PySide2.QtGui.QAccessibleTextInsertEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextInsertEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextInsertEvent.textInserted": (),
-# class PySide2.QtGui.QAccessibleTextInterface:
-    "PySide2.QtGui.QAccessibleTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTextInterface.addSelection": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.attributes": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.characterCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.characterRect": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextInterface.offsetAtPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QAccessibleTextInterface.removeSelection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.scrollToSubstring": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.selection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.selectionCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.setCursorPosition": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.setSelection": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.text": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAfterOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAtOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textBeforeOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-# class PySide2.QtGui.QAccessibleTextRemoveEvent:
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleTextSelectionEvent:
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'int')],
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionEnd": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionStart": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.setSelection": ('int', 'int'),
-# class PySide2.QtGui.QAccessibleTextUpdateEvent:
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str', 'str')],
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textInserted": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleValueChangeEvent:
-    "PySide2.QtGui.QAccessibleValueChangeEvent.__init__": [('PySide2.QtCore.QObject', 'typing.Any'), ('PySide2.QtGui.QAccessibleInterface', 'typing.Any')],
-    "PySide2.QtGui.QAccessibleValueChangeEvent.setValue": ('typing.Any',),
-    "PySide2.QtGui.QAccessibleValueChangeEvent.value": (),
-# class PySide2.QtGui.QAccessibleValueInterface:
-    "PySide2.QtGui.QAccessibleValueInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleValueInterface.currentValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.maximumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumStepSize": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.setCurrentValue": ('typing.Any',),
-# class PySide2.QtGui.QActionEvent:
-# class PySide2.QtGui.QBackingStore:
-    "PySide2.QtGui.QBackingStore.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QBackingStore.beginPaint": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.endPaint": (),
-    "PySide2.QtGui.QBackingStore.flush": ('PySide2.QtGui.QRegion', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QBackingStore.hasStaticContents": (),
-    "PySide2.QtGui.QBackingStore.paintDevice": (),
-    "PySide2.QtGui.QBackingStore.resize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QBackingStore.scroll": ('PySide2.QtGui.QRegion', 'int', 'int'),
-    "PySide2.QtGui.QBackingStore.setStaticContents": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.size": (),
-    "PySide2.QtGui.QBackingStore.staticContents": (),
-    "PySide2.QtGui.QBackingStore.window": (),
-# class PySide2.QtGui.QBitmap:
-    "PySide2.QtGui.QBitmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'bytes')],
-    "PySide2.QtGui.QBitmap.__copy__": (),
-    "PySide2.QtGui.QBitmap.clear": (),
-    "PySide2.QtGui.QBitmap.fromData": ('PySide2.QtCore.QSize', 'bytes', 'PySide2.QtGui.QImage.Format'),
-    "PySide2.QtGui.QBitmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QBitmap.swap": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBitmap.transformed": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform',)],
-# class PySide2.QtGui.QBrush:
-    "PySide2.QtGui.QBrush.__init__": [(), ('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QBrush',), ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBrush.__copy__": (),
-    "PySide2.QtGui.QBrush.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.color": (),
-    "PySide2.QtGui.QBrush.gradient": (),
-    "PySide2.QtGui.QBrush.isOpaque": (),
-    "PySide2.QtGui.QBrush.matrix": (),
-    "PySide2.QtGui.QBrush.setColor": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',)],
-    "PySide2.QtGui.QBrush.setMatrix": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QBrush.setStyle": ('PySide2.QtCore.Qt.BrushStyle',),
-    "PySide2.QtGui.QBrush.setTexture": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QBrush.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QBrush.setTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QBrush.style": (),
-    "PySide2.QtGui.QBrush.swap": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QBrush.texture": (),
-    "PySide2.QtGui.QBrush.textureImage": (),
-    "PySide2.QtGui.QBrush.transform": (),
-# class PySide2.QtGui.QClipboard:
-# class PySide2.QtGui.QClipboard.Mode:
-    "PySide2.QtGui.QClipboard.clear": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.image": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.mimeData": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.ownsClipboard": (),
-    "PySide2.QtGui.QClipboard.ownsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.ownsSelection": (),
-    "PySide2.QtGui.QClipboard.pixmap": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.setImage": ('PySide2.QtGui.QImage', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setText": ('str', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.supportsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.supportsSelection": (),
-    "PySide2.QtGui.QClipboard.text": [('PySide2.QtGui.QClipboard.Mode',), ('str', 'PySide2.QtGui.QClipboard.Mode')],
-# class PySide2.QtGui.QCloseEvent:
-    "PySide2.QtGui.QCloseEvent.__init__": (),
-# class PySide2.QtGui.QColor:
-# class PySide2.QtGui.QColor.NameFormat:
-# class PySide2.QtGui.QColor.Spec:
-    "PySide2.QtGui.QColor.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('int',), ('int', 'int', 'int', 'int'), ('str',), ('typing.Any',)],
-    "PySide2.QtGui.QColor.__copy__": (),
-    "PySide2.QtGui.QColor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__reduce__": (),
-    "PySide2.QtGui.QColor.__repr__": (),
-    "PySide2.QtGui.QColor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__setstate__": ('object',),
-    "PySide2.QtGui.QColor.__str__": (),
-    "PySide2.QtGui.QColor.alpha": (),
-    "PySide2.QtGui.QColor.alphaF": (),
-    "PySide2.QtGui.QColor.black": (),
-    "PySide2.QtGui.QColor.blackF": (),
-    "PySide2.QtGui.QColor.blue": (),
-    "PySide2.QtGui.QColor.blueF": (),
-    "PySide2.QtGui.QColor.colorNames": (),
-    "PySide2.QtGui.QColor.convertTo": ('PySide2.QtGui.QColor.Spec',),
-    "PySide2.QtGui.QColor.cyan": (),
-    "PySide2.QtGui.QColor.cyanF": (),
-    "PySide2.QtGui.QColor.dark": ('int',),
-    "PySide2.QtGui.QColor.darker": ('int',),
-    "PySide2.QtGui.QColor.fromCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.fromRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgba": ('int',),
-    "PySide2.QtGui.QColor.fromRgba64": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.getCmyk": (),
-    "PySide2.QtGui.QColor.getCmykF": (),
-    "PySide2.QtGui.QColor.getHsl": (),
-    "PySide2.QtGui.QColor.getHslF": (),
-    "PySide2.QtGui.QColor.getHsv": (),
-    "PySide2.QtGui.QColor.getHsvF": (),
-    "PySide2.QtGui.QColor.getRgb": (),
-    "PySide2.QtGui.QColor.getRgbF": (),
-    "PySide2.QtGui.QColor.green": (),
-    "PySide2.QtGui.QColor.greenF": (),
-    "PySide2.QtGui.QColor.hslHue": (),
-    "PySide2.QtGui.QColor.hslHueF": (),
-    "PySide2.QtGui.QColor.hslSaturation": (),
-    "PySide2.QtGui.QColor.hslSaturationF": (),
-    "PySide2.QtGui.QColor.hsvHue": (),
-    "PySide2.QtGui.QColor.hsvHueF": (),
-    "PySide2.QtGui.QColor.hsvSaturation": (),
-    "PySide2.QtGui.QColor.hsvSaturationF": (),
-    "PySide2.QtGui.QColor.hue": (),
-    "PySide2.QtGui.QColor.hueF": (),
-    "PySide2.QtGui.QColor.isValid": (),
-    "PySide2.QtGui.QColor.isValidColor": ('str',),
-    "PySide2.QtGui.QColor.light": ('int',),
-    "PySide2.QtGui.QColor.lighter": ('int',),
-    "PySide2.QtGui.QColor.lightness": (),
-    "PySide2.QtGui.QColor.lightnessF": (),
-    "PySide2.QtGui.QColor.magenta": (),
-    "PySide2.QtGui.QColor.magentaF": (),
-    "PySide2.QtGui.QColor.name": [(), ('PySide2.QtGui.QColor.NameFormat',)],
-    "PySide2.QtGui.QColor.red": (),
-    "PySide2.QtGui.QColor.redF": (),
-    "PySide2.QtGui.QColor.rgb": (),
-    "PySide2.QtGui.QColor.rgba": (),
-    "PySide2.QtGui.QColor.saturation": (),
-    "PySide2.QtGui.QColor.saturationF": (),
-    "PySide2.QtGui.QColor.setAlpha": ('int',),
-    "PySide2.QtGui.QColor.setAlphaF": ('float',),
-    "PySide2.QtGui.QColor.setBlue": ('int',),
-    "PySide2.QtGui.QColor.setBlueF": ('float',),
-    "PySide2.QtGui.QColor.setCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setGreen": ('int',),
-    "PySide2.QtGui.QColor.setGreenF": ('float',),
-    "PySide2.QtGui.QColor.setHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setNamedColor": ('str',),
-    "PySide2.QtGui.QColor.setRed": ('int',),
-    "PySide2.QtGui.QColor.setRedF": ('float',),
-    "PySide2.QtGui.QColor.setRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.setRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setRgba": ('int',),
-    "PySide2.QtGui.QColor.spec": (),
-    "PySide2.QtGui.QColor.toCmyk": (),
-    "PySide2.QtGui.QColor.toExtendedRgb": (),
-    "PySide2.QtGui.QColor.toHsl": (),
-    "PySide2.QtGui.QColor.toHsv": (),
-    "PySide2.QtGui.QColor.toRgb": (),
-    "PySide2.QtGui.QColor.toTuple": (),
-    "PySide2.QtGui.QColor.value": (),
-    "PySide2.QtGui.QColor.valueF": (),
-    "PySide2.QtGui.QColor.yellow": (),
-    "PySide2.QtGui.QColor.yellowF": (),
-# class PySide2.QtGui.QColorSpace:
-# class PySide2.QtGui.QColorSpace.NamedColorSpace:
-# class PySide2.QtGui.QColorSpace.Primaries:
-# class PySide2.QtGui.QColorSpace.TransferFunction:
-    "PySide2.QtGui.QColorSpace.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace',), ('PySide2.QtGui.QColorSpace.NamedColorSpace',), ('PySide2.QtGui.QColorSpace.Primaries', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace.Primaries', 'float')],
-    "PySide2.QtGui.QColorSpace.__copy__": (),
-    "PySide2.QtGui.QColorSpace.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.fromIccProfile": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QColorSpace.gamma": (),
-    "PySide2.QtGui.QColorSpace.iccProfile": (),
-    "PySide2.QtGui.QColorSpace.isValid": (),
-    "PySide2.QtGui.QColorSpace.primaries": (),
-    "PySide2.QtGui.QColorSpace.setPrimaries": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QColorSpace.Primaries',)],
-    "PySide2.QtGui.QColorSpace.setTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-    "PySide2.QtGui.QColorSpace.swap": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QColorSpace.transferFunction": (),
-    "PySide2.QtGui.QColorSpace.withTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-# class PySide2.QtGui.QConicalGradient:
-    "PySide2.QtGui.QConicalGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QConicalGradient',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QConicalGradient.__copy__": (),
-    "PySide2.QtGui.QConicalGradient.angle": (),
-    "PySide2.QtGui.QConicalGradient.center": (),
-    "PySide2.QtGui.QConicalGradient.setAngle": ('float',),
-    "PySide2.QtGui.QConicalGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-# class PySide2.QtGui.QContextMenuEvent:
-# class PySide2.QtGui.QContextMenuEvent.Reason:
-    "PySide2.QtGui.QContextMenuEvent.__init__": [('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QContextMenuEvent.globalPos": (),
-    "PySide2.QtGui.QContextMenuEvent.globalX": (),
-    "PySide2.QtGui.QContextMenuEvent.global""Y": (),
-    "PySide2.QtGui.QContextMenuEvent.pos": (),
-    "PySide2.QtGui.QContextMenuEvent.reason": (),
-    "PySide2.QtGui.QContextMenuEvent.x": (),
-    "PySide2.QtGui.QContextMenuEvent.y": (),
-# class PySide2.QtGui.QCursor:
-    "PySide2.QtGui.QCursor.__init__": [(), ('PySide2.QtCore.Qt.CursorShape',), ('PySide2.QtGui.QBitmap', 'PySide2.QtGui.QBitmap', 'int', 'int'), ('PySide2.QtGui.QCursor',), ('PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QCursor.__copy__": (),
-    "PySide2.QtGui.QCursor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.bitmap": (),
-    "PySide2.QtGui.QCursor.hotSpot": (),
-    "PySide2.QtGui.QCursor.mask": (),
-    "PySide2.QtGui.QCursor.pixmap": (),
-    "PySide2.QtGui.QCursor.pos": [(), ('PySide2.QtGui.QScreen',)],
-    "PySide2.QtGui.QCursor.setPos": [('PySide2.QtCore.QPoint',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QScreen', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtGui.QCursor.setShape": ('PySide2.QtCore.Qt.CursorShape',),
-    "PySide2.QtGui.QCursor.shape": (),
-    "PySide2.QtGui.QCursor.swap": ('PySide2.QtGui.QCursor',),
-# class PySide2.QtGui.QDesktopServices:
-    "PySide2.QtGui.QDesktopServices.__init__": (),
-    "PySide2.QtGui.QDesktopServices.openUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QDesktopServices.setUrlHandler": ('str', 'PySide2.QtCore.QObject', 'bytes'),
-    "PySide2.QtGui.QDesktopServices.unsetUrlHandler": ('str',),
-# class PySide2.QtGui.QDoubleValidator:
-# class PySide2.QtGui.QDoubleValidator.Notation:
-    "PySide2.QtGui.QDoubleValidator.__init__": [('PySide2.QtCore.QObject',), ('float', 'float', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QDoubleValidator.bottom": (),
-    "PySide2.QtGui.QDoubleValidator.decimals": (),
-    "PySide2.QtGui.QDoubleValidator.notation": (),
-    "PySide2.QtGui.QDoubleValidator.setBottom": ('float',),
-    "PySide2.QtGui.QDoubleValidator.setDecimals": ('int',),
-    "PySide2.QtGui.QDoubleValidator.setNotation": ('PySide2.QtGui.QDoubleValidator.Notation',),
-    "PySide2.QtGui.QDoubleValidator.setRange": ('float', 'float', 'int'),
-    "PySide2.QtGui.QDoubleValidator.setTop": ('float',),
-    "PySide2.QtGui.QDoubleValidator.top": (),
-    "PySide2.QtGui.QDoubleValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QDrag:
-    "PySide2.QtGui.QDrag.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QDrag.cancel": (),
-    "PySide2.QtGui.QDrag.defaultAction": (),
-    "PySide2.QtGui.QDrag.dragCursor": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDrag.exec_": [('PySide2.QtCore.Qt.DropActions',), ('PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.Qt.DropAction')],
-    "PySide2.QtGui.QDrag.hotSpot": (),
-    "PySide2.QtGui.QDrag.mimeData": (),
-    "PySide2.QtGui.QDrag.pixmap": (),
-    "PySide2.QtGui.QDrag.setDragCursor": ('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtGui.QDrag.setHotSpot": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QDrag.setMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtGui.QDrag.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QDrag.source": (),
-    "PySide2.QtGui.QDrag.start": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtGui.QDrag.supportedActions": (),
-    "PySide2.QtGui.QDrag.target": (),
-# class PySide2.QtGui.QDragEnterEvent:
-    "PySide2.QtGui.QDragEnterEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-# class PySide2.QtGui.QDragLeaveEvent:
-    "PySide2.QtGui.QDragLeaveEvent.__init__": (),
-# class PySide2.QtGui.QDragMoveEvent:
-    "PySide2.QtGui.QDragMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDragMoveEvent.accept": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QDragMoveEvent.answerRect": (),
-    "PySide2.QtGui.QDragMoveEvent.ignore": [(), ('PySide2.QtCore.QRect',)],
-# class PySide2.QtGui.QDropEvent:
-    "PySide2.QtGui.QDropEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDropEvent.acceptProposedAction": (),
-    "PySide2.QtGui.QDropEvent.dropAction": (),
-    "PySide2.QtGui.QDropEvent.keyboardModifiers": (),
-    "PySide2.QtGui.QDropEvent.mimeData": (),
-    "PySide2.QtGui.QDropEvent.mouseButtons": (),
-    "PySide2.QtGui.QDropEvent.pos": (),
-    "PySide2.QtGui.QDropEvent.posF": (),
-    "PySide2.QtGui.QDropEvent.possibleActions": (),
-    "PySide2.QtGui.QDropEvent.proposedAction": (),
-    "PySide2.QtGui.QDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDropEvent.source": (),
-# class PySide2.QtGui.QEnterEvent:
-    "PySide2.QtGui.QEnterEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QEnterEvent.globalPos": (),
-    "PySide2.QtGui.QEnterEvent.globalX": (),
-    "PySide2.QtGui.QEnterEvent.global""Y": (),
-    "PySide2.QtGui.QEnterEvent.localPos": (),
-    "PySide2.QtGui.QEnterEvent.pos": (),
-    "PySide2.QtGui.QEnterEvent.screenPos": (),
-    "PySide2.QtGui.QEnterEvent.windowPos": (),
-    "PySide2.QtGui.QEnterEvent.x": (),
-    "PySide2.QtGui.QEnterEvent.y": (),
-# class PySide2.QtGui.QExposeEvent:
-    "PySide2.QtGui.QExposeEvent.__init__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QExposeEvent.region": (),
-# class PySide2.QtGui.QFileOpenEvent:
-    "PySide2.QtGui.QFileOpenEvent.__init__": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtGui.QFileOpenEvent.file": (),
-    "PySide2.QtGui.QFileOpenEvent.openFile": ('PySide2.QtCore.QFile', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtGui.QFileOpenEvent.url": (),
-# class PySide2.QtGui.QFocusEvent:
-    "PySide2.QtGui.QFocusEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtGui.QFocusEvent.gotFocus": (),
-    "PySide2.QtGui.QFocusEvent.lostFocus": (),
-    "PySide2.QtGui.QFocusEvent.reason": (),
-# class PySide2.QtGui.QFont:
-# class PySide2.QtGui.QFont.Capitalization:
-# class PySide2.QtGui.QFont.HintingPreference:
-# class PySide2.QtGui.QFont.SpacingType:
-# class PySide2.QtGui.QFont.Stretch:
-# class PySide2.QtGui.QFont.Style:
-# class PySide2.QtGui.QFont.StyleHint:
-# class PySide2.QtGui.QFont.StyleStrategy:
-# class PySide2.QtGui.QFont.Weight:
-    "PySide2.QtGui.QFont.__init__": [(), ('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('str', 'int', 'int', 'bool')],
-    "PySide2.QtGui.QFont.__copy__": (),
-    "PySide2.QtGui.QFont.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.bold": (),
-    "PySide2.QtGui.QFont.cacheStatistics": (),
-    "PySide2.QtGui.QFont.capitalization": (),
-    "PySide2.QtGui.QFont.cleanup": (),
-    "PySide2.QtGui.QFont.defaultFamily": (),
-    "PySide2.QtGui.QFont.exactMatch": (),
-    "PySide2.QtGui.QFont.families": (),
-    "PySide2.QtGui.QFont.family": (),
-    "PySide2.QtGui.QFont.fixedPitch": (),
-    "PySide2.QtGui.QFont.fromString": ('str',),
-    "PySide2.QtGui.QFont.hintingPreference": (),
-    "PySide2.QtGui.QFont.initialize": (),
-    "PySide2.QtGui.QFont.insertSubstitution": ('str', 'str'),
-    "PySide2.QtGui.QFont.insertSubstitutions": ('str', 'typing.Sequence'),
-    "PySide2.QtGui.QFont.isCopyOf": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.italic": (),
-    "PySide2.QtGui.QFont.kerning": (),
-    "PySide2.QtGui.QFont.key": (),
-    "PySide2.QtGui.QFont.lastResortFamily": (),
-    "PySide2.QtGui.QFont.lastResortFont": (),
-    "PySide2.QtGui.QFont.letterSpacing": (),
-    "PySide2.QtGui.QFont.letterSpacingType": (),
-    "PySide2.QtGui.QFont.overline": (),
-    "PySide2.QtGui.QFont.pixelSize": (),
-    "PySide2.QtGui.QFont.pointSize": (),
-    "PySide2.QtGui.QFont.pointSizeF": (),
-    "PySide2.QtGui.QFont.rawMode": (),
-    "PySide2.QtGui.QFont.rawName": (),
-    "PySide2.QtGui.QFont.removeSubstitutions": ('str',),
-    "PySide2.QtGui.QFont.resolve": [(), ('PySide2.QtGui.QFont',), ('int',)],
-    "PySide2.QtGui.QFont.setBold": ('bool',),
-    "PySide2.QtGui.QFont.setCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QFont.setFamilies": ('typing.Sequence',),
-    "PySide2.QtGui.QFont.setFamily": ('str',),
-    "PySide2.QtGui.QFont.setFixedPitch": ('bool',),
-    "PySide2.QtGui.QFont.setHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QFont.setItalic": ('bool',),
-    "PySide2.QtGui.QFont.setKerning": ('bool',),
-    "PySide2.QtGui.QFont.setLetterSpacing": ('PySide2.QtGui.QFont.SpacingType', 'float'),
-    "PySide2.QtGui.QFont.setOverline": ('bool',),
-    "PySide2.QtGui.QFont.setPixelSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSizeF": ('float',),
-    "PySide2.QtGui.QFont.setRawMode": ('bool',),
-    "PySide2.QtGui.QFont.setRawName": ('str',),
-    "PySide2.QtGui.QFont.setStretch": ('int',),
-    "PySide2.QtGui.QFont.setStrikeOut": ('bool',),
-    "PySide2.QtGui.QFont.setStyle": ('PySide2.QtGui.QFont.Style',),
-    "PySide2.QtGui.QFont.setStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QFont.setStyleName": ('str',),
-    "PySide2.QtGui.QFont.setStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QFont.setUnderline": ('bool',),
-    "PySide2.QtGui.QFont.setWeight": ('int',),
-    "PySide2.QtGui.QFont.setWordSpacing": ('float',),
-    "PySide2.QtGui.QFont.stretch": (),
-    "PySide2.QtGui.QFont.strikeOut": (),
-    "PySide2.QtGui.QFont.style": (),
-    "PySide2.QtGui.QFont.styleHint": (),
-    "PySide2.QtGui.QFont.styleName": (),
-    "PySide2.QtGui.QFont.styleStrategy": (),
-    "PySide2.QtGui.QFont.substitute": ('str',),
-    "PySide2.QtGui.QFont.substitutes": ('str',),
-    "PySide2.QtGui.QFont.substitutions": (),
-    "PySide2.QtGui.QFont.swap": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.toString": (),
-    "PySide2.QtGui.QFont.underline": (),
-    "PySide2.QtGui.QFont.weight": (),
-    "PySide2.QtGui.QFont.wordSpacing": (),
-# class PySide2.QtGui.QFontDatabase:
-# class PySide2.QtGui.QFontDatabase.SystemFont:
-# class PySide2.QtGui.QFontDatabase.WritingSystem:
-    "PySide2.QtGui.QFontDatabase.__init__": [(), ('PySide2.QtGui.QFontDatabase',)],
-    "PySide2.QtGui.QFontDatabase.__copy__": (),
-    "PySide2.QtGui.QFontDatabase.addApplicationFont": ('str',),
-    "PySide2.QtGui.QFontDatabase.addApplicationFontFromData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QFontDatabase.applicationFontFamilies": ('int',),
-    "PySide2.QtGui.QFontDatabase.bold": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.families": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.font": ('str', 'str', 'int'),
-    "PySide2.QtGui.QFontDatabase.hasFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isBitmapScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isFixedPitch": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isPrivateFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isSmoothlyScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.italic": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.pointSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.removeAllApplicationFonts": (),
-    "PySide2.QtGui.QFontDatabase.removeApplicationFont": ('int',),
-    "PySide2.QtGui.QFontDatabase.smoothSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.standardSizes": (),
-    "PySide2.QtGui.QFontDatabase.styleString": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontDatabase.styles": ('str',),
-    "PySide2.QtGui.QFontDatabase.supportsThreadedFontRendering": (),
-    "PySide2.QtGui.QFontDatabase.systemFont": ('PySide2.QtGui.QFontDatabase.SystemFont',),
-    "PySide2.QtGui.QFontDatabase.weight": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.writingSystemName": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystemSample": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystems": [(), ('str',)],
-# class PySide2.QtGui.QFontInfo:
-    "PySide2.QtGui.QFontInfo.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontInfo.__copy__": (),
-    "PySide2.QtGui.QFontInfo.bold": (),
-    "PySide2.QtGui.QFontInfo.exactMatch": (),
-    "PySide2.QtGui.QFontInfo.family": (),
-    "PySide2.QtGui.QFontInfo.fixedPitch": (),
-    "PySide2.QtGui.QFontInfo.italic": (),
-    "PySide2.QtGui.QFontInfo.overline": (),
-    "PySide2.QtGui.QFontInfo.pixelSize": (),
-    "PySide2.QtGui.QFontInfo.pointSize": (),
-    "PySide2.QtGui.QFontInfo.pointSizeF": (),
-    "PySide2.QtGui.QFontInfo.rawMode": (),
-    "PySide2.QtGui.QFontInfo.strikeOut": (),
-    "PySide2.QtGui.QFontInfo.style": (),
-    "PySide2.QtGui.QFontInfo.styleHint": (),
-    "PySide2.QtGui.QFontInfo.styleName": (),
-    "PySide2.QtGui.QFontInfo.swap": ('PySide2.QtGui.QFontInfo',),
-    "PySide2.QtGui.QFontInfo.underline": (),
-    "PySide2.QtGui.QFontInfo.weight": (),
-# class PySide2.QtGui.QFontMetrics:
-    "PySide2.QtGui.QFontMetrics.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',)],
-    "PySide2.QtGui.QFontMetrics.__copy__": (),
-    "PySide2.QtGui.QFontMetrics.ascent": (),
-    "PySide2.QtGui.QFontMetrics.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetrics.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str', 'int', 'typing.Sequence'), ('int', 'int', 'int', 'int', 'int', 'str', 'int', 'typing.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetrics.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.capHeight": (),
-    "PySide2.QtGui.QFontMetrics.charWidth": ('str', 'int'),
-    "PySide2.QtGui.QFontMetrics.descent": (),
-    "PySide2.QtGui.QFontMetrics.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'int', 'int'),
-    "PySide2.QtGui.QFontMetrics.fontDpi": (),
-    "PySide2.QtGui.QFontMetrics.height": (),
-    "PySide2.QtGui.QFontMetrics.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetrics.inFont": ('str',),
-    "PySide2.QtGui.QFontMetrics.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetrics.leading": (),
-    "PySide2.QtGui.QFontMetrics.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.lineSpacing": (),
-    "PySide2.QtGui.QFontMetrics.lineWidth": (),
-    "PySide2.QtGui.QFontMetrics.maxWidth": (),
-    "PySide2.QtGui.QFontMetrics.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetrics.minRightBearing": (),
-    "PySide2.QtGui.QFontMetrics.overlinePos": (),
-    "PySide2.QtGui.QFontMetrics.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.size": ('int', 'str', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QFontMetrics.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetrics.swap": ('PySide2.QtGui.QFontMetrics',),
-    "PySide2.QtGui.QFontMetrics.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetrics.underlinePos": (),
-    "PySide2.QtGui.QFontMetrics.width": [('str', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtGui.QFontMetrics.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.xHeight": (),
-# class PySide2.QtGui.QFontMetricsF:
-    "PySide2.QtGui.QFontMetricsF.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',), ('PySide2.QtGui.QFontMetricsF',)],
-    "PySide2.QtGui.QFontMetricsF.__copy__": (),
-    "PySide2.QtGui.QFontMetricsF.ascent": (),
-    "PySide2.QtGui.QFontMetricsF.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetricsF.boundingRect": [('PySide2.QtCore.QRectF', 'int', 'str', 'int', 'typing.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetricsF.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.capHeight": (),
-    "PySide2.QtGui.QFontMetricsF.descent": (),
-    "PySide2.QtGui.QFontMetricsF.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'float', 'int'),
-    "PySide2.QtGui.QFontMetricsF.fontDpi": (),
-    "PySide2.QtGui.QFontMetricsF.height": (),
-    "PySide2.QtGui.QFontMetricsF.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetricsF.inFont": ('str',),
-    "PySide2.QtGui.QFontMetricsF.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetricsF.leading": (),
-    "PySide2.QtGui.QFontMetricsF.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.lineSpacing": (),
-    "PySide2.QtGui.QFontMetricsF.lineWidth": (),
-    "PySide2.QtGui.QFontMetricsF.maxWidth": (),
-    "PySide2.QtGui.QFontMetricsF.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetricsF.minRightBearing": (),
-    "PySide2.QtGui.QFontMetricsF.overlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.size": ('int', 'str', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QFontMetricsF.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetricsF.swap": ('PySide2.QtGui.QFontMetricsF',),
-    "PySide2.QtGui.QFontMetricsF.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetricsF.underlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.width": ('str',),
-    "PySide2.QtGui.QFontMetricsF.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.xHeight": (),
-# class PySide2.QtGui.QGradient:
-# class PySide2.QtGui.QGradient.CoordinateMode:
-# class PySide2.QtGui.QGradient.InterpolationMode:
-# class PySide2.QtGui.QGradient.Preset:
-# class PySide2.QtGui.QGradient.Spread:
-# class PySide2.QtGui.QGradient.Type:
-    "PySide2.QtGui.QGradient.__init__": [(), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QGradient.Preset',)],
-    "PySide2.QtGui.QGradient.__copy__": (),
-    "PySide2.QtGui.QGradient.coordinateMode": (),
-    "PySide2.QtGui.QGradient.interpolationMode": (),
-    "PySide2.QtGui.QGradient.setColorAt": ('float', 'PySide2.QtGui.QColor'),
-    "PySide2.QtGui.QGradient.setCoordinateMode": ('PySide2.QtGui.QGradient.CoordinateMode',),
-    "PySide2.QtGui.QGradient.setInterpolationMode": ('PySide2.QtGui.QGradient.InterpolationMode',),
-    "PySide2.QtGui.QGradient.setSpread": ('PySide2.QtGui.QGradient.Spread',),
-    "PySide2.QtGui.QGradient.setStops": ('typing.List',),
-    "PySide2.QtGui.QGradient.spread": (),
-    "PySide2.QtGui.QGradient.stops": (),
-    "PySide2.QtGui.QGradient.type": (),
-# class PySide2.QtGui.QGuiApplication:
-    "PySide2.QtGui.QGuiApplication.__init__": [(), ('typing.Sequence',)],
-    "PySide2.QtGui.QGuiApplication.allWindows": (),
-    "PySide2.QtGui.QGuiApplication.applicationDisplayName": (),
-    "PySide2.QtGui.QGuiApplication.applicationState": (),
-    "PySide2.QtGui.QGuiApplication.changeOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.clipboard": (),
-    "PySide2.QtGui.QGuiApplication.desktopFileName": (),
-    "PySide2.QtGui.QGuiApplication.desktopSettingsAware": (),
-    "PySide2.QtGui.QGuiApplication.devicePixelRatio": (),
-    "PySide2.QtGui.QGuiApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QGuiApplication.exec_": (),
-    "PySide2.QtGui.QGuiApplication.focusObject": (),
-    "PySide2.QtGui.QGuiApplication.focusWindow": (),
-    "PySide2.QtGui.QGuiApplication.font": (),
-    "PySide2.QtGui.QGuiApplication.highDpiScaleFactorRoundingPolicy": (),
-    "PySide2.QtGui.QGuiApplication.inputMethod": (),
-    "PySide2.QtGui.QGuiApplication.isFallbackSessionManagementEnabled": (),
-    "PySide2.QtGui.QGuiApplication.isLeftToRight": (),
-    "PySide2.QtGui.QGuiApplication.isRightToLeft": (),
-    "PySide2.QtGui.QGuiApplication.isSavingSession": (),
-    "PySide2.QtGui.QGuiApplication.isSessionRestored": (),
-    "PySide2.QtGui.QGuiApplication.keyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.layoutDirection": (),
-    "PySide2.QtGui.QGuiApplication.modalWindow": (),
-    "PySide2.QtGui.QGuiApplication.mouseButtons": (),
-    "PySide2.QtGui.QGuiApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtGui.QGuiApplication.overrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.palette": (),
-    "PySide2.QtGui.QGuiApplication.platformName": (),
-    "PySide2.QtGui.QGuiApplication.primaryScreen": (),
-    "PySide2.QtGui.QGuiApplication.queryKeyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.quitOnLastWindowClosed": (),
-    "PySide2.QtGui.QGuiApplication.restoreOverrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.screenAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.screens": (),
-    "PySide2.QtGui.QGuiApplication.sessionId": (),
-    "PySide2.QtGui.QGuiApplication.sessionKey": (),
-    "PySide2.QtGui.QGuiApplication.setApplicationDisplayName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopFileName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopSettingsAware": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFallbackSessionManagementEnabled": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QGuiApplication.setHighDpiScaleFactorRoundingPolicy": ('PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy',),
-    "PySide2.QtGui.QGuiApplication.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QGuiApplication.setOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QGuiApplication.setQuitOnLastWindowClosed": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QGuiApplication.styleHints": (),
-    "PySide2.QtGui.QGuiApplication.sync": (),
-    "PySide2.QtGui.QGuiApplication.topLevelAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.topLevelWindows": (),
-    "PySide2.QtGui.QGuiApplication.windowIcon": (),
-# class PySide2.QtGui.QHelpEvent:
-    "PySide2.QtGui.QHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QHelpEvent.globalPos": (),
-    "PySide2.QtGui.QHelpEvent.globalX": (),
-    "PySide2.QtGui.QHelpEvent.global""Y": (),
-    "PySide2.QtGui.QHelpEvent.pos": (),
-    "PySide2.QtGui.QHelpEvent.x": (),
-    "PySide2.QtGui.QHelpEvent.y": (),
-# class PySide2.QtGui.QHideEvent:
-    "PySide2.QtGui.QHideEvent.__init__": (),
-# class PySide2.QtGui.QHoverEvent:
-    "PySide2.QtGui.QHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QHoverEvent.oldPos": (),
-    "PySide2.QtGui.QHoverEvent.oldPosF": (),
-    "PySide2.QtGui.QHoverEvent.pos": (),
-    "PySide2.QtGui.QHoverEvent.posF": (),
-# class PySide2.QtGui.QIcon:
-# class PySide2.QtGui.QIcon.Mode:
-# class PySide2.QtGui.QIcon.State:
-    "PySide2.QtGui.QIcon.__init__": [(), ('PySide2.QtGui.QIcon',), ('PySide2.QtGui.QIconEngine',), ('PySide2.QtGui.QPixmap',), ('str',)],
-    "PySide2.QtGui.QIcon.__copy__": (),
-    "PySide2.QtGui.QIcon.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.actualSize": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.cacheKey": (),
-    "PySide2.QtGui.QIcon.fallbackSearchPaths": (),
-    "PySide2.QtGui.QIcon.fallbackThemeName": (),
-    "PySide2.QtGui.QIcon.fromTheme": [('str',), ('str', 'PySide2.QtGui.QIcon')],
-    "PySide2.QtGui.QIcon.hasThemeIcon": ('str',),
-    "PySide2.QtGui.QIcon.isMask": (),
-    "PySide2.QtGui.QIcon.isNull": (),
-    "PySide2.QtGui.QIcon.name": (),
-    "PySide2.QtGui.QIcon.paint": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QPainter', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.pixmap": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.setFallbackSearchPaths": ('typing.Sequence',),
-    "PySide2.QtGui.QIcon.setFallbackThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setIsMask": ('bool',),
-    "PySide2.QtGui.QIcon.setThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setThemeSearchPaths": ('typing.Sequence',),
-    "PySide2.QtGui.QIcon.swap": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QIcon.themeName": (),
-    "PySide2.QtGui.QIcon.themeSearchPaths": (),
-# class PySide2.QtGui.QIconDragEvent:
-    "PySide2.QtGui.QIconDragEvent.__init__": (),
-# class PySide2.QtGui.QIconEngine:
-# class PySide2.QtGui.QIconEngine.AvailableSizesArgument:
-    "PySide2.QtGui.QIconEngine.AvailableSizesArgument.__init__": (),
-# class PySide2.QtGui.QIconEngine.IconEngineHook:
-    "PySide2.QtGui.QIconEngine.__init__": [(), ('PySide2.QtGui.QIconEngine',)],
-    "PySide2.QtGui.QIconEngine.actualSize": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.clone": (),
-    "PySide2.QtGui.QIconEngine.iconName": (),
-    "PySide2.QtGui.QIconEngine.isNull": (),
-    "PySide2.QtGui.QIconEngine.key": (),
-    "PySide2.QtGui.QIconEngine.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.pixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIconEngine.scaledPixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State', 'float'),
-    "PySide2.QtGui.QIconEngine.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QImage:
-# class PySide2.QtGui.QImage.Format:
-# class PySide2.QtGui.QImage.InvertMode:
-    "PySide2.QtGui.QImage.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QImage.Format'), ('PySide2.QtGui.QImage',), ('bytes', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('bytes', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'bytes'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('typing.Sequence',)],
-    "PySide2.QtGui.QImage.__copy__": (),
-    "PySide2.QtGui.QImage.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.allGray": (),
-    "PySide2.QtGui.QImage.alphaChannel": (),
-    "PySide2.QtGui.QImage.bitPlaneCount": (),
-    "PySide2.QtGui.QImage.bits": (),
-    "PySide2.QtGui.QImage.byteCount": (),
-    "PySide2.QtGui.QImage.bytesPerLine": (),
-    "PySide2.QtGui.QImage.cacheKey": (),
-    "PySide2.QtGui.QImage.color": ('int',),
-    "PySide2.QtGui.QImage.colorCount": (),
-    "PySide2.QtGui.QImage.colorSpace": (),
-    "PySide2.QtGui.QImage.colorTable": (),
-    "PySide2.QtGui.QImage.constBits": (),
-    "PySide2.QtGui.QImage.constScanLine": ('int',),
-    "PySide2.QtGui.QImage.convertTo": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.convertToFormat": [('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtGui.QImage.Format', 'typing.List', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QImage.convertToFormat_helper": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToFormat_inplace": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertedToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QImage.createAlphaMask": ('PySide2.QtCore.Qt.ImageConversionFlags',),
-    "PySide2.QtGui.QImage.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QImage.createMaskFromColor": ('int', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QImage.depth": (),
-    "PySide2.QtGui.QImage.devType": (),
-    "PySide2.QtGui.QImage.devicePixelRatio": (),
-    "PySide2.QtGui.QImage.dotsPerMeterX": (),
-    "PySide2.QtGui.QImage.dotsPerMeterY": (),
-    "PySide2.QtGui.QImage.fill": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('int',)],
-    "PySide2.QtGui.QImage.format": (),
-    "PySide2.QtGui.QImage.fromData": ('PySide2.QtCore.QByteArray', 'bytes'),
-    "PySide2.QtGui.QImage.hasAlphaChannel": (),
-    "PySide2.QtGui.QImage.height": (),
-    "PySide2.QtGui.QImage.invertPixels": ('PySide2.QtGui.QImage.InvertMode',),
-    "PySide2.QtGui.QImage.isGrayscale": (),
-    "PySide2.QtGui.QImage.isNull": (),
-    "PySide2.QtGui.QImage.load": [('PySide2.QtCore.QIODevice', 'bytes'), ('str', 'bytes')],
-    "PySide2.QtGui.QImage.loadFromData": ('PySide2.QtCore.QByteArray', 'bytes'),
-    "PySide2.QtGui.QImage.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QImage.mirrored": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_helper": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_inplace": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.offset": (),
-    "PySide2.QtGui.QImage.paintEngine": (),
-    "PySide2.QtGui.QImage.pixel": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelColor": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelFormat": (),
-    "PySide2.QtGui.QImage.pixelIndex": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.rect": (),
-    "PySide2.QtGui.QImage.reinterpretAsFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.rgbSwapped": (),
-    "PySide2.QtGui.QImage.rgbSwapped_helper": (),
-    "PySide2.QtGui.QImage.rgbSwapped_inplace": (),
-    "PySide2.QtGui.QImage.save": [('PySide2.QtCore.QIODevice', 'bytes', 'int'), ('str', 'bytes', 'int')],
-    "PySide2.QtGui.QImage.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scanLine": ('int',),
-    "PySide2.QtGui.QImage.setAlphaChannel": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.setColor": ('int', 'int'),
-    "PySide2.QtGui.QImage.setColorCount": ('int',),
-    "PySide2.QtGui.QImage.setColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.setColorTable": ('typing.List',),
-    "PySide2.QtGui.QImage.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QImage.setDotsPerMeterX": ('int',),
-    "PySide2.QtGui.QImage.setDotsPerMeterY": ('int',),
-    "PySide2.QtGui.QImage.setOffset": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QImage.setPixel": [('PySide2.QtCore.QPoint', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QImage.setPixelColor": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QImage.setText": ('str', 'str'),
-    "PySide2.QtGui.QImage.size": (),
-    "PySide2.QtGui.QImage.sizeInBytes": (),
-    "PySide2.QtGui.QImage.smoothScaled": ('int', 'int'),
-    "PySide2.QtGui.QImage.swap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.text": ('str',),
-    "PySide2.QtGui.QImage.textKeys": (),
-    "PySide2.QtGui.QImage.toImageFormat": ('PySide2.QtGui.QPixelFormat',),
-    "PySide2.QtGui.QImage.toPixelFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QImage.valid": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.width": (),
-# class PySide2.QtGui.QImageIOHandler:
-# class PySide2.QtGui.QImageIOHandler.ImageOption:
-# class PySide2.QtGui.QImageIOHandler.Transformation:
-# class PySide2.QtGui.QImageIOHandler.Transformations:
-    "PySide2.QtGui.QImageIOHandler.__init__": (),
-    "PySide2.QtGui.QImageIOHandler.canRead": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageNumber": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageRect": (),
-    "PySide2.QtGui.QImageIOHandler.device": (),
-    "PySide2.QtGui.QImageIOHandler.format": (),
-    "PySide2.QtGui.QImageIOHandler.imageCount": (),
-    "PySide2.QtGui.QImageIOHandler.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageIOHandler.jumpToNextImage": (),
-    "PySide2.QtGui.QImageIOHandler.loopCount": (),
-    "PySide2.QtGui.QImageIOHandler.name": (),
-    "PySide2.QtGui.QImageIOHandler.nextImageDelay": (),
-    "PySide2.QtGui.QImageIOHandler.option": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.read": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImageIOHandler.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageIOHandler.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageIOHandler.setOption": ('PySide2.QtGui.QImageIOHandler.ImageOption', 'typing.Any'),
-    "PySide2.QtGui.QImageIOHandler.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QImageReader:
-# class PySide2.QtGui.QImageReader.ImageReaderError:
-    "PySide2.QtGui.QImageReader.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageReader.autoDetectImageFormat": (),
-    "PySide2.QtGui.QImageReader.autoTransform": (),
-    "PySide2.QtGui.QImageReader.backgroundColor": (),
-    "PySide2.QtGui.QImageReader.canRead": (),
-    "PySide2.QtGui.QImageReader.clipRect": (),
-    "PySide2.QtGui.QImageReader.currentImageNumber": (),
-    "PySide2.QtGui.QImageReader.currentImageRect": (),
-    "PySide2.QtGui.QImageReader.decideFormatFromContent": (),
-    "PySide2.QtGui.QImageReader.device": (),
-    "PySide2.QtGui.QImageReader.error": (),
-    "PySide2.QtGui.QImageReader.errorString": (),
-    "PySide2.QtGui.QImageReader.fileName": (),
-    "PySide2.QtGui.QImageReader.format": (),
-    "PySide2.QtGui.QImageReader.gamma": (),
-    "PySide2.QtGui.QImageReader.imageCount": (),
-    "PySide2.QtGui.QImageReader.imageFormat": [(), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QImageReader.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageReader.jumpToNextImage": (),
-    "PySide2.QtGui.QImageReader.loopCount": (),
-    "PySide2.QtGui.QImageReader.nextImageDelay": (),
-    "PySide2.QtGui.QImageReader.quality": (),
-    "PySide2.QtGui.QImageReader.read": (),
-    "PySide2.QtGui.QImageReader.scaledClipRect": (),
-    "PySide2.QtGui.QImageReader.scaledSize": (),
-    "PySide2.QtGui.QImageReader.setAutoDetectImageFormat": ('bool',),
-    "PySide2.QtGui.QImageReader.setAutoTransform": ('bool',),
-    "PySide2.QtGui.QImageReader.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QImageReader.setClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setDecideFormatFromContent": ('bool',),
-    "PySide2.QtGui.QImageReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageReader.setFileName": ('str',),
-    "PySide2.QtGui.QImageReader.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.setGamma": ('float',),
-    "PySide2.QtGui.QImageReader.setQuality": ('int',),
-    "PySide2.QtGui.QImageReader.setScaledClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QImageReader.size": (),
-    "PySide2.QtGui.QImageReader.subType": (),
-    "PySide2.QtGui.QImageReader.supportedImageFormats": (),
-    "PySide2.QtGui.QImageReader.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageReader.supportedSubTypes": (),
-    "PySide2.QtGui.QImageReader.supportsAnimation": (),
-    "PySide2.QtGui.QImageReader.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageReader.text": ('str',),
-    "PySide2.QtGui.QImageReader.textKeys": (),
-    "PySide2.QtGui.QImageReader.transformation": (),
-# class PySide2.QtGui.QImageWriter:
-# class PySide2.QtGui.QImageWriter.ImageWriterError:
-    "PySide2.QtGui.QImageWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageWriter.canWrite": (),
-    "PySide2.QtGui.QImageWriter.compression": (),
-    "PySide2.QtGui.QImageWriter.description": (),
-    "PySide2.QtGui.QImageWriter.device": (),
-    "PySide2.QtGui.QImageWriter.error": (),
-    "PySide2.QtGui.QImageWriter.errorString": (),
-    "PySide2.QtGui.QImageWriter.fileName": (),
-    "PySide2.QtGui.QImageWriter.format": (),
-    "PySide2.QtGui.QImageWriter.gamma": (),
-    "PySide2.QtGui.QImageWriter.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.optimizedWrite": (),
-    "PySide2.QtGui.QImageWriter.progressiveScanWrite": (),
-    "PySide2.QtGui.QImageWriter.quality": (),
-    "PySide2.QtGui.QImageWriter.setCompression": ('int',),
-    "PySide2.QtGui.QImageWriter.setDescription": ('str',),
-    "PySide2.QtGui.QImageWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageWriter.setFileName": ('str',),
-    "PySide2.QtGui.QImageWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setGamma": ('float',),
-    "PySide2.QtGui.QImageWriter.setOptimizedWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setProgressiveScanWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setQuality": ('int',),
-    "PySide2.QtGui.QImageWriter.setSubType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setText": ('str', 'str'),
-    "PySide2.QtGui.QImageWriter.setTransformation": ('PySide2.QtGui.QImageIOHandler.Transformations',),
-    "PySide2.QtGui.QImageWriter.subType": (),
-    "PySide2.QtGui.QImageWriter.supportedImageFormats": (),
-    "PySide2.QtGui.QImageWriter.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageWriter.supportedSubTypes": (),
-    "PySide2.QtGui.QImageWriter.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageWriter.transformation": (),
-    "PySide2.QtGui.QImageWriter.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QInputEvent:
-    "PySide2.QtGui.QInputEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QInputEvent.modifiers": (),
-    "PySide2.QtGui.QInputEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtGui.QInputEvent.setTimestamp": ('int',),
-    "PySide2.QtGui.QInputEvent.timestamp": (),
-# class PySide2.QtGui.QInputMethod:
-# class PySide2.QtGui.QInputMethod.Action:
-    "PySide2.QtGui.QInputMethod.anchorRectangle": (),
-    "PySide2.QtGui.QInputMethod.commit": (),
-    "PySide2.QtGui.QInputMethod.cursorRectangle": (),
-    "PySide2.QtGui.QInputMethod.hide": (),
-    "PySide2.QtGui.QInputMethod.inputDirection": (),
-    "PySide2.QtGui.QInputMethod.inputItemClipRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemTransform": (),
-    "PySide2.QtGui.QInputMethod.invokeAction": ('PySide2.QtGui.QInputMethod.Action', 'int'),
-    "PySide2.QtGui.QInputMethod.isAnimating": (),
-    "PySide2.QtGui.QInputMethod.isVisible": (),
-    "PySide2.QtGui.QInputMethod.keyboardRectangle": (),
-    "PySide2.QtGui.QInputMethod.locale": (),
-    "PySide2.QtGui.QInputMethod.queryFocusObject": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethod.reset": (),
-    "PySide2.QtGui.QInputMethod.setInputItemRectangle": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QInputMethod.setInputItemTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QInputMethod.setVisible": ('bool',),
-    "PySide2.QtGui.QInputMethod.show": (),
-    "PySide2.QtGui.QInputMethod.update": ('PySide2.QtCore.Qt.InputMethodQueries',),
-# class PySide2.QtGui.QInputMethodEvent:
-# class PySide2.QtGui.QInputMethodEvent.Attribute:
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__init__": [('PySide2.QtGui.QInputMethodEvent.Attribute',), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int'), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int', 'typing.Any')],
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__copy__": (),
-# class PySide2.QtGui.QInputMethodEvent.AttributeType:
-    "PySide2.QtGui.QInputMethodEvent.__init__": [(), ('PySide2.QtGui.QInputMethodEvent',), ('str', 'typing.Sequence')],
-    "PySide2.QtGui.QInputMethodEvent.attributes": (),
-    "PySide2.QtGui.QInputMethodEvent.commitString": (),
-    "PySide2.QtGui.QInputMethodEvent.preeditString": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementLength": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementStart": (),
-    "PySide2.QtGui.QInputMethodEvent.setCommitString": ('str', 'int', 'int'),
-# class PySide2.QtGui.QInputMethodQueryEvent:
-    "PySide2.QtGui.QInputMethodQueryEvent.__init__": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtGui.QInputMethodQueryEvent.queries": (),
-    "PySide2.QtGui.QInputMethodQueryEvent.setValue": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethodQueryEvent.value": ('PySide2.QtCore.Qt.InputMethodQuery',),
-# class PySide2.QtGui.QIntValidator:
-    "PySide2.QtGui.QIntValidator.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QIntValidator.bottom": (),
-    "PySide2.QtGui.QIntValidator.fixup": ('str',),
-    "PySide2.QtGui.QIntValidator.setBottom": ('int',),
-    "PySide2.QtGui.QIntValidator.setRange": ('int', 'int'),
-    "PySide2.QtGui.QIntValidator.setTop": ('int',),
-    "PySide2.QtGui.QIntValidator.top": (),
-    "PySide2.QtGui.QIntValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QKeyEvent:
-    "PySide2.QtGui.QKeyEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'int', 'int', 'str', 'bool', 'int'), ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtGui.QKeyEvent.count": (),
-    "PySide2.QtGui.QKeyEvent.isAutoRepeat": (),
-    "PySide2.QtGui.QKeyEvent.key": (),
-    "PySide2.QtGui.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeyEvent.modifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeModifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeScanCode": (),
-    "PySide2.QtGui.QKeyEvent.nativeVirtualKey": (),
-    "PySide2.QtGui.QKeyEvent.text": (),
-# class PySide2.QtGui.QKeySequence:
-# class PySide2.QtGui.QKeySequence.SequenceFormat:
-# class PySide2.QtGui.QKeySequence.SequenceMatch:
-# class PySide2.QtGui.QKeySequence.StandardKey:
-    "PySide2.QtGui.QKeySequence.__init__": [(), ('PySide2.QtGui.QKeySequence',), ('PySide2.QtGui.QKeySequence.StandardKey',), ('int', 'int', 'int', 'int'), ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat')],
-    "PySide2.QtGui.QKeySequence.__copy__": (),
-    "PySide2.QtGui.QKeySequence.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.__reduce__": (),
-    "PySide2.QtGui.QKeySequence.__repr__": (),
-    "PySide2.QtGui.QKeySequence.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.count": (),
-    "PySide2.QtGui.QKeySequence.fromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.isEmpty": (),
-    "PySide2.QtGui.QKeySequence.keyBindings": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeySequence.listFromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.listToString": ('typing.Sequence', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.matches": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.mnemonic": ('str',),
-    "PySide2.QtGui.QKeySequence.swap": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.toString": ('PySide2.QtGui.QKeySequence.SequenceFormat',),
-# class PySide2.QtGui.QLinearGradient:
-    "PySide2.QtGui.QLinearGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QLinearGradient',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QLinearGradient.__copy__": (),
-    "PySide2.QtGui.QLinearGradient.finalStop": (),
-    "PySide2.QtGui.QLinearGradient.setFinalStop": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.setStart": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.start": (),
-# class PySide2.QtGui.QMatrix:
-    "PySide2.QtGui.QMatrix.__init__": [(), ('PySide2.QtGui.QMatrix',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix.__copy__": (),
-    "PySide2.QtGui.QMatrix.__imul__": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QMatrix.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix',)],
-    "PySide2.QtGui.QMatrix.__reduce__": (),
-    "PySide2.QtGui.QMatrix.__repr__": (),
-    "PySide2.QtGui.QMatrix.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.determinant": (),
-    "PySide2.QtGui.QMatrix.dx": (),
-    "PySide2.QtGui.QMatrix.dy": (),
-    "PySide2.QtGui.QMatrix.inverted": (),
-    "PySide2.QtGui.QMatrix.isIdentity": (),
-    "PySide2.QtGui.QMatrix.isInvertible": (),
-    "PySide2.QtGui.QMatrix.m11": (),
-    "PySide2.QtGui.QMatrix.m12": (),
-    "PySide2.QtGui.QMatrix.m21": (),
-    "PySide2.QtGui.QMatrix.m22": (),
-    "PySide2.QtGui.QMatrix.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float'), ('int', 'int')],
-    "PySide2.QtGui.QMatrix.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QMatrix.reset": (),
-    "PySide2.QtGui.QMatrix.rotate": ('float',),
-    "PySide2.QtGui.QMatrix.scale": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix.shear": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.translate": ('float', 'float'),
-# class PySide2.QtGui.QMatrix2x2:
-    "PySide2.QtGui.QMatrix2x2.__init__": [(), ('PySide2.QtGui.QMatrix2x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x2.__copy__": (),
-    "PySide2.QtGui.QMatrix2x2.__iadd__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x2.__isub__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x2.__repr__": (),
-    "PySide2.QtGui.QMatrix2x2.data": (),
-    "PySide2.QtGui.QMatrix2x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.transposed": (),
-# class PySide2.QtGui.QMatrix2x3:
-    "PySide2.QtGui.QMatrix2x3.__init__": [(), ('PySide2.QtGui.QMatrix2x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x3.__copy__": (),
-    "PySide2.QtGui.QMatrix2x3.__iadd__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x3.__isub__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x3.__repr__": (),
-    "PySide2.QtGui.QMatrix2x3.data": (),
-    "PySide2.QtGui.QMatrix2x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.transposed": (),
-# class PySide2.QtGui.QMatrix2x4:
-    "PySide2.QtGui.QMatrix2x4.__init__": [(), ('PySide2.QtGui.QMatrix2x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x4.__copy__": (),
-    "PySide2.QtGui.QMatrix2x4.__iadd__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x4.__isub__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x4.__repr__": (),
-    "PySide2.QtGui.QMatrix2x4.data": (),
-    "PySide2.QtGui.QMatrix2x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.transposed": (),
-# class PySide2.QtGui.QMatrix3x2:
-    "PySide2.QtGui.QMatrix3x2.__init__": [(), ('PySide2.QtGui.QMatrix3x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x2.__copy__": (),
-    "PySide2.QtGui.QMatrix3x2.__iadd__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x2.__isub__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x2.__repr__": (),
-    "PySide2.QtGui.QMatrix3x2.data": (),
-    "PySide2.QtGui.QMatrix3x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.transposed": (),
-# class PySide2.QtGui.QMatrix3x3:
-    "PySide2.QtGui.QMatrix3x3.__init__": [(), ('PySide2.QtGui.QMatrix3x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x3.__copy__": (),
-    "PySide2.QtGui.QMatrix3x3.__iadd__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x3.__isub__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x3.__repr__": (),
-    "PySide2.QtGui.QMatrix3x3.data": (),
-    "PySide2.QtGui.QMatrix3x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.transposed": (),
-# class PySide2.QtGui.QMatrix3x4:
-    "PySide2.QtGui.QMatrix3x4.__init__": [(), ('PySide2.QtGui.QMatrix3x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x4.__copy__": (),
-    "PySide2.QtGui.QMatrix3x4.__iadd__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x4.__isub__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x4.__repr__": (),
-    "PySide2.QtGui.QMatrix3x4.data": (),
-    "PySide2.QtGui.QMatrix3x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.transposed": (),
-# class PySide2.QtGui.QMatrix4x2:
-    "PySide2.QtGui.QMatrix4x2.__init__": [(), ('PySide2.QtGui.QMatrix4x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x2.__copy__": (),
-    "PySide2.QtGui.QMatrix4x2.__iadd__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x2.__isub__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x2.__repr__": (),
-    "PySide2.QtGui.QMatrix4x2.data": (),
-    "PySide2.QtGui.QMatrix4x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.transposed": (),
-# class PySide2.QtGui.QMatrix4x3:
-    "PySide2.QtGui.QMatrix4x3.__init__": [(), ('PySide2.QtGui.QMatrix4x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x3.__copy__": (),
-    "PySide2.QtGui.QMatrix4x3.__iadd__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x3.__isub__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x3.__repr__": (),
-    "PySide2.QtGui.QMatrix4x3.data": (),
-    "PySide2.QtGui.QMatrix4x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.transposed": (),
-# class PySide2.QtGui.QMatrix4x4:
-    "PySide2.QtGui.QMatrix4x4.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'), ('typing.Sequence',)],
-    "PySide2.QtGui.QMatrix4x4.__add__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__copy__": (),
-    "PySide2.QtGui.QMatrix4x4.__dummy": ('typing.Sequence',),
-    "PySide2.QtGui.QMatrix4x4.__iadd__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__imul__": [('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__isub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__mul__": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__neg__": (),
-    "PySide2.QtGui.QMatrix4x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x4.__repr__": (),
-    "PySide2.QtGui.QMatrix4x4.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__sub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.column": ('int',),
-    "PySide2.QtGui.QMatrix4x4.copyDataTo": (),
-    "PySide2.QtGui.QMatrix4x4.data": (),
-    "PySide2.QtGui.QMatrix4x4.determinant": (),
-    "PySide2.QtGui.QMatrix4x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x4.flipCoordinates": (),
-    "PySide2.QtGui.QMatrix4x4.frustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.inverted": (),
-    "PySide2.QtGui.QMatrix4x4.isAffine": (),
-    "PySide2.QtGui.QMatrix4x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.lookAt": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QMatrix4x4.map": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',)],
-    "PySide2.QtGui.QMatrix4x4.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix4x4.mapVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QMatrix4x4.normalMatrix": (),
-    "PySide2.QtGui.QMatrix4x4.optimize": (),
-    "PySide2.QtGui.QMatrix4x4.ortho": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.perspective": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.rotate": [('PySide2.QtGui.QQuaternion',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.row": ('int',),
-    "PySide2.QtGui.QMatrix4x4.scale": [('PySide2.QtGui.QVector3D',), ('float',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.setColumn": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setRow": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.toAffine": (),
-    "PySide2.QtGui.QMatrix4x4.toTransform": [(), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.translate": [('PySide2.QtGui.QVector3D',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.transposed": (),
-    "PySide2.QtGui.QMatrix4x4.viewport": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-# class PySide2.QtGui.QMouseEvent:
-    "PySide2.QtGui.QMouseEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QMouseEvent.button": (),
-    "PySide2.QtGui.QMouseEvent.buttons": (),
-    "PySide2.QtGui.QMouseEvent.flags": (),
-    "PySide2.QtGui.QMouseEvent.globalPos": (),
-    "PySide2.QtGui.QMouseEvent.globalX": (),
-    "PySide2.QtGui.QMouseEvent.global""Y": (),
-    "PySide2.QtGui.QMouseEvent.localPos": (),
-    "PySide2.QtGui.QMouseEvent.pos": (),
-    "PySide2.QtGui.QMouseEvent.screenPos": (),
-    "PySide2.QtGui.QMouseEvent.setLocalPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QMouseEvent.source": (),
-    "PySide2.QtGui.QMouseEvent.windowPos": (),
-    "PySide2.QtGui.QMouseEvent.x": (),
-    "PySide2.QtGui.QMouseEvent.y": (),
-# class PySide2.QtGui.QMoveEvent:
-    "PySide2.QtGui.QMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QMoveEvent.oldPos": (),
-    "PySide2.QtGui.QMoveEvent.pos": (),
-# class PySide2.QtGui.QMovie:
-# class PySide2.QtGui.QMovie.CacheMode:
-# class PySide2.QtGui.QMovie.MovieState:
-    "PySide2.QtGui.QMovie.__init__": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QMovie.backgroundColor": (),
-    "PySide2.QtGui.QMovie.cacheMode": (),
-    "PySide2.QtGui.QMovie.currentFrameNumber": (),
-    "PySide2.QtGui.QMovie.currentImage": (),
-    "PySide2.QtGui.QMovie.currentPixmap": (),
-    "PySide2.QtGui.QMovie.device": (),
-    "PySide2.QtGui.QMovie.fileName": (),
-    "PySide2.QtGui.QMovie.format": (),
-    "PySide2.QtGui.QMovie.frameCount": (),
-    "PySide2.QtGui.QMovie.frameRect": (),
-    "PySide2.QtGui.QMovie.isValid": (),
-    "PySide2.QtGui.QMovie.jumpToFrame": ('int',),
-    "PySide2.QtGui.QMovie.jumpToNextFrame": (),
-    "PySide2.QtGui.QMovie.lastError": (),
-    "PySide2.QtGui.QMovie.lastErrorString": (),
-    "PySide2.QtGui.QMovie.loopCount": (),
-    "PySide2.QtGui.QMovie.nextFrameDelay": (),
-    "PySide2.QtGui.QMovie.scaledSize": (),
-    "PySide2.QtGui.QMovie.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QMovie.setCacheMode": ('PySide2.QtGui.QMovie.CacheMode',),
-    "PySide2.QtGui.QMovie.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QMovie.setFileName": ('str',),
-    "PySide2.QtGui.QMovie.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QMovie.setPaused": ('bool',),
-    "PySide2.QtGui.QMovie.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QMovie.setSpeed": ('int',),
-    "PySide2.QtGui.QMovie.speed": (),
-    "PySide2.QtGui.QMovie.start": (),
-    "PySide2.QtGui.QMovie.state": (),
-    "PySide2.QtGui.QMovie.stop": (),
-    "PySide2.QtGui.QMovie.supportedFormats": (),
-# class PySide2.QtGui.QNativeGestureEvent:
-    "PySide2.QtGui.QNativeGestureEvent.__init__": [('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int'), ('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int')],
-    "PySide2.QtGui.QNativeGestureEvent.device": (),
-    "PySide2.QtGui.QNativeGestureEvent.gestureType": (),
-    "PySide2.QtGui.QNativeGestureEvent.globalPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.localPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.pos": (),
-    "PySide2.QtGui.QNativeGestureEvent.screenPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.value": (),
-    "PySide2.QtGui.QNativeGestureEvent.windowPos": (),
-# class PySide2.QtGui.QOffscreenSurface:
-    "PySide2.QtGui.QOffscreenSurface.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QOffscreenSurface.create": (),
-    "PySide2.QtGui.QOffscreenSurface.destroy": (),
-    "PySide2.QtGui.QOffscreenSurface.format": (),
-    "PySide2.QtGui.QOffscreenSurface.isValid": (),
-    "PySide2.QtGui.QOffscreenSurface.nativeHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.requestedFormat": (),
-    "PySide2.QtGui.QOffscreenSurface.screen": (),
-    "PySide2.QtGui.QOffscreenSurface.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOffscreenSurface.setNativeHandle": ('int',),
-    "PySide2.QtGui.QOffscreenSurface.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOffscreenSurface.size": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceType": (),
-# class PySide2.QtGui.QOpenGLBuffer:
-# class PySide2.QtGui.QOpenGLBuffer.Access:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlag:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags:
-# class PySide2.QtGui.QOpenGLBuffer.Type:
-# class PySide2.QtGui.QOpenGLBuffer.UsagePattern:
-    "PySide2.QtGui.QOpenGLBuffer.__init__": [(), ('PySide2.QtGui.QOpenGLBuffer',), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QOpenGLBuffer.bind": (),
-    "PySide2.QtGui.QOpenGLBuffer.bufferId": (),
-    "PySide2.QtGui.QOpenGLBuffer.create": (),
-    "PySide2.QtGui.QOpenGLBuffer.destroy": (),
-    "PySide2.QtGui.QOpenGLBuffer.isCreated": (),
-    "PySide2.QtGui.QOpenGLBuffer.map": ('PySide2.QtGui.QOpenGLBuffer.Access',),
-    "PySide2.QtGui.QOpenGLBuffer.mapRange": ('int', 'int', 'PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags'),
-    "PySide2.QtGui.QOpenGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLBuffer.release": [(), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.setUsagePattern": ('PySide2.QtGui.QOpenGLBuffer.UsagePattern',),
-    "PySide2.QtGui.QOpenGLBuffer.size": (),
-    "PySide2.QtGui.QOpenGLBuffer.type": (),
-    "PySide2.QtGui.QOpenGLBuffer.unmap": (),
-    "PySide2.QtGui.QOpenGLBuffer.usagePattern": (),
-    "PySide2.QtGui.QOpenGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtGui.QOpenGLContext:
-# class PySide2.QtGui.QOpenGLContext.OpenGLModuleType:
-    "PySide2.QtGui.QOpenGLContext.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLContext.areSharing": ('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLContext.create": (),
-    "PySide2.QtGui.QOpenGLContext.currentContext": (),
-    "PySide2.QtGui.QOpenGLContext.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLContext.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLContext.extensions": (),
-    "PySide2.QtGui.QOpenGLContext.extraFunctions": (),
-    "PySide2.QtGui.QOpenGLContext.format": (),
-    "PySide2.QtGui.QOpenGLContext.functions": (),
-    "PySide2.QtGui.QOpenGLContext.globalShareContext": (),
-    "PySide2.QtGui.QOpenGLContext.hasExtension": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QOpenGLContext.isOpenGLES": (),
-    "PySide2.QtGui.QOpenGLContext.isValid": (),
-    "PySide2.QtGui.QOpenGLContext.makeCurrent": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.nativeHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleType": (),
-    "PySide2.QtGui.QOpenGLContext.screen": (),
-    "PySide2.QtGui.QOpenGLContext.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOpenGLContext.setNativeHandle": ('typing.Any',),
-    "PySide2.QtGui.QOpenGLContext.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOpenGLContext.setShareContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLContext.shareContext": (),
-    "PySide2.QtGui.QOpenGLContext.shareGroup": (),
-    "PySide2.QtGui.QOpenGLContext.supportsThreadedOpenGL": (),
-    "PySide2.QtGui.QOpenGLContext.surface": (),
-    "PySide2.QtGui.QOpenGLContext.swapBuffers": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.versionFunctions": ('PySide2.QtGui.QOpenGLVersionProfile',),
-# class PySide2.QtGui.QOpenGLContextGroup:
-    "PySide2.QtGui.QOpenGLContextGroup.currentContextGroup": (),
-    "PySide2.QtGui.QOpenGLContextGroup.shares": (),
-# class PySide2.QtGui.QOpenGLDebugLogger:
-# class PySide2.QtGui.QOpenGLDebugLogger.LoggingMode:
-    "PySide2.QtGui.QOpenGLDebugLogger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLDebugLogger.disableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.enableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.initialize": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.isLogging": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.logMessage": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggedMessages": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggingMode": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.maximumMessageLength": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.popGroup": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.pushGroup": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Source'),
-    "PySide2.QtGui.QOpenGLDebugLogger.startLogging": ('PySide2.QtGui.QOpenGLDebugLogger.LoggingMode',),
-    "PySide2.QtGui.QOpenGLDebugLogger.stopLogging": (),
-# class PySide2.QtGui.QOpenGLDebugMessage:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severities:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severity:
-# class PySide2.QtGui.QOpenGLDebugMessage.Source:
-# class PySide2.QtGui.QOpenGLDebugMessage.Sources:
-# class PySide2.QtGui.QOpenGLDebugMessage.Type:
-# class PySide2.QtGui.QOpenGLDebugMessage.Types:
-    "PySide2.QtGui.QOpenGLDebugMessage.__init__": [(), ('PySide2.QtGui.QOpenGLDebugMessage',)],
-    "PySide2.QtGui.QOpenGLDebugMessage.__copy__": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.createApplicationMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.createThirdPartyMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.id": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.message": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.severity": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.source": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.swap": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugMessage.type": (),
-# class PySide2.QtGui.QOpenGLExtraFunctions:
-    "PySide2.QtGui.QOpenGLExtraFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLExtraFunctions.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginQuery": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindSampler": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendBarrier": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDisablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEnablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEndQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformBlockiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformsiv": ('int', 'int', 'typing.Sequence', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetBufferParameteri64v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFramebufferParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetGraphicsResetStatus": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64i_v": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInteger64v": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetIntegeri_v": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInternalformativ": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetMultisamplefv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramBinary": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramInterfaceiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramPipelineiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceiv": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryObjectuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetStringi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameterfv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameteriv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformfv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformuiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsSampler": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrier": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMinSampleShading": ('float',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectLabel": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectPtrLabel": ('int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPopDebugGroup": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPrimitiveBoundingBox": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPushDebugGroup": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSampleMaski": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1ui": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUnmapBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glValidateProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexBindingDivisor": ('int', 'int'),
-# class PySide2.QtGui.QOpenGLFramebufferObject:
-# class PySide2.QtGui.QOpenGLFramebufferObject.Attachment:
-# class PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy:
-    "PySide2.QtGui.QOpenGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.addColorAttachment": [('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bind": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bindDefault": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.blitFramebuffer": [('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtGui.QOpenGLFramebufferObject', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.format": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.handle": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.height": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isBound": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isValid": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.release": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObject.size": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.sizes": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.takeTexture": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLFramebufferObject.texture": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.textures": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.toImage": [(), ('bool',), ('bool', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.width": (),
-# class PySide2.QtGui.QOpenGLFramebufferObjectFormat:
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtGui.QOpenGLFramebufferObjectFormat',)],
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtGui.QOpenGLFunctions:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeature:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeatures:
-    "PySide2.QtGui.QOpenGLFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLFunctions.glActiveTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glAttachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindBuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindTexture": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquation": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFunc": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClear": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glClearDepthf": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearStencil": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompileShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateProgram": (),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCullFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthFunc": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthRangef": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glDetachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDisable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glEnable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glFinish": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFlush": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFrontFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGenBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenerateMipmap": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttachedShaders": ('int', 'int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetBufferParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetError": (),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFloatv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFramebufferAttachmentParameteriv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetIntegerv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetProgramiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetRenderbufferParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderPrecisionFormat": ('int', 'int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetString": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glHint": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glIsBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsEnabled": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsFramebuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsRenderbuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glLineWidth": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glLinkProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glPixelStorei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glReleaseShaderCompiler": (),
-    "PySide2.QtGui.QOpenGLFunctions.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1i": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUseProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glValidateProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.hasOpenGLFeature": ('PySide2.QtGui.QOpenGLFunctions.OpenGLFeature',),
-    "PySide2.QtGui.QOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QOpenGLFunctions.openGLFeatures": (),
-# class PySide2.QtGui.QOpenGLPixelTransferOptions:
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__init__": [(), ('PySide2.QtGui.QOpenGLPixelTransferOptions',)],
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__copy__": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.alignment": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.imageHeight": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isLeastSignificantBitFirst": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isSwapBytesEnabled": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.rowLength": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setAlignment": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setImageHeight": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setLeastSignificantByteFirst": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setRowLength": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipImages": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipPixels": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipRows": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSwapBytesEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipImages": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipPixels": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipRows": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.swap": ('PySide2.QtGui.QOpenGLPixelTransferOptions',),
-# class PySide2.QtGui.QOpenGLShader:
-# class PySide2.QtGui.QOpenGLShader.ShaderType:
-# class PySide2.QtGui.QOpenGLShader.ShaderTypeBit:
-    "PySide2.QtGui.QOpenGLShader.__init__": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QOpenGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-    "PySide2.QtGui.QOpenGLShader.compileSourceFile": ('str',),
-    "PySide2.QtGui.QOpenGLShader.hasOpenGLShaders": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLShader.isCompiled": (),
-    "PySide2.QtGui.QOpenGLShader.log": (),
-    "PySide2.QtGui.QOpenGLShader.shaderId": (),
-    "PySide2.QtGui.QOpenGLShader.shaderType": (),
-    "PySide2.QtGui.QOpenGLShader.sourceCode": (),
-# class PySide2.QtGui.QOpenGLShaderProgram:
-    "PySide2.QtGui.QOpenGLShaderProgram.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'bytes'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'bytes'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.bind": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('bytes', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.create": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultInnerTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultOuterTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.disableAttributeArray": [('bytes',), ('int',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.enableAttributeArray": [('bytes',), ('int',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLShaderProgram.isLinked": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.link": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.log": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.patchVertexCount": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.programId": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.release": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeArray": [('bytes', 'int', 'int', 'int', 'int'), ('bytes', 'typing.Sequence', 'int', 'int'), ('int', 'int', 'int', 'int', 'int'), ('int', 'typing.Sequence', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeBuffer": [('bytes', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeValue": [('bytes', 'PySide2.QtGui.QColor'), ('bytes', 'PySide2.QtGui.QVector2D'), ('bytes', 'PySide2.QtGui.QVector3D'), ('bytes', 'PySide2.QtGui.QVector4D'), ('bytes', 'float'), ('bytes', 'float', 'float'), ('bytes', 'float', 'float', 'float'), ('bytes', 'float', 'float', 'float', 'float'), ('bytes', 'typing.Sequence', 'int', 'int'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'typing.Sequence', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultInnerTessellationLevels": ('typing.List',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultOuterTessellationLevels": ('typing.List',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setPatchVertexCount": ('int',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue": [('bytes', 'PySide2.QtCore.QPoint'), ('bytes', 'PySide2.QtCore.QPointF'), ('bytes', 'PySide2.QtCore.QSize'), ('bytes', 'PySide2.QtCore.QSizeF'), ('bytes', 'PySide2.QtGui.QColor'), ('bytes', 'PySide2.QtGui.QMatrix2x2'), ('bytes', 'PySide2.QtGui.QMatrix2x3'), ('bytes', 'PySide2.QtGui.QMatrix2x4'), ('bytes', 'PySide2.QtGui.QMatrix3x2'), ('bytes', 'PySide2.QtGui.QMatrix3x3'), ('bytes', 'PySide2.QtGui.QMatrix3x4'), ('bytes', 'PySide2.QtGui.QMatrix4x2'), ('bytes', 'PySide2.QtGui.QMatrix4x3'), ('bytes', 'PySide2.QtGui.QMatrix4x4'), ('bytes', 'PySide2.QtGui.QTransform'), ('bytes', 'PySide2.QtGui.QVector2D'), ('bytes', 'PySide2.QtGui.QVector3D'), ('bytes', 'PySide2.QtGui.QVector4D'), ('bytes', 'float', 'float'), ('bytes', 'float', 'float', 'float'), ('bytes', 'float', 'float', 'float', 'float'), ('bytes', 'typing.Tuple'), ('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('int', 'typing.Tuple')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1f": [('bytes', 'float'), ('int', 'float')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1i": [('bytes', 'int'), ('int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValueArray": [('bytes', 'typing.Sequence', 'int'), ('bytes', 'typing.Sequence', 'int', 'int'), ('int', 'typing.Sequence', 'int'), ('int', 'typing.Sequence', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.shaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-# class PySide2.QtGui.QOpenGLTexture:
-# class PySide2.QtGui.QOpenGLTexture.BindingTarget:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonFunction:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonMode:
-# class PySide2.QtGui.QOpenGLTexture.CoordinateDirection:
-# class PySide2.QtGui.QOpenGLTexture.CubeMapFace:
-# class PySide2.QtGui.QOpenGLTexture.DepthStencilMode:
-# class PySide2.QtGui.QOpenGLTexture.Feature:
-# class PySide2.QtGui.QOpenGLTexture.Features:
-# class PySide2.QtGui.QOpenGLTexture.Filter:
-# class PySide2.QtGui.QOpenGLTexture.MipMapGeneration:
-# class PySide2.QtGui.QOpenGLTexture.PixelFormat:
-# class PySide2.QtGui.QOpenGLTexture.PixelType:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleComponent:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleValue:
-# class PySide2.QtGui.QOpenGLTexture.Target:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormat:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormatClass:
-# class PySide2.QtGui.QOpenGLTexture.TextureUnitReset:
-# class PySide2.QtGui.QOpenGLTexture.WrapMode:
-    "PySide2.QtGui.QOpenGLTexture.__init__": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.Target',)],
-    "PySide2.QtGui.QOpenGLTexture.allocateStorage": [(), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType')],
-    "PySide2.QtGui.QOpenGLTexture.bind": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.borderColor": (),
-    "PySide2.QtGui.QOpenGLTexture.boundTextureId": [('PySide2.QtGui.QOpenGLTexture.BindingTarget',), ('int', 'PySide2.QtGui.QOpenGLTexture.BindingTarget')],
-    "PySide2.QtGui.QOpenGLTexture.comparisonFunction": (),
-    "PySide2.QtGui.QOpenGLTexture.comparisonMode": (),
-    "PySide2.QtGui.QOpenGLTexture.create": (),
-    "PySide2.QtGui.QOpenGLTexture.createTextureView": ('PySide2.QtGui.QOpenGLTexture.Target', 'PySide2.QtGui.QOpenGLTexture.TextureFormat', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.depth": (),
-    "PySide2.QtGui.QOpenGLTexture.depthStencilMode": (),
-    "PySide2.QtGui.QOpenGLTexture.destroy": (),
-    "PySide2.QtGui.QOpenGLTexture.faces": (),
-    "PySide2.QtGui.QOpenGLTexture.format": (),
-    "PySide2.QtGui.QOpenGLTexture.generateMipMaps": [(), ('int', 'bool')],
-    "PySide2.QtGui.QOpenGLTexture.hasFeature": ('PySide2.QtGui.QOpenGLTexture.Feature',),
-    "PySide2.QtGui.QOpenGLTexture.height": (),
-    "PySide2.QtGui.QOpenGLTexture.isAutoMipMapGenerationEnabled": (),
-    "PySide2.QtGui.QOpenGLTexture.isBound": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLTexture.isCreated": (),
-    "PySide2.QtGui.QOpenGLTexture.isFixedSamplePositions": (),
-    "PySide2.QtGui.QOpenGLTexture.isStorageAllocated": (),
-    "PySide2.QtGui.QOpenGLTexture.isTextureView": (),
-    "PySide2.QtGui.QOpenGLTexture.layers": (),
-    "PySide2.QtGui.QOpenGLTexture.levelOfDetailRange": (),
-    "PySide2.QtGui.QOpenGLTexture.levelofDetailBias": (),
-    "PySide2.QtGui.QOpenGLTexture.magnificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumAnisotropy": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumMipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.minMagFilters": (),
-    "PySide2.QtGui.QOpenGLTexture.minificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.minimumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.mipBaseLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevelRange": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.mipMaxLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.release": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.samples": (),
-    "PySide2.QtGui.QOpenGLTexture.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setBorderColor": [('PySide2.QtGui.QColor',), ('float', 'float', 'float', 'float'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLTexture.setComparisonFunction": ('PySide2.QtGui.QOpenGLTexture.ComparisonFunction',),
-    "PySide2.QtGui.QOpenGLTexture.setComparisonMode": ('PySide2.QtGui.QOpenGLTexture.ComparisonMode',),
-    "PySide2.QtGui.QOpenGLTexture.setCompressedData": [('int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setData": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setDepthStencilMode": ('PySide2.QtGui.QOpenGLTexture.DepthStencilMode',),
-    "PySide2.QtGui.QOpenGLTexture.setFixedSamplePositions": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.QtGui.QOpenGLTexture.setLayers": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setLevelOfDetailRange": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLTexture.setLevelofDetailBias": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMagnificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMinMagFilters": ('PySide2.QtGui.QOpenGLTexture.Filter', 'PySide2.QtGui.QOpenGLTexture.Filter'),
-    "PySide2.QtGui.QOpenGLTexture.setMinificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMinimumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMipBaseLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevelRange": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevels": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipMaxLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setSwizzleMask": [('PySide2.QtGui.QOpenGLTexture.SwizzleComponent', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue'), ('PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue')],
-    "PySide2.QtGui.QOpenGLTexture.setWrapMode": [('PySide2.QtGui.QOpenGLTexture.CoordinateDirection', 'PySide2.QtGui.QOpenGLTexture.WrapMode'), ('PySide2.QtGui.QOpenGLTexture.WrapMode',)],
-    "PySide2.QtGui.QOpenGLTexture.swizzleMask": ('PySide2.QtGui.QOpenGLTexture.SwizzleComponent',),
-    "PySide2.QtGui.QOpenGLTexture.target": (),
-    "PySide2.QtGui.QOpenGLTexture.textureId": (),
-    "PySide2.QtGui.QOpenGLTexture.width": (),
-    "PySide2.QtGui.QOpenGLTexture.wrapMode": ('PySide2.QtGui.QOpenGLTexture.CoordinateDirection',),
-# class PySide2.QtGui.QOpenGLTextureBlitter:
-# class PySide2.QtGui.QOpenGLTextureBlitter.Origin:
-    "PySide2.QtGui.QOpenGLTextureBlitter.__init__": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.bind": ('int',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.blit": [('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin')],
-    "PySide2.QtGui.QOpenGLTextureBlitter.create": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.destroy": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.isCreated": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.release": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setOpacity": ('float',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setRedBlueSwizzle": ('bool',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.sourceTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin'),
-    "PySide2.QtGui.QOpenGLTextureBlitter.supportsExternalOESTarget": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.targetTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect'),
-# class PySide2.QtGui.QOpenGLTimeMonitor:
-    "PySide2.QtGui.QOpenGLTimeMonitor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.create": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.destroy": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.objectIds": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.recordSample": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.reset": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.sampleCount": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.setSampleCount": ('int',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForIntervals": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.waitForSamples": (),
-# class PySide2.QtGui.QOpenGLTimerQuery:
-    "PySide2.QtGui.QOpenGLTimerQuery.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimerQuery.begin": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.create": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.destroy": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.end": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.objectId": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.recordTimestamp": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForResult": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.waitForTimestamp": (),
-# class PySide2.QtGui.QOpenGLVersionProfile:
-    "PySide2.QtGui.QOpenGLVersionProfile.__init__": [(), ('PySide2.QtGui.QOpenGLVersionProfile',), ('PySide2.QtGui.QSurfaceFormat',)],
-    "PySide2.QtGui.QOpenGLVersionProfile.__copy__": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.hasProfiles": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isLegacyVersion": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isValid": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.profile": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QOpenGLVersionProfile.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLVersionProfile.version": (),
-# class PySide2.QtGui.QOpenGLVertexArrayObject:
-# class PySide2.QtGui.QOpenGLVertexArrayObject.Binder:
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.__init__": ('PySide2.QtGui.QOpenGLVertexArrayObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.rebind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.release": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.bind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.create": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.destroy": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.isCreated": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.objectId": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.release": (),
-# class PySide2.QtGui.QOpenGLWindow:
-# class PySide2.QtGui.QOpenGLWindow.UpdateBehavior:
-    "PySide2.QtGui.QOpenGLWindow.__init__": [('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow'), ('PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtGui.QOpenGLWindow.context": (),
-    "PySide2.QtGui.QOpenGLWindow.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLWindow.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.grabFramebuffer": (),
-    "PySide2.QtGui.QOpenGLWindow.initializeGL": (),
-    "PySide2.QtGui.QOpenGLWindow.isValid": (),
-    "PySide2.QtGui.QOpenGLWindow.makeCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QOpenGLWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QOpenGLWindow.paintGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintOverGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintUnderGL": (),
-    "PySide2.QtGui.QOpenGLWindow.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QOpenGLWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QOpenGLWindow.resizeGL": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLWindow.shareContext": (),
-    "PySide2.QtGui.QOpenGLWindow.updateBehavior": (),
-# class PySide2.QtGui.QPageLayout:
-# class PySide2.QtGui.QPageLayout.Mode:
-# class PySide2.QtGui.QPageLayout.Orientation:
-# class PySide2.QtGui.QPageLayout.Unit:
-    "PySide2.QtGui.QPageLayout.__init__": [(), ('PySide2.QtGui.QPageLayout',), ('PySide2.QtGui.QPageSize', 'PySide2.QtGui.QPageLayout.Orientation', 'PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit', 'PySide2.QtCore.QMarginsF')],
-    "PySide2.QtGui.QPageLayout.__copy__": (),
-    "PySide2.QtGui.QPageLayout.fullRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.fullRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.fullRectPoints": (),
-    "PySide2.QtGui.QPageLayout.isEquivalentTo": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.isValid": (),
-    "PySide2.QtGui.QPageLayout.margins": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.marginsPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.marginsPoints": (),
-    "PySide2.QtGui.QPageLayout.maximumMargins": (),
-    "PySide2.QtGui.QPageLayout.minimumMargins": (),
-    "PySide2.QtGui.QPageLayout.mode": (),
-    "PySide2.QtGui.QPageLayout.orientation": (),
-    "PySide2.QtGui.QPageLayout.pageSize": (),
-    "PySide2.QtGui.QPageLayout.paintRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.paintRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.paintRectPoints": (),
-    "PySide2.QtGui.QPageLayout.setBottomMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setLeftMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMinimumMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMode": ('PySide2.QtGui.QPageLayout.Mode',),
-    "PySide2.QtGui.QPageLayout.setOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPageLayout.setPageSize": ('PySide2.QtGui.QPageSize', 'PySide2.QtCore.QMarginsF'),
-    "PySide2.QtGui.QPageLayout.setRightMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setTopMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setUnits": ('PySide2.QtGui.QPageLayout.Unit',),
-    "PySide2.QtGui.QPageLayout.swap": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.units": (),
-# class PySide2.QtGui.QPageSize:
-# class PySide2.QtGui.QPageSize.PageSizeId:
-# class PySide2.QtGui.QPageSize.SizeMatchPolicy:
-# class PySide2.QtGui.QPageSize.Unit:
-    "PySide2.QtGui.QPageSize.__init__": [(), ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.__copy__": (),
-    "PySide2.QtGui.QPageSize.definitionSize": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.definitionUnits": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.id": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('int',)],
-    "PySide2.QtGui.QPageSize.isEquivalentTo": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.isValid": (),
-    "PySide2.QtGui.QPageSize.key": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.name": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.rect": ('PySide2.QtGui.QPageSize.Unit',),
-    "PySide2.QtGui.QPageSize.rectPixels": ('int',),
-    "PySide2.QtGui.QPageSize.rectPoints": (),
-    "PySide2.QtGui.QPageSize.size": [('PySide2.QtGui.QPageSize.PageSizeId', 'PySide2.QtGui.QPageSize.Unit'), ('PySide2.QtGui.QPageSize.Unit',)],
-    "PySide2.QtGui.QPageSize.sizePixels": [('PySide2.QtGui.QPageSize.PageSizeId', 'int'), ('int',)],
-    "PySide2.QtGui.QPageSize.sizePoints": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.swap": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.windowsId": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-# class PySide2.QtGui.QPagedPaintDevice:
-# class PySide2.QtGui.QPagedPaintDevice.Margins:
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__init__": [(), ('PySide2.QtGui.QPagedPaintDevice.Margins',)],
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__copy__": (),
-# class PySide2.QtGui.QPagedPaintDevice.PageSize:
-# class PySide2.QtGui.QPagedPaintDevice.PdfVersion:
-    "PySide2.QtGui.QPagedPaintDevice.__init__": (),
-    "PySide2.QtGui.QPagedPaintDevice.devicePageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.margins": (),
-    "PySide2.QtGui.QPagedPaintDevice.newPage": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSize": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSizeMM": (),
-    "PySide2.QtGui.QPagedPaintDevice.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageLayout": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit')],
-    "PySide2.QtGui.QPagedPaintDevice.setPageOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtGui.QPagedPaintDevice.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtGui.QPaintDevice:
-# class PySide2.QtGui.QPaintDevice.PaintDeviceMetric:
-    "PySide2.QtGui.QPaintDevice.__init__": (),
-    "PySide2.QtGui.QPaintDevice.colorCount": (),
-    "PySide2.QtGui.QPaintDevice.depth": (),
-    "PySide2.QtGui.QPaintDevice.devType": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatio": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioF": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioFScale": (),
-    "PySide2.QtGui.QPaintDevice.height": (),
-    "PySide2.QtGui.QPaintDevice.heightMM": (),
-    "PySide2.QtGui.QPaintDevice.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPaintDevice.logicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.logicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDevice.paintEngine": (),
-    "PySide2.QtGui.QPaintDevice.paintingActive": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPaintDevice.sharedPainter": (),
-    "PySide2.QtGui.QPaintDevice.width": (),
-    "PySide2.QtGui.QPaintDevice.widthMM": (),
-# class PySide2.QtGui.QPaintDeviceWindow:
-    "PySide2.QtGui.QPaintDeviceWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEngine": (),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-# class PySide2.QtGui.QPaintEngine:
-# class PySide2.QtGui.QPaintEngine.DirtyFlag:
-# class PySide2.QtGui.QPaintEngine.DirtyFlags:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeature:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeatures:
-# class PySide2.QtGui.QPaintEngine.PolygonDrawMode:
-# class PySide2.QtGui.QPaintEngine.Type:
-    "PySide2.QtGui.QPaintEngine.__init__": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPaintEngine.clearDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.coordinateOffset": (),
-    "PySide2.QtGui.QPaintEngine.drawEllipse": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QPaintEngine.drawImage": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPaintEngine.drawLines": [('PySide2.QtCore.QLine', 'int'), ('PySide2.QtCore.QLineF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPaintEngine.drawPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QPaintEngine.drawPoints": [('PySide2.QtCore.QPoint', 'int'), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPolygon": [('PySide2.QtCore.QPoint', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode')],
-    "PySide2.QtGui.QPaintEngine.drawRects": [('PySide2.QtCore.QRect', 'int'), ('PySide2.QtCore.QRectF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawTextItem": ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'),
-    "PySide2.QtGui.QPaintEngine.drawTiledPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPaintEngine.end": (),
-    "PySide2.QtGui.QPaintEngine.hasFeature": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.isActive": (),
-    "PySide2.QtGui.QPaintEngine.isExtended": (),
-    "PySide2.QtGui.QPaintEngine.paintDevice": (),
-    "PySide2.QtGui.QPaintEngine.painter": (),
-    "PySide2.QtGui.QPaintEngine.setActive": ('bool',),
-    "PySide2.QtGui.QPaintEngine.setDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.setSystemClip": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPaintEngine.setSystemRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPaintEngine.syncState": (),
-    "PySide2.QtGui.QPaintEngine.systemClip": (),
-    "PySide2.QtGui.QPaintEngine.systemRect": (),
-    "PySide2.QtGui.QPaintEngine.testDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.type": (),
-    "PySide2.QtGui.QPaintEngine.updateState": ('PySide2.QtGui.QPaintEngineState',),
-# class PySide2.QtGui.QPaintEngineState:
-    "PySide2.QtGui.QPaintEngineState.__init__": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundBrush": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundMode": (),
-    "PySide2.QtGui.QPaintEngineState.brush": (),
-    "PySide2.QtGui.QPaintEngineState.brushNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.brushOrigin": (),
-    "PySide2.QtGui.QPaintEngineState.clipOperation": (),
-    "PySide2.QtGui.QPaintEngineState.clipPath": (),
-    "PySide2.QtGui.QPaintEngineState.clipRegion": (),
-    "PySide2.QtGui.QPaintEngineState.compositionMode": (),
-    "PySide2.QtGui.QPaintEngineState.font": (),
-    "PySide2.QtGui.QPaintEngineState.isClipEnabled": (),
-    "PySide2.QtGui.QPaintEngineState.matrix": (),
-    "PySide2.QtGui.QPaintEngineState.opacity": (),
-    "PySide2.QtGui.QPaintEngineState.painter": (),
-    "PySide2.QtGui.QPaintEngineState.pen": (),
-    "PySide2.QtGui.QPaintEngineState.penNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.renderHints": (),
-    "PySide2.QtGui.QPaintEngineState.state": (),
-    "PySide2.QtGui.QPaintEngineState.transform": (),
-# class PySide2.QtGui.QPaintEvent:
-    "PySide2.QtGui.QPaintEvent.__init__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QPaintEvent.rect": (),
-    "PySide2.QtGui.QPaintEvent.region": (),
-# class PySide2.QtGui.QPainter:
-# class PySide2.QtGui.QPainter.CompositionMode:
-# class PySide2.QtGui.QPainter.PixmapFragment:
-    "PySide2.QtGui.QPainter.PixmapFragment.__init__": [(), ('PySide2.QtGui.QPainter.PixmapFragment',)],
-    "PySide2.QtGui.QPainter.PixmapFragment.__copy__": (),
-    "PySide2.QtGui.QPainter.PixmapFragment.create": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QRectF', 'float', 'float', 'float', 'float'),
-# class PySide2.QtGui.QPainter.PixmapFragmentHint:
-# class PySide2.QtGui.QPainter.PixmapFragmentHints:
-# class PySide2.QtGui.QPainter.RenderHint:
-# class PySide2.QtGui.QPainter.RenderHints:
-    "PySide2.QtGui.QPainter.__init__": [(), ('PySide2.QtGui.QPaintDevice',)],
-    "PySide2.QtGui.QPainter.background": (),
-    "PySide2.QtGui.QPainter.backgroundMode": (),
-    "PySide2.QtGui.QPainter.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.beginNativePainting": (),
-    "PySide2.QtGui.QPainter.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str'), ('PySide2.QtCore.QRectF', 'int', 'str'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.brush": (),
-    "PySide2.QtGui.QPainter.brushOrigin": (),
-    "PySide2.QtGui.QPainter.clipBoundingRect": (),
-    "PySide2.QtGui.QPainter.clipPath": (),
-    "PySide2.QtGui.QPainter.clipRegion": (),
-    "PySide2.QtGui.QPainter.combinedMatrix": (),
-    "PySide2.QtGui.QPainter.combinedTransform": (),
-    "PySide2.QtGui.QPainter.compositionMode": (),
-    "PySide2.QtGui.QPainter.device": (),
-    "PySide2.QtGui.QPainter.deviceMatrix": (),
-    "PySide2.QtGui.QPainter.deviceTransform": (),
-    "PySide2.QtGui.QPainter.drawArc": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawChord": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawConvexPolygon": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List',)],
-    "PySide2.QtGui.QPainter.drawEllipse": [('PySide2.QtCore.QPoint', 'int', 'int'), ('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawImage": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('int', 'int', 'PySide2.QtGui.QImage', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPainter.drawLine": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawLines": ('typing.List',),
-    "PySide2.QtGui.QPainter.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainter.drawPicture": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPicture'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPicture'), ('int', 'int', 'PySide2.QtGui.QPicture')],
-    "PySide2.QtGui.QPainter.drawPie": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmap": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmapFragments": ('PySide2.QtGui.QPainter.PixmapFragment', 'int', 'PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPainter.PixmapFragmentHints'),
-    "PySide2.QtGui.QPainter.drawPoint": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.drawPoints": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List',)],
-    "PySide2.QtGui.QPainter.drawPolygon": [('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.FillRule'), ('typing.List', 'PySide2.QtCore.Qt.FillRule')],
-    "PySide2.QtGui.QPainter.drawPolyline": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List',)],
-    "PySide2.QtGui.QPainter.drawRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRects": ('typing.List',),
-    "PySide2.QtGui.QPainter.drawRoundRect": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRoundedRect": [('PySide2.QtCore.QRect', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('int', 'int', 'int', 'int', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainter.drawStaticText": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QStaticText'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QStaticText'), ('int', 'int', 'PySide2.QtGui.QStaticText')],
-    "PySide2.QtGui.QPainter.drawText": [('PySide2.QtCore.QPoint', 'str'), ('PySide2.QtCore.QPointF', 'str'), ('PySide2.QtCore.QRect', 'int', 'str', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'int', 'str', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str', 'PySide2.QtCore.QRect'), ('int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.drawTextItem": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QTextItem'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'), ('int', 'int', 'PySide2.QtGui.QTextItem')],
-    "PySide2.QtGui.QPainter.drawTiledPixmap": [('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QPainter.end": (),
-    "PySide2.QtGui.QPainter.endNativePainting": (),
-    "PySide2.QtGui.QPainter.eraseRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.fillPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPainter.fillRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QGradient.Preset'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QGradient.Preset'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.BrushStyle'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.GlobalColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QBrush'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QGradient.Preset')],
-    "PySide2.QtGui.QPainter.font": (),
-    "PySide2.QtGui.QPainter.fontInfo": (),
-    "PySide2.QtGui.QPainter.fontMetrics": (),
-    "PySide2.QtGui.QPainter.hasClipping": (),
-    "PySide2.QtGui.QPainter.initFrom": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.isActive": (),
-    "PySide2.QtGui.QPainter.layoutDirection": (),
-    "PySide2.QtGui.QPainter.matrix": (),
-    "PySide2.QtGui.QPainter.matrixEnabled": (),
-    "PySide2.QtGui.QPainter.opacity": (),
-    "PySide2.QtGui.QPainter.paintEngine": (),
-    "PySide2.QtGui.QPainter.pen": (),
-    "PySide2.QtGui.QPainter.redirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.renderHints": (),
-    "PySide2.QtGui.QPainter.resetMatrix": (),
-    "PySide2.QtGui.QPainter.resetTransform": (),
-    "PySide2.QtGui.QPainter.restore": (),
-    "PySide2.QtGui.QPainter.restoreRedirected": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.rotate": ('float',),
-    "PySide2.QtGui.QPainter.save": (),
-    "PySide2.QtGui.QPainter.scale": ('float', 'float'),
-    "PySide2.QtGui.QPainter.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPainter.setBackgroundMode": ('PySide2.QtCore.Qt.BGMode',),
-    "PySide2.QtGui.QPainter.setBrush": [('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtGui.QBrush',)],
-    "PySide2.QtGui.QPainter.setBrushOrigin": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.setClipPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ClipOperation'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ClipOperation'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ClipOperation')],
-    "PySide2.QtGui.QPainter.setClipRegion": ('PySide2.QtGui.QRegion', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipping": ('bool',),
-    "PySide2.QtGui.QPainter.setCompositionMode": ('PySide2.QtGui.QPainter.CompositionMode',),
-    "PySide2.QtGui.QPainter.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QPainter.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QPainter.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setOpacity": ('float',),
-    "PySide2.QtGui.QPainter.setPen": [('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainter.setRedirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtGui.QPainter.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints', 'bool'),
-    "PySide2.QtGui.QPainter.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.setViewTransformEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setViewport": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWindow": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWorldMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setWorldMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setWorldTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.shear": ('float', 'float'),
-    "PySide2.QtGui.QPainter.strokePath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen'),
-    "PySide2.QtGui.QPainter.testRenderHint": ('PySide2.QtGui.QPainter.RenderHint',),
-    "PySide2.QtGui.QPainter.transform": (),
-    "PySide2.QtGui.QPainter.translate": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainter.viewTransformEnabled": (),
-    "PySide2.QtGui.QPainter.viewport": (),
-    "PySide2.QtGui.QPainter.window": (),
-    "PySide2.QtGui.QPainter.worldMatrix": (),
-    "PySide2.QtGui.QPainter.worldMatrixEnabled": (),
-    "PySide2.QtGui.QPainter.worldTransform": (),
-# class PySide2.QtGui.QPainterPath:
-# class PySide2.QtGui.QPainterPath.Element:
-    "PySide2.QtGui.QPainterPath.Element.__init__": [(), ('PySide2.QtGui.QPainterPath.Element',)],
-    "PySide2.QtGui.QPainterPath.Element.__copy__": (),
-    "PySide2.QtGui.QPainterPath.Element.isCurveTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isLineTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isMoveTo": (),
-# class PySide2.QtGui.QPainterPath.ElementType:
-    "PySide2.QtGui.QPainterPath.__init__": [(), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.__add__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__and__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__copy__": (),
-    "PySide2.QtGui.QPainterPath.__iadd__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__iand__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__ior__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__isub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.__or__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__sub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addEllipse": [('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPainterPath.addRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPainterPath.addRoundRect": [('PySide2.QtCore.QRectF', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtGui.QPainterPath.addRoundedRect": [('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('float', 'float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainterPath.addText": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QFont', 'str'), ('float', 'float', 'PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtGui.QPainterPath.angleAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.arcMoveTo": [('PySide2.QtCore.QRectF', 'float'), ('float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.arcTo": [('PySide2.QtCore.QRectF', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.boundingRect": (),
-    "PySide2.QtGui.QPainterPath.capacity": (),
-    "PySide2.QtGui.QPainterPath.clear": (),
-    "PySide2.QtGui.QPainterPath.closeSubpath": (),
-    "PySide2.QtGui.QPainterPath.connectPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.controlPointRect": (),
-    "PySide2.QtGui.QPainterPath.cubicTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.currentPosition": (),
-    "PySide2.QtGui.QPainterPath.elementAt": ('int',),
-    "PySide2.QtGui.QPainterPath.elementCount": (),
-    "PySide2.QtGui.QPainterPath.fillRule": (),
-    "PySide2.QtGui.QPainterPath.intersected": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.intersects": [('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.isEmpty": (),
-    "PySide2.QtGui.QPainterPath.length": (),
-    "PySide2.QtGui.QPainterPath.lineTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.percentAtLength": ('float',),
-    "PySide2.QtGui.QPainterPath.pointAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.quadTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.reserve": ('int',),
-    "PySide2.QtGui.QPainterPath.setElementPositionAt": ('int', 'float', 'float'),
-    "PySide2.QtGui.QPainterPath.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtGui.QPainterPath.simplified": (),
-    "PySide2.QtGui.QPainterPath.slopeAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.subtracted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.subtractedInverted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.swap": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.toFillPolygon": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toFillPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toReversed": (),
-    "PySide2.QtGui.QPainterPath.toSubpathPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.united": ('PySide2.QtGui.QPainterPath',),
-# class PySide2.QtGui.QPainterPathStroker:
-    "PySide2.QtGui.QPainterPathStroker.__init__": [(), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainterPathStroker.capStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.createStroke": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPathStroker.curveThreshold": (),
-    "PySide2.QtGui.QPainterPathStroker.dashOffset": (),
-    "PySide2.QtGui.QPainterPathStroker.dashPattern": (),
-    "PySide2.QtGui.QPainterPathStroker.joinStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.miterLimit": (),
-    "PySide2.QtGui.QPainterPathStroker.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setCurveThreshold": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashOffset": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashPattern": [('PySide2.QtCore.Qt.PenStyle',), ('typing.List',)],
-    "PySide2.QtGui.QPainterPathStroker.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setWidth": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.width": (),
-# class PySide2.QtGui.QPalette:
-# class PySide2.QtGui.QPalette.ColorGroup:
-# class PySide2.QtGui.QPalette.ColorRole:
-    "PySide2.QtGui.QPalette.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette',)],
-    "PySide2.QtGui.QPalette.__copy__": (),
-    "PySide2.QtGui.QPalette.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.alternateBase": (),
-    "PySide2.QtGui.QPalette.background": (),
-    "PySide2.QtGui.QPalette.base": (),
-    "PySide2.QtGui.QPalette.brightText": (),
-    "PySide2.QtGui.QPalette.brush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.button": (),
-    "PySide2.QtGui.QPalette.buttonText": (),
-    "PySide2.QtGui.QPalette.cacheKey": (),
-    "PySide2.QtGui.QPalette.color": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.currentColorGroup": (),
-    "PySide2.QtGui.QPalette.dark": (),
-    "PySide2.QtGui.QPalette.foreground": (),
-    "PySide2.QtGui.QPalette.highlight": (),
-    "PySide2.QtGui.QPalette.highlightedText": (),
-    "PySide2.QtGui.QPalette.isBrushSet": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtGui.QPalette.isCopyOf": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.isEqual": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorGroup'),
-    "PySide2.QtGui.QPalette.light": (),
-    "PySide2.QtGui.QPalette.link": (),
-    "PySide2.QtGui.QPalette.linkVisited": (),
-    "PySide2.QtGui.QPalette.mid": (),
-    "PySide2.QtGui.QPalette.midlight": (),
-    "PySide2.QtGui.QPalette.placeholderText": (),
-    "PySide2.QtGui.QPalette.resolve": [(), ('PySide2.QtGui.QPalette',), ('int',)],
-    "PySide2.QtGui.QPalette.setBrush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtGui.QPalette.setColor": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QPalette.setColorGroup": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPalette.setCurrentColorGroup": ('PySide2.QtGui.QPalette.ColorGroup',),
-    "PySide2.QtGui.QPalette.shadow": (),
-    "PySide2.QtGui.QPalette.swap": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.text": (),
-    "PySide2.QtGui.QPalette.toolTipBase": (),
-    "PySide2.QtGui.QPalette.toolTipText": (),
-    "PySide2.QtGui.QPalette.window": (),
-    "PySide2.QtGui.QPalette.windowText": (),
-# class PySide2.QtGui.QPdfWriter:
-    "PySide2.QtGui.QPdfWriter.__init__": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPdfWriter.creator": (),
-    "PySide2.QtGui.QPdfWriter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPdfWriter.newPage": (),
-    "PySide2.QtGui.QPdfWriter.paintEngine": (),
-    "PySide2.QtGui.QPdfWriter.pdfVersion": (),
-    "PySide2.QtGui.QPdfWriter.resolution": (),
-    "PySide2.QtGui.QPdfWriter.setCreator": ('str',),
-    "PySide2.QtGui.QPdfWriter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPdfWriter.setPageSize": ('PySide2.QtGui.QPagedPaintDevice.PageSize',),
-    "PySide2.QtGui.QPdfWriter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QPdfWriter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtGui.QPdfWriter.setResolution": ('int',),
-    "PySide2.QtGui.QPdfWriter.setTitle": ('str',),
-    "PySide2.QtGui.QPdfWriter.title": (),
-# class PySide2.QtGui.QPen:
-    "PySide2.QtGui.QPen.__init__": [(), ('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QBrush', 'float', 'PySide2.QtCore.Qt.PenStyle', 'PySide2.QtCore.Qt.PenCapStyle', 'PySide2.QtCore.Qt.PenJoinStyle'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPen.__copy__": (),
-    "PySide2.QtGui.QPen.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.brush": (),
-    "PySide2.QtGui.QPen.capStyle": (),
-    "PySide2.QtGui.QPen.color": (),
-    "PySide2.QtGui.QPen.dashOffset": (),
-    "PySide2.QtGui.QPen.dashPattern": (),
-    "PySide2.QtGui.QPen.isCosmetic": (),
-    "PySide2.QtGui.QPen.isSolid": (),
-    "PySide2.QtGui.QPen.joinStyle": (),
-    "PySide2.QtGui.QPen.miterLimit": (),
-    "PySide2.QtGui.QPen.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPen.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPen.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QPen.setCosmetic": ('bool',),
-    "PySide2.QtGui.QPen.setDashOffset": ('float',),
-    "PySide2.QtGui.QPen.setDashPattern": ('typing.List',),
-    "PySide2.QtGui.QPen.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPen.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPen.setStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtGui.QPen.setWidth": ('int',),
-    "PySide2.QtGui.QPen.setWidthF": ('float',),
-    "PySide2.QtGui.QPen.style": (),
-    "PySide2.QtGui.QPen.swap": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QPen.width": (),
-    "PySide2.QtGui.QPen.widthF": (),
-# class PySide2.QtGui.QPicture:
-    "PySide2.QtGui.QPicture.__init__": [('PySide2.QtGui.QPicture',), ('int',)],
-    "PySide2.QtGui.QPicture.__copy__": (),
-    "PySide2.QtGui.QPicture.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.boundingRect": (),
-    "PySide2.QtGui.QPicture.data": (),
-    "PySide2.QtGui.QPicture.devType": (),
-    "PySide2.QtGui.QPicture.inputFormatList": (),
-    "PySide2.QtGui.QPicture.inputFormats": (),
-    "PySide2.QtGui.QPicture.isNull": (),
-    "PySide2.QtGui.QPicture.load": [('PySide2.QtCore.QIODevice', 'bytes'), ('str', 'bytes')],
-    "PySide2.QtGui.QPicture.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPicture.outputFormatList": (),
-    "PySide2.QtGui.QPicture.outputFormats": (),
-    "PySide2.QtGui.QPicture.paintEngine": (),
-    "PySide2.QtGui.QPicture.pictureFormat": ('str',),
-    "PySide2.QtGui.QPicture.play": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPicture.save": [('PySide2.QtCore.QIODevice', 'bytes'), ('str', 'bytes')],
-    "PySide2.QtGui.QPicture.setBoundingRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPicture.setData": ('bytes', 'int'),
-    "PySide2.QtGui.QPicture.size": (),
-    "PySide2.QtGui.QPicture.swap": ('PySide2.QtGui.QPicture',),
-# class PySide2.QtGui.QPictureIO:
-    "PySide2.QtGui.QPictureIO.__init__": [(), ('PySide2.QtCore.QIODevice', 'bytes'), ('str', 'bytes')],
-    "PySide2.QtGui.QPictureIO.description": (),
-    "PySide2.QtGui.QPictureIO.fileName": (),
-    "PySide2.QtGui.QPictureIO.format": (),
-    "PySide2.QtGui.QPictureIO.gamma": (),
-    "PySide2.QtGui.QPictureIO.inputFormats": (),
-    "PySide2.QtGui.QPictureIO.ioDevice": (),
-    "PySide2.QtGui.QPictureIO.outputFormats": (),
-    "PySide2.QtGui.QPictureIO.parameters": (),
-    "PySide2.QtGui.QPictureIO.picture": (),
-    "PySide2.QtGui.QPictureIO.pictureFormat": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPictureIO.quality": (),
-    "PySide2.QtGui.QPictureIO.read": (),
-    "PySide2.QtGui.QPictureIO.setDescription": ('str',),
-    "PySide2.QtGui.QPictureIO.setFileName": ('str',),
-    "PySide2.QtGui.QPictureIO.setFormat": ('bytes',),
-    "PySide2.QtGui.QPictureIO.setGamma": ('float',),
-    "PySide2.QtGui.QPictureIO.setIODevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QPictureIO.setParameters": ('bytes',),
-    "PySide2.QtGui.QPictureIO.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtGui.QPictureIO.setQuality": ('int',),
-    "PySide2.QtGui.QPictureIO.setStatus": ('int',),
-    "PySide2.QtGui.QPictureIO.status": (),
-    "PySide2.QtGui.QPictureIO.write": (),
-# class PySide2.QtGui.QPixelFormat:
-# class PySide2.QtGui.QPixelFormat.AlphaPosition:
-# class PySide2.QtGui.QPixelFormat.AlphaPremultiplied:
-# class PySide2.QtGui.QPixelFormat.AlphaUsage:
-# class PySide2.QtGui.QPixelFormat.ByteOrder:
-# class PySide2.QtGui.QPixelFormat.ColorModel:
-# class PySide2.QtGui.QPixelFormat.TypeInterpretation:
-# class PySide2.QtGui.QPixelFormat.YUVLayout:
-    "PySide2.QtGui.QPixelFormat.__init__": [(), ('PySide2.QtGui.QPixelFormat',), ('PySide2.QtGui.QPixelFormat.ColorModel', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QPixelFormat.AlphaUsage', 'PySide2.QtGui.QPixelFormat.AlphaPosition', 'PySide2.QtGui.QPixelFormat.AlphaPremultiplied', 'PySide2.QtGui.QPixelFormat.TypeInterpretation', 'PySide2.QtGui.QPixelFormat.ByteOrder', 'int')],
-    "PySide2.QtGui.QPixelFormat.__copy__": (),
-    "PySide2.QtGui.QPixelFormat.alphaPosition": (),
-    "PySide2.QtGui.QPixelFormat.alphaSize": (),
-    "PySide2.QtGui.QPixelFormat.alphaUsage": (),
-    "PySide2.QtGui.QPixelFormat.bitsPerPixel": (),
-    "PySide2.QtGui.QPixelFormat.blackSize": (),
-    "PySide2.QtGui.QPixelFormat.blueSize": (),
-    "PySide2.QtGui.QPixelFormat.brightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.byteOrder": (),
-    "PySide2.QtGui.QPixelFormat.channelCount": (),
-    "PySide2.QtGui.QPixelFormat.colorModel": (),
-    "PySide2.QtGui.QPixelFormat.cyanSize": (),
-    "PySide2.QtGui.QPixelFormat.greenSize": (),
-    "PySide2.QtGui.QPixelFormat.hueSize": (),
-    "PySide2.QtGui.QPixelFormat.lightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.magentaSize": (),
-    "PySide2.QtGui.QPixelFormat.premultiplied": (),
-    "PySide2.QtGui.QPixelFormat.redSize": (),
-    "PySide2.QtGui.QPixelFormat.saturationSize": (),
-    "PySide2.QtGui.QPixelFormat.subEnum": (),
-    "PySide2.QtGui.QPixelFormat.typeInterpretation": (),
-    "PySide2.QtGui.QPixelFormat.yellowSize": (),
-    "PySide2.QtGui.QPixelFormat.yuvLayout": (),
-# class PySide2.QtGui.QPixmap:
-    "PySide2.QtGui.QPixmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'bytes', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('typing.Sequence',)],
-    "PySide2.QtGui.QPixmap.__copy__": (),
-    "PySide2.QtGui.QPixmap.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.cacheKey": (),
-    "PySide2.QtGui.QPixmap.convertFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QPixmap.createMaskFromColor": ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QPixmap.defaultDepth": (),
-    "PySide2.QtGui.QPixmap.depth": (),
-    "PySide2.QtGui.QPixmap.devType": (),
-    "PySide2.QtGui.QPixmap.devicePixelRatio": (),
-    "PySide2.QtGui.QPixmap.fill": [('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QPaintDevice', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageInPlace": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageReader": ('PySide2.QtGui.QImageReader', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.grabWidget": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QObject', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QPixmap.hasAlpha": (),
-    "PySide2.QtGui.QPixmap.hasAlphaChannel": (),
-    "PySide2.QtGui.QPixmap.height": (),
-    "PySide2.QtGui.QPixmap.isNull": (),
-    "PySide2.QtGui.QPixmap.isQBitmap": (),
-    "PySide2.QtGui.QPixmap.load": ('str', 'bytes', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.loadFromData": [('PySide2.QtCore.QByteArray', 'bytes', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('bytes', 'int', 'bytes', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPixmap.mask": (),
-    "PySide2.QtGui.QPixmap.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPixmap.paintEngine": (),
-    "PySide2.QtGui.QPixmap.rect": (),
-    "PySide2.QtGui.QPixmap.save": [('PySide2.QtCore.QIODevice', 'bytes', 'int'), ('str', 'bytes', 'int')],
-    "PySide2.QtGui.QPixmap.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scroll": [('int', 'int', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion')],
-    "PySide2.QtGui.QPixmap.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QPixmap.setMask": ('PySide2.QtGui.QBitmap',),
-    "PySide2.QtGui.QPixmap.size": (),
-    "PySide2.QtGui.QPixmap.swap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QPixmap.toImage": (),
-    "PySide2.QtGui.QPixmap.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.width": (),
-# class PySide2.QtGui.QPixmapCache:
-# class PySide2.QtGui.QPixmapCache.Key:
-    "PySide2.QtGui.QPixmapCache.Key.__init__": [(), ('PySide2.QtGui.QPixmapCache.Key',)],
-    "PySide2.QtGui.QPixmapCache.Key.__copy__": (),
-    "PySide2.QtGui.QPixmapCache.Key.isValid": (),
-    "PySide2.QtGui.QPixmapCache.Key.swap": ('PySide2.QtGui.QPixmapCache.Key',),
-    "PySide2.QtGui.QPixmapCache.__init__": (),
-    "PySide2.QtGui.QPixmapCache.cacheLimit": (),
-    "PySide2.QtGui.QPixmapCache.clear": (),
-    "PySide2.QtGui.QPixmapCache.find": [('PySide2.QtGui.QPixmapCache.Key',), ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'), ('str',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.insert": [('PySide2.QtGui.QPixmap',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.remove": [('PySide2.QtGui.QPixmapCache.Key',), ('str',)],
-    "PySide2.QtGui.QPixmapCache.replace": ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtGui.QPixmapCache.setCacheLimit": ('int',),
-# class PySide2.QtGui.QPointingDeviceUniqueId:
-    "PySide2.QtGui.QPointingDeviceUniqueId.__init__": [(), ('PySide2.QtGui.QPointingDeviceUniqueId',)],
-    "PySide2.QtGui.QPointingDeviceUniqueId.__copy__": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.fromNumericId": ('int',),
-    "PySide2.QtGui.QPointingDeviceUniqueId.isValid": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.numericId": (),
-# class PySide2.QtGui.QPolygon:
-    "PySide2.QtGui.QPolygon.__init__": [(), ('PySide2.QtCore.QRect', 'bool'), ('PySide2.QtGui.QPolygon',), ('int',), ('typing.List',)],
-    "PySide2.QtGui.QPolygon.__add__": ('typing.List',),
-    "PySide2.QtGui.QPolygon.__copy__": (),
-    "PySide2.QtGui.QPolygon.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.__lshift__": [('PySide2.QtCore.QDataStream',), ('PySide2.QtCore.QPoint',), ('typing.List',)],
-    "PySide2.QtGui.QPolygon.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygon.__reduce__": (),
-    "PySide2.QtGui.QPolygon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygon.append": [('PySide2.QtCore.QPoint',), ('typing.List',)],
-    "PySide2.QtGui.QPolygon.at": ('int',),
-    "PySide2.QtGui.QPolygon.back": (),
-    "PySide2.QtGui.QPolygon.boundingRect": (),
-    "PySide2.QtGui.QPolygon.capacity": (),
-    "PySide2.QtGui.QPolygon.clear": (),
-    "PySide2.QtGui.QPolygon.constData": (),
-    "PySide2.QtGui.QPolygon.constFirst": (),
-    "PySide2.QtGui.QPolygon.constLast": (),
-    "PySide2.QtGui.QPolygon.contains": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.containsPoint": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygon.count": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtGui.QPolygon.data": (),
-    "PySide2.QtGui.QPolygon.empty": (),
-    "PySide2.QtGui.QPolygon.endsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.fill": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.first": (),
-    "PySide2.QtGui.QPolygon.fromList": ('typing.Sequence',),
-    "PySide2.QtGui.QPolygon.front": (),
-    "PySide2.QtGui.QPolygon.indexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.insert": [('int', 'PySide2.QtCore.QPoint'), ('int', 'int', 'PySide2.QtCore.QPoint')],
-    "PySide2.QtGui.QPolygon.intersected": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.intersects": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.isEmpty": (),
-    "PySide2.QtGui.QPolygon.isSharedWith": ('typing.List',),
-    "PySide2.QtGui.QPolygon.last": (),
-    "PySide2.QtGui.QPolygon.lastIndexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.length": (),
-    "PySide2.QtGui.QPolygon.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.pop_back": (),
-    "PySide2.QtGui.QPolygon.pop_front": (),
-    "PySide2.QtGui.QPolygon.prepend": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_back": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_front": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.removeAll": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.removeAt": ('int',),
-    "PySide2.QtGui.QPolygon.removeFirst": (),
-    "PySide2.QtGui.QPolygon.removeLast": (),
-    "PySide2.QtGui.QPolygon.removeOne": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.replace": ('int', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPolygon.reserve": ('int',),
-    "PySide2.QtGui.QPolygon.resize": ('int',),
-    "PySide2.QtGui.QPolygon.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygon.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygon.size": (),
-    "PySide2.QtGui.QPolygon.squeeze": (),
-    "PySide2.QtGui.QPolygon.startsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.subtracted": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swap": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.takeAt": ('int',),
-    "PySide2.QtGui.QPolygon.takeFirst": (),
-    "PySide2.QtGui.QPolygon.takeLast": (),
-    "PySide2.QtGui.QPolygon.toList": (),
-    "PySide2.QtGui.QPolygon.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.united": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.value": [('int',), ('int', 'PySide2.QtCore.QPoint')],
-# class PySide2.QtGui.QPolygonF:
-    "PySide2.QtGui.QPolygonF.__init__": [(), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('int',), ('typing.List',)],
-    "PySide2.QtGui.QPolygonF.__add__": ('typing.List',),
-    "PySide2.QtGui.QPolygonF.__copy__": (),
-    "PySide2.QtGui.QPolygonF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygonF.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.append": [('PySide2.QtCore.QPointF',), ('typing.List',)],
-    "PySide2.QtGui.QPolygonF.at": ('int',),
-    "PySide2.QtGui.QPolygonF.back": (),
-    "PySide2.QtGui.QPolygonF.boundingRect": (),
-    "PySide2.QtGui.QPolygonF.capacity": (),
-    "PySide2.QtGui.QPolygonF.clear": (),
-    "PySide2.QtGui.QPolygonF.constData": (),
-    "PySide2.QtGui.QPolygonF.constFirst": (),
-    "PySide2.QtGui.QPolygonF.constLast": (),
-    "PySide2.QtGui.QPolygonF.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.containsPoint": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygonF.count": [(), ('PySide2.QtCore.QPointF',)],
-    "PySide2.QtGui.QPolygonF.data": (),
-    "PySide2.QtGui.QPolygonF.empty": (),
-    "PySide2.QtGui.QPolygonF.endsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.fill": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.first": (),
-    "PySide2.QtGui.QPolygonF.fromList": ('typing.Sequence',),
-    "PySide2.QtGui.QPolygonF.front": (),
-    "PySide2.QtGui.QPolygonF.indexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.insert": [('int', 'PySide2.QtCore.QPointF'), ('int', 'int', 'PySide2.QtCore.QPointF')],
-    "PySide2.QtGui.QPolygonF.intersected": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.intersects": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.isClosed": (),
-    "PySide2.QtGui.QPolygonF.isEmpty": (),
-    "PySide2.QtGui.QPolygonF.isSharedWith": ('typing.List',),
-    "PySide2.QtGui.QPolygonF.last": (),
-    "PySide2.QtGui.QPolygonF.lastIndexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.length": (),
-    "PySide2.QtGui.QPolygonF.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.pop_back": (),
-    "PySide2.QtGui.QPolygonF.pop_front": (),
-    "PySide2.QtGui.QPolygonF.prepend": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_back": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_front": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygonF.removeAll": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.removeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.removeFirst": (),
-    "PySide2.QtGui.QPolygonF.removeLast": (),
-    "PySide2.QtGui.QPolygonF.removeOne": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.replace": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPolygonF.reserve": ('int',),
-    "PySide2.QtGui.QPolygonF.resize": ('int',),
-    "PySide2.QtGui.QPolygonF.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygonF.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygonF.size": (),
-    "PySide2.QtGui.QPolygonF.squeeze": (),
-    "PySide2.QtGui.QPolygonF.startsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.subtracted": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swap": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.takeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.takeFirst": (),
-    "PySide2.QtGui.QPolygonF.takeLast": (),
-    "PySide2.QtGui.QPolygonF.toList": (),
-    "PySide2.QtGui.QPolygonF.toPolygon": (),
-    "PySide2.QtGui.QPolygonF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.united": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.value": [('int',), ('int', 'PySide2.QtCore.QPointF')],
-# class PySide2.QtGui.QPyTextObject:
-    "PySide2.QtGui.QPyTextObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QPyTextObject.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QPyTextObject.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QQuaternion:
-    "PySide2.QtGui.QQuaternion.__init__": [(), ('PySide2.QtGui.QVector4D',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.__add__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__copy__": (),
-    "PySide2.QtGui.QQuaternion.__iadd__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__imul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__isub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__mul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__neg__": (),
-    "PySide2.QtGui.QQuaternion.__reduce__": (),
-    "PySide2.QtGui.QQuaternion.__repr__": (),
-    "PySide2.QtGui.QQuaternion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__sub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.conjugate": (),
-    "PySide2.QtGui.QQuaternion.conjugated": (),
-    "PySide2.QtGui.QQuaternion.dotProduct": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion'),
-    "PySide2.QtGui.QQuaternion.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromDirection": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromRotationMatrix": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QQuaternion.getAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.inverted": (),
-    "PySide2.QtGui.QQuaternion.isIdentity": (),
-    "PySide2.QtGui.QQuaternion.isNull": (),
-    "PySide2.QtGui.QQuaternion.length": (),
-    "PySide2.QtGui.QQuaternion.lengthSquared": (),
-    "PySide2.QtGui.QQuaternion.nlerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.normalize": (),
-    "PySide2.QtGui.QQuaternion.normalized": (),
-    "PySide2.QtGui.QQuaternion.rotatedVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QQuaternion.rotationTo": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.scalar": (),
-    "PySide2.QtGui.QQuaternion.setScalar": ('float',),
-    "PySide2.QtGui.QQuaternion.setVector": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.setX": ('float',),
-    "PySide2.QtGui.QQuaternion.setY": ('float',),
-    "PySide2.QtGui.QQuaternion.setZ": ('float',),
-    "PySide2.QtGui.QQuaternion.slerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.toEulerAngles": (),
-    "PySide2.QtGui.QQuaternion.toRotationMatrix": (),
-    "PySide2.QtGui.QQuaternion.toVector4D": (),
-    "PySide2.QtGui.QQuaternion.vector": (),
-    "PySide2.QtGui.QQuaternion.x": (),
-    "PySide2.QtGui.QQuaternion.y": (),
-    "PySide2.QtGui.QQuaternion.z": (),
-# class PySide2.QtGui.QRadialGradient:
-    "PySide2.QtGui.QRadialGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QRadialGradient',), ('float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QRadialGradient.__copy__": (),
-    "PySide2.QtGui.QRadialGradient.center": (),
-    "PySide2.QtGui.QRadialGradient.centerRadius": (),
-    "PySide2.QtGui.QRadialGradient.focalPoint": (),
-    "PySide2.QtGui.QRadialGradient.focalRadius": (),
-    "PySide2.QtGui.QRadialGradient.radius": (),
-    "PySide2.QtGui.QRadialGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setCenterRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setFocalPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setFocalRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setRadius": ('float',),
-# class PySide2.QtGui.QRasterWindow:
-    "PySide2.QtGui.QRasterWindow.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QRasterWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QRasterWindow.redirected": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtGui.QRawFont:
-# class PySide2.QtGui.QRawFont.AntialiasingType:
-# class PySide2.QtGui.QRawFont.LayoutFlag:
-# class PySide2.QtGui.QRawFont.LayoutFlags:
-    "PySide2.QtGui.QRawFont.__init__": [(), ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'), ('PySide2.QtGui.QRawFont',), ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference')],
-    "PySide2.QtGui.QRawFont.__copy__": (),
-    "PySide2.QtGui.QRawFont.advancesForGlyphIndexes": [('typing.List',), ('typing.List', 'PySide2.QtGui.QRawFont.LayoutFlags')],
-    "PySide2.QtGui.QRawFont.alphaMapForGlyph": ('int', 'PySide2.QtGui.QRawFont.AntialiasingType', 'PySide2.QtGui.QTransform'),
-    "PySide2.QtGui.QRawFont.ascent": (),
-    "PySide2.QtGui.QRawFont.averageCharWidth": (),
-    "PySide2.QtGui.QRawFont.boundingRect": ('int',),
-    "PySide2.QtGui.QRawFont.capHeight": (),
-    "PySide2.QtGui.QRawFont.descent": (),
-    "PySide2.QtGui.QRawFont.familyName": (),
-    "PySide2.QtGui.QRawFont.fontTable": ('bytes',),
-    "PySide2.QtGui.QRawFont.fromFont": ('PySide2.QtGui.QFont', 'PySide2.QtGui.QFontDatabase.WritingSystem'),
-    "PySide2.QtGui.QRawFont.glyphIndexesForString": ('str',),
-    "PySide2.QtGui.QRawFont.hintingPreference": (),
-    "PySide2.QtGui.QRawFont.isValid": (),
-    "PySide2.QtGui.QRawFont.leading": (),
-    "PySide2.QtGui.QRawFont.lineThickness": (),
-    "PySide2.QtGui.QRawFont.loadFromData": ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.loadFromFile": ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.maxCharWidth": (),
-    "PySide2.QtGui.QRawFont.pathForGlyph": ('int',),
-    "PySide2.QtGui.QRawFont.pixelSize": (),
-    "PySide2.QtGui.QRawFont.setPixelSize": ('float',),
-    "PySide2.QtGui.QRawFont.style": (),
-    "PySide2.QtGui.QRawFont.styleName": (),
-    "PySide2.QtGui.QRawFont.supportedWritingSystems": (),
-    "PySide2.QtGui.QRawFont.supportsCharacter": [('int',), ('str',)],
-    "PySide2.QtGui.QRawFont.swap": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QRawFont.underlinePosition": (),
-    "PySide2.QtGui.QRawFont.unitsPerEm": (),
-    "PySide2.QtGui.QRawFont.weight": (),
-    "PySide2.QtGui.QRawFont.xHeight": (),
-# class PySide2.QtGui.QRegExpValidator:
-    "PySide2.QtGui.QRegExpValidator.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRegExp', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QRegExpValidator.regExp": (),
-    "PySide2.QtGui.QRegExpValidator.setRegExp": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtGui.QRegExpValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QRegion:
-# class PySide2.QtGui.QRegion.RegionType:
-    "PySide2.QtGui.QRegion.__init__": [(), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion.RegionType'), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion.RegionType')],
-    "PySide2.QtGui.QRegion.__add__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__and__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__copy__": (),
-    "PySide2.QtGui.QRegion.__iadd__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__ior__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__isub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__ixor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QRegion.__or__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__sub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__xor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.begin": (),
-    "PySide2.QtGui.QRegion.boundingRect": (),
-    "PySide2.QtGui.QRegion.cbegin": (),
-    "PySide2.QtGui.QRegion.cend": (),
-    "PySide2.QtGui.QRegion.contains": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QRegion.end": (),
-    "PySide2.QtGui.QRegion.intersected": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.intersects": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.isEmpty": (),
-    "PySide2.QtGui.QRegion.isNull": (),
-    "PySide2.QtGui.QRegion.rectCount": (),
-    "PySide2.QtGui.QRegion.rects": (),
-    "PySide2.QtGui.QRegion.setRects": ('PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtGui.QRegion.subtracted": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.swap": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.united": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.xored": ('PySide2.QtGui.QRegion',),
-# class PySide2.QtGui.QResizeEvent:
-    "PySide2.QtGui.QResizeEvent.__init__": ('PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtGui.QResizeEvent.oldSize": (),
-    "PySide2.QtGui.QResizeEvent.size": (),
-# class PySide2.QtGui.QScreen:
-    "PySide2.QtGui.QScreen.angleBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation'),
-    "PySide2.QtGui.QScreen.availableGeometry": (),
-    "PySide2.QtGui.QScreen.availableSize": (),
-    "PySide2.QtGui.QScreen.availableVirtualGeometry": (),
-    "PySide2.QtGui.QScreen.availableVirtualSize": (),
-    "PySide2.QtGui.QScreen.depth": (),
-    "PySide2.QtGui.QScreen.devicePixelRatio": (),
-    "PySide2.QtGui.QScreen.geometry": (),
-    "PySide2.QtGui.QScreen.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QScreen.isLandscape": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.isPortrait": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.logicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.manufacturer": (),
-    "PySide2.QtGui.QScreen.mapBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.model": (),
-    "PySide2.QtGui.QScreen.name": (),
-    "PySide2.QtGui.QScreen.nativeOrientation": (),
-    "PySide2.QtGui.QScreen.orientation": (),
-    "PySide2.QtGui.QScreen.orientationUpdateMask": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.physicalSize": (),
-    "PySide2.QtGui.QScreen.primaryOrientation": (),
-    "PySide2.QtGui.QScreen.refreshRate": (),
-    "PySide2.QtGui.QScreen.serialNumber": (),
-    "PySide2.QtGui.QScreen.setOrientationUpdateMask": ('PySide2.QtCore.Qt.ScreenOrientations',),
-    "PySide2.QtGui.QScreen.size": (),
-    "PySide2.QtGui.QScreen.transformBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.virtualGeometry": (),
-    "PySide2.QtGui.QScreen.virtualSiblings": (),
-    "PySide2.QtGui.QScreen.virtualSize": (),
-# class PySide2.QtGui.QScrollEvent:
-# class PySide2.QtGui.QScrollEvent.ScrollState:
-    "PySide2.QtGui.QScrollEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QScrollEvent.ScrollState'),
-    "PySide2.QtGui.QScrollEvent.contentPos": (),
-    "PySide2.QtGui.QScrollEvent.overshootDistance": (),
-    "PySide2.QtGui.QScrollEvent.scrollState": (),
-# class PySide2.QtGui.QScrollPrepareEvent:
-    "PySide2.QtGui.QScrollPrepareEvent.__init__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPosRange": (),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPosRange": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setViewportSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QScrollPrepareEvent.startPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.viewportSize": (),
-# class PySide2.QtGui.QSessionManager:
-# class PySide2.QtGui.QSessionManager.RestartHint:
-    "PySide2.QtGui.QSessionManager.allowsErrorInteraction": (),
-    "PySide2.QtGui.QSessionManager.allowsInteraction": (),
-    "PySide2.QtGui.QSessionManager.cancel": (),
-    "PySide2.QtGui.QSessionManager.discardCommand": (),
-    "PySide2.QtGui.QSessionManager.isPhase2": (),
-    "PySide2.QtGui.QSessionManager.release": (),
-    "PySide2.QtGui.QSessionManager.requestPhase2": (),
-    "PySide2.QtGui.QSessionManager.restartCommand": (),
-    "PySide2.QtGui.QSessionManager.restartHint": (),
-    "PySide2.QtGui.QSessionManager.sessionId": (),
-    "PySide2.QtGui.QSessionManager.sessionKey": (),
-    "PySide2.QtGui.QSessionManager.setDiscardCommand": ('typing.Sequence',),
-    "PySide2.QtGui.QSessionManager.setManagerProperty": [('str', 'str'), ('str', 'typing.Sequence')],
-    "PySide2.QtGui.QSessionManager.setRestartCommand": ('typing.Sequence',),
-    "PySide2.QtGui.QSessionManager.setRestartHint": ('PySide2.QtGui.QSessionManager.RestartHint',),
-# class PySide2.QtGui.QShortcutEvent:
-    "PySide2.QtGui.QShortcutEvent.__init__": ('PySide2.QtGui.QKeySequence', 'int', 'bool'),
-    "PySide2.QtGui.QShortcutEvent.isAmbiguous": (),
-    "PySide2.QtGui.QShortcutEvent.key": (),
-    "PySide2.QtGui.QShortcutEvent.shortcutId": (),
-# class PySide2.QtGui.QShowEvent:
-    "PySide2.QtGui.QShowEvent.__init__": (),
-# class PySide2.QtGui.QStandardItem:
-# class PySide2.QtGui.QStandardItem.ItemType:
-    "PySide2.QtGui.QStandardItem.__init__": [(), ('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QStandardItem',), ('int', 'int'), ('str',)],
-    "PySide2.QtGui.QStandardItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.accessibleDescription": (),
-    "PySide2.QtGui.QStandardItem.accessibleText": (),
-    "PySide2.QtGui.QStandardItem.appendColumn": ('typing.Sequence',),
-    "PySide2.QtGui.QStandardItem.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence',)],
-    "PySide2.QtGui.QStandardItem.appendRows": ('typing.Sequence',),
-    "PySide2.QtGui.QStandardItem.background": (),
-    "PySide2.QtGui.QStandardItem.checkState": (),
-    "PySide2.QtGui.QStandardItem.child": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.clearData": (),
-    "PySide2.QtGui.QStandardItem.clone": (),
-    "PySide2.QtGui.QStandardItem.column": (),
-    "PySide2.QtGui.QStandardItem.columnCount": (),
-    "PySide2.QtGui.QStandardItem.data": ('int',),
-    "PySide2.QtGui.QStandardItem.emitDataChanged": (),
-    "PySide2.QtGui.QStandardItem.flags": (),
-    "PySide2.QtGui.QStandardItem.font": (),
-    "PySide2.QtGui.QStandardItem.foreground": (),
-    "PySide2.QtGui.QStandardItem.hasChildren": (),
-    "PySide2.QtGui.QStandardItem.icon": (),
-    "PySide2.QtGui.QStandardItem.index": (),
-    "PySide2.QtGui.QStandardItem.insertColumn": ('int', 'typing.Sequence'),
-    "PySide2.QtGui.QStandardItem.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.insertRow": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence')],
-    "PySide2.QtGui.QStandardItem.insertRows": [('int', 'int'), ('int', 'typing.Sequence')],
-    "PySide2.QtGui.QStandardItem.isAutoTristate": (),
-    "PySide2.QtGui.QStandardItem.isCheckable": (),
-    "PySide2.QtGui.QStandardItem.isDragEnabled": (),
-    "PySide2.QtGui.QStandardItem.isDropEnabled": (),
-    "PySide2.QtGui.QStandardItem.isEditable": (),
-    "PySide2.QtGui.QStandardItem.isEnabled": (),
-    "PySide2.QtGui.QStandardItem.isSelectable": (),
-    "PySide2.QtGui.QStandardItem.isTristate": (),
-    "PySide2.QtGui.QStandardItem.isUserTristate": (),
-    "PySide2.QtGui.QStandardItem.model": (),
-    "PySide2.QtGui.QStandardItem.parent": (),
-    "PySide2.QtGui.QStandardItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.removeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.removeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.row": (),
-    "PySide2.QtGui.QStandardItem.rowCount": (),
-    "PySide2.QtGui.QStandardItem.setAccessibleDescription": ('str',),
-    "PySide2.QtGui.QStandardItem.setAccessibleText": ('str',),
-    "PySide2.QtGui.QStandardItem.setAutoTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtGui.QStandardItem.setCheckable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setChild": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItem.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setData": ('typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItem.setDragEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setDropEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEditable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtGui.QStandardItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QStandardItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QStandardItem.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setSelectable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QStandardItem.setStatusTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setText": ('str',),
-    "PySide2.QtGui.QStandardItem.setTextAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QStandardItem.setToolTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setUserTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setWhatsThis": ('str',),
-    "PySide2.QtGui.QStandardItem.sizeHint": (),
-    "PySide2.QtGui.QStandardItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItem.statusTip": (),
-    "PySide2.QtGui.QStandardItem.takeChild": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.text": (),
-    "PySide2.QtGui.QStandardItem.textAlignment": (),
-    "PySide2.QtGui.QStandardItem.toolTip": (),
-    "PySide2.QtGui.QStandardItem.type": (),
-    "PySide2.QtGui.QStandardItem.whatsThis": (),
-    "PySide2.QtGui.QStandardItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QStandardItemModel:
-    "PySide2.QtGui.QStandardItemModel.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QStandardItemModel.appendColumn": ('typing.Sequence',),
-    "PySide2.QtGui.QStandardItemModel.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence',)],
-    "PySide2.QtGui.QStandardItemModel.clear": (),
-    "PySide2.QtGui.QStandardItemModel.clearItemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtGui.QStandardItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtGui.QStandardItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtGui.QStandardItemModel.horizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.indexFromItem": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.insertColumn": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'typing.Sequence')],
-    "PySide2.QtGui.QStandardItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.insertRow": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence')],
-    "PySide2.QtGui.QStandardItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.invisibleRootItem": (),
-    "PySide2.QtGui.QStandardItemModel.item": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemPrototype": (),
-    "PySide2.QtGui.QStandardItemModel.mimeData": ('typing.List',),
-    "PySide2.QtGui.QStandardItemModel.mimeTypes": (),
-    "PySide2.QtGui.QStandardItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtGui.QStandardItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderLabels": ('typing.Sequence',),
-    "PySide2.QtGui.QStandardItemModel.setItem": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict'),
-    "PySide2.QtGui.QStandardItemModel.setItemPrototype": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.setItemRoleNames": ('typing.Dict',),
-    "PySide2.QtGui.QStandardItemModel.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setSortRole": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderLabels": ('typing.Sequence',),
-    "PySide2.QtGui.QStandardItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItemModel.sortRole": (),
-    "PySide2.QtGui.QStandardItemModel.supportedDropActions": (),
-    "PySide2.QtGui.QStandardItemModel.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeItem": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.verticalHeaderItem": ('int',),
-# class PySide2.QtGui.QStaticText:
-# class PySide2.QtGui.QStaticText.PerformanceHint:
-    "PySide2.QtGui.QStaticText.__init__": [(), ('PySide2.QtGui.QStaticText',), ('str',)],
-    "PySide2.QtGui.QStaticText.__copy__": (),
-    "PySide2.QtGui.QStaticText.performanceHint": (),
-    "PySide2.QtGui.QStaticText.prepare": ('PySide2.QtGui.QTransform', 'PySide2.QtGui.QFont'),
-    "PySide2.QtGui.QStaticText.setPerformanceHint": ('PySide2.QtGui.QStaticText.PerformanceHint',),
-    "PySide2.QtGui.QStaticText.setText": ('str',),
-    "PySide2.QtGui.QStaticText.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtGui.QStaticText.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QStaticText.setTextWidth": ('float',),
-    "PySide2.QtGui.QStaticText.size": (),
-    "PySide2.QtGui.QStaticText.swap": ('PySide2.QtGui.QStaticText',),
-    "PySide2.QtGui.QStaticText.text": (),
-    "PySide2.QtGui.QStaticText.textFormat": (),
-    "PySide2.QtGui.QStaticText.textOption": (),
-    "PySide2.QtGui.QStaticText.textWidth": (),
-# class PySide2.QtGui.QStatusTipEvent:
-    "PySide2.QtGui.QStatusTipEvent.__init__": ('str',),
-    "PySide2.QtGui.QStatusTipEvent.tip": (),
-# class PySide2.QtGui.QStyleHints:
-    "PySide2.QtGui.QStyleHints.cursorFlashTime": (),
-    "PySide2.QtGui.QStyleHints.fontSmoothingGamma": (),
-    "PySide2.QtGui.QStyleHints.keyboardAutoRepeatRate": (),
-    "PySide2.QtGui.QStyleHints.keyboardInputInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickDistance": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickInterval": (),
-    "PySide2.QtGui.QStyleHints.mousePressAndHoldInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseQuickSelectionThreshold": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskCharacter": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskDelay": (),
-    "PySide2.QtGui.QStyleHints.setCursorFlashTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setFocusOnTouchRelease": (),
-    "PySide2.QtGui.QStyleHints.setKeyboardInputInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseDoubleClickInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMousePressAndHoldInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseQuickSelectionThreshold": ('int',),
-    "PySide2.QtGui.QStyleHints.setShowShortcutsInContextMenus": ('bool',),
-    "PySide2.QtGui.QStyleHints.setStartDragDistance": ('int',),
-    "PySide2.QtGui.QStyleHints.setStartDragTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setTabFocusBehavior": ('PySide2.QtCore.Qt.TabFocusBehavior',),
-    "PySide2.QtGui.QStyleHints.setUseHoverEffects": ('bool',),
-    "PySide2.QtGui.QStyleHints.setWheelScrollLines": ('int',),
-    "PySide2.QtGui.QStyleHints.showIsFullScreen": (),
-    "PySide2.QtGui.QStyleHints.showIsMaximized": (),
-    "PySide2.QtGui.QStyleHints.showShortcutsInContextMenus": (),
-    "PySide2.QtGui.QStyleHints.singleClickActivation": (),
-    "PySide2.QtGui.QStyleHints.startDragDistance": (),
-    "PySide2.QtGui.QStyleHints.startDragTime": (),
-    "PySide2.QtGui.QStyleHints.startDragVelocity": (),
-    "PySide2.QtGui.QStyleHints.tabFocusBehavior": (),
-    "PySide2.QtGui.QStyleHints.touchDoubleTapDistance": (),
-    "PySide2.QtGui.QStyleHints.useHoverEffects": (),
-    "PySide2.QtGui.QStyleHints.useRtlExtensions": (),
-    "PySide2.QtGui.QStyleHints.wheelScrollLines": (),
-# class PySide2.QtGui.QSurface:
-# class PySide2.QtGui.QSurface.SurfaceClass:
-# class PySide2.QtGui.QSurface.SurfaceType:
-    "PySide2.QtGui.QSurface.__init__": ('PySide2.QtGui.QSurface.SurfaceClass',),
-    "PySide2.QtGui.QSurface.format": (),
-    "PySide2.QtGui.QSurface.size": (),
-    "PySide2.QtGui.QSurface.supportsOpenGL": (),
-    "PySide2.QtGui.QSurface.surfaceClass": (),
-    "PySide2.QtGui.QSurface.surfaceHandle": (),
-    "PySide2.QtGui.QSurface.surfaceType": (),
-# class PySide2.QtGui.QSurfaceFormat:
-# class PySide2.QtGui.QSurfaceFormat.ColorSpace:
-# class PySide2.QtGui.QSurfaceFormat.FormatOption:
-# class PySide2.QtGui.QSurfaceFormat.FormatOptions:
-# class PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile:
-# class PySide2.QtGui.QSurfaceFormat.RenderableType:
-# class PySide2.QtGui.QSurfaceFormat.SwapBehavior:
-    "PySide2.QtGui.QSurfaceFormat.__init__": [(), ('PySide2.QtGui.QSurfaceFormat',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.__copy__": (),
-    "PySide2.QtGui.QSurfaceFormat.alphaBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.blueBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.colorSpace": (),
-    "PySide2.QtGui.QSurfaceFormat.defaultFormat": (),
-    "PySide2.QtGui.QSurfaceFormat.depthBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.greenBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.hasAlpha": (),
-    "PySide2.QtGui.QSurfaceFormat.majorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.minorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.options": (),
-    "PySide2.QtGui.QSurfaceFormat.profile": (),
-    "PySide2.QtGui.QSurfaceFormat.redBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.renderableType": (),
-    "PySide2.QtGui.QSurfaceFormat.samples": (),
-    "PySide2.QtGui.QSurfaceFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setColorSpace": ('PySide2.QtGui.QSurfaceFormat.ColorSpace',),
-    "PySide2.QtGui.QSurfaceFormat.setDefaultFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QSurfaceFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMajorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMinorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption', 'bool'), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.setOptions": ('PySide2.QtGui.QSurfaceFormat.FormatOptions',),
-    "PySide2.QtGui.QSurfaceFormat.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QSurfaceFormat.setRedBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setRenderableType": ('PySide2.QtGui.QSurfaceFormat.RenderableType',),
-    "PySide2.QtGui.QSurfaceFormat.setSamples": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStereo": ('bool',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapBehavior": ('PySide2.QtGui.QSurfaceFormat.SwapBehavior',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapInterval": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QSurfaceFormat.stencilBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.stereo": (),
-    "PySide2.QtGui.QSurfaceFormat.swapBehavior": (),
-    "PySide2.QtGui.QSurfaceFormat.swapInterval": (),
-    "PySide2.QtGui.QSurfaceFormat.testOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.version": (),
-# class PySide2.QtGui.QSyntaxHighlighter:
-    "PySide2.QtGui.QSyntaxHighlighter.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QTextDocument',)],
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlock": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockUserData": (),
-    "PySide2.QtGui.QSyntaxHighlighter.document": (),
-    "PySide2.QtGui.QSyntaxHighlighter.format": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.highlightBlock": ('str',),
-    "PySide2.QtGui.QSyntaxHighlighter.previousBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlight": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlightBlock": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockState": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QSyntaxHighlighter.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QSyntaxHighlighter.setFormat": [('int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QFont'), ('int', 'int', 'PySide2.QtGui.QTextCharFormat')],
-# class PySide2.QtGui.QTabletEvent:
-# class PySide2.QtGui.QTabletEvent.PointerType:
-# class PySide2.QtGui.QTabletEvent.TabletDevice:
-    "PySide2.QtGui.QTabletEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons')],
-    "PySide2.QtGui.QTabletEvent.button": (),
-    "PySide2.QtGui.QTabletEvent.buttons": (),
-    "PySide2.QtGui.QTabletEvent.device": (),
-    "PySide2.QtGui.QTabletEvent.globalPos": (),
-    "PySide2.QtGui.QTabletEvent.globalPosF": (),
-    "PySide2.QtGui.QTabletEvent.globalX": (),
-    "PySide2.QtGui.QTabletEvent.global""Y": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobalX": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobal""Y": (),
-    "PySide2.QtGui.QTabletEvent.pointerType": (),
-    "PySide2.QtGui.QTabletEvent.pos": (),
-    "PySide2.QtGui.QTabletEvent.posF": (),
-    "PySide2.QtGui.QTabletEvent.pressure": (),
-    "PySide2.QtGui.QTabletEvent.rotation": (),
-    "PySide2.QtGui.QTabletEvent.tangentialPressure": (),
-    "PySide2.QtGui.QTabletEvent.uniqueId": (),
-    "PySide2.QtGui.QTabletEvent.x": (),
-    "PySide2.QtGui.QTabletEvent.xTilt": (),
-    "PySide2.QtGui.QTabletEvent.y": (),
-    "PySide2.QtGui.QTabletEvent.yTilt": (),
-    "PySide2.QtGui.QTabletEvent.z": (),
-# class PySide2.QtGui.QTextBlock:
-# class PySide2.QtGui.QTextBlock.iterator:
-    "PySide2.QtGui.QTextBlock.iterator.__init__": [(), ('PySide2.QtGui.QTextBlock.iterator',)],
-    "PySide2.QtGui.QTextBlock.iterator.__copy__": (),
-    "PySide2.QtGui.QTextBlock.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__iter__": (),
-    "PySide2.QtGui.QTextBlock.iterator.atEnd": (),
-    "PySide2.QtGui.QTextBlock.iterator.fragment": (),
-    "PySide2.QtGui.QTextBlock.__init__": [(), ('PySide2.QtGui.QTextBlock',)],
-    "PySide2.QtGui.QTextBlock.__copy__": (),
-    "PySide2.QtGui.QTextBlock.__iter__": (),
-    "PySide2.QtGui.QTextBlock.begin": (),
-    "PySide2.QtGui.QTextBlock.blockFormat": (),
-    "PySide2.QtGui.QTextBlock.blockFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.blockNumber": (),
-    "PySide2.QtGui.QTextBlock.charFormat": (),
-    "PySide2.QtGui.QTextBlock.charFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.clearLayout": (),
-    "PySide2.QtGui.QTextBlock.contains": ('int',),
-    "PySide2.QtGui.QTextBlock.document": (),
-    "PySide2.QtGui.QTextBlock.end": (),
-    "PySide2.QtGui.QTextBlock.firstLineNumber": (),
-    "PySide2.QtGui.QTextBlock.fragmentIndex": (),
-    "PySide2.QtGui.QTextBlock.isValid": (),
-    "PySide2.QtGui.QTextBlock.isVisible": (),
-    "PySide2.QtGui.QTextBlock.layout": (),
-    "PySide2.QtGui.QTextBlock.length": (),
-    "PySide2.QtGui.QTextBlock.lineCount": (),
-    "PySide2.QtGui.QTextBlock.position": (),
-    "PySide2.QtGui.QTextBlock.previous": (),
-    "PySide2.QtGui.QTextBlock.revision": (),
-    "PySide2.QtGui.QTextBlock.setLineCount": ('int',),
-    "PySide2.QtGui.QTextBlock.setRevision": ('int',),
-    "PySide2.QtGui.QTextBlock.setUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QTextBlock.setUserState": ('int',),
-    "PySide2.QtGui.QTextBlock.setVisible": ('bool',),
-    "PySide2.QtGui.QTextBlock.text": (),
-    "PySide2.QtGui.QTextBlock.textDirection": (),
-    "PySide2.QtGui.QTextBlock.textFormats": (),
-    "PySide2.QtGui.QTextBlock.textList": (),
-    "PySide2.QtGui.QTextBlock.userData": (),
-    "PySide2.QtGui.QTextBlock.userState": (),
-# class PySide2.QtGui.QTextBlockFormat:
-# class PySide2.QtGui.QTextBlockFormat.LineHeightTypes:
-# class PySide2.QtGui.QTextBlockFormat.MarkerType:
-    "PySide2.QtGui.QTextBlockFormat.__init__": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextBlockFormat.__copy__": (),
-    "PySide2.QtGui.QTextBlockFormat.alignment": (),
-    "PySide2.QtGui.QTextBlockFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.headingLevel": (),
-    "PySide2.QtGui.QTextBlockFormat.indent": (),
-    "PySide2.QtGui.QTextBlockFormat.isValid": (),
-    "PySide2.QtGui.QTextBlockFormat.leftMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.lineHeight": [(), ('float', 'float')],
-    "PySide2.QtGui.QTextBlockFormat.lineHeightType": (),
-    "PySide2.QtGui.QTextBlockFormat.marker": (),
-    "PySide2.QtGui.QTextBlockFormat.nonBreakableLines": (),
-    "PySide2.QtGui.QTextBlockFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextBlockFormat.rightMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextBlockFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setHeadingLevel": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setLineHeight": ('float', 'int'),
-    "PySide2.QtGui.QTextBlockFormat.setMarker": ('PySide2.QtGui.QTextBlockFormat.MarkerType',),
-    "PySide2.QtGui.QTextBlockFormat.setNonBreakableLines": ('bool',),
-    "PySide2.QtGui.QTextBlockFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextBlockFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTabPositions": ('typing.Sequence',),
-    "PySide2.QtGui.QTextBlockFormat.setTextIndent": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.tabPositions": (),
-    "PySide2.QtGui.QTextBlockFormat.textIndent": (),
-    "PySide2.QtGui.QTextBlockFormat.topMargin": (),
-# class PySide2.QtGui.QTextBlockGroup:
-    "PySide2.QtGui.QTextBlockGroup.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextBlockGroup.blockFormatChanged": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockInserted": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockList": (),
-    "PySide2.QtGui.QTextBlockGroup.blockRemoved": ('PySide2.QtGui.QTextBlock',),
-# class PySide2.QtGui.QTextBlockUserData:
-    "PySide2.QtGui.QTextBlockUserData.__init__": (),
-# class PySide2.QtGui.QTextCharFormat:
-# class PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior:
-# class PySide2.QtGui.QTextCharFormat.UnderlineStyle:
-# class PySide2.QtGui.QTextCharFormat.VerticalAlignment:
-    "PySide2.QtGui.QTextCharFormat.__init__": [(), ('PySide2.QtGui.QTextCharFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextCharFormat.__copy__": (),
-    "PySide2.QtGui.QTextCharFormat.anchorHref": (),
-    "PySide2.QtGui.QTextCharFormat.anchorName": (),
-    "PySide2.QtGui.QTextCharFormat.anchorNames": (),
-    "PySide2.QtGui.QTextCharFormat.font": (),
-    "PySide2.QtGui.QTextCharFormat.fontCapitalization": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamilies": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamily": (),
-    "PySide2.QtGui.QTextCharFormat.fontFixedPitch": (),
-    "PySide2.QtGui.QTextCharFormat.fontHintingPreference": (),
-    "PySide2.QtGui.QTextCharFormat.fontItalic": (),
-    "PySide2.QtGui.QTextCharFormat.fontKerning": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacingType": (),
-    "PySide2.QtGui.QTextCharFormat.fontOverline": (),
-    "PySide2.QtGui.QTextCharFormat.fontPointSize": (),
-    "PySide2.QtGui.QTextCharFormat.fontStretch": (),
-    "PySide2.QtGui.QTextCharFormat.fontStrikeOut": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleHint": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleName": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleStrategy": (),
-    "PySide2.QtGui.QTextCharFormat.fontUnderline": (),
-    "PySide2.QtGui.QTextCharFormat.fontWeight": (),
-    "PySide2.QtGui.QTextCharFormat.fontWordSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.isAnchor": (),
-    "PySide2.QtGui.QTextCharFormat.isValid": (),
-    "PySide2.QtGui.QTextCharFormat.setAnchor": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorHref": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorNames": ('typing.Sequence',),
-    "PySide2.QtGui.QTextCharFormat.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior')],
-    "PySide2.QtGui.QTextCharFormat.setFontCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamilies": ('typing.Sequence',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamily": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontFixedPitch": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QTextCharFormat.setFontItalic": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontKerning": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacingType": ('PySide2.QtGui.QFont.SpacingType',),
-    "PySide2.QtGui.QTextCharFormat.setFontOverline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontPointSize": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontStretch": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontStrikeOut": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QTextCharFormat.setFontUnderline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontWeight": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontWordSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellColumnSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellRowSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTextOutline": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QTextCharFormat.setToolTip": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineStyle": ('PySide2.QtGui.QTextCharFormat.UnderlineStyle',),
-    "PySide2.QtGui.QTextCharFormat.setVerticalAlignment": ('PySide2.QtGui.QTextCharFormat.VerticalAlignment',),
-    "PySide2.QtGui.QTextCharFormat.tableCellColumnSpan": (),
-    "PySide2.QtGui.QTextCharFormat.tableCellRowSpan": (),
-    "PySide2.QtGui.QTextCharFormat.textOutline": (),
-    "PySide2.QtGui.QTextCharFormat.toolTip": (),
-    "PySide2.QtGui.QTextCharFormat.underlineColor": (),
-    "PySide2.QtGui.QTextCharFormat.underlineStyle": (),
-    "PySide2.QtGui.QTextCharFormat.verticalAlignment": (),
-# class PySide2.QtGui.QTextCursor:
-# class PySide2.QtGui.QTextCursor.MoveMode:
-# class PySide2.QtGui.QTextCursor.MoveOperation:
-# class PySide2.QtGui.QTextCursor.SelectionType:
-    "PySide2.QtGui.QTextCursor.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextFrame',)],
-    "PySide2.QtGui.QTextCursor.__copy__": (),
-    "PySide2.QtGui.QTextCursor.anchor": (),
-    "PySide2.QtGui.QTextCursor.atBlockEnd": (),
-    "PySide2.QtGui.QTextCursor.atBlockStart": (),
-    "PySide2.QtGui.QTextCursor.atEnd": (),
-    "PySide2.QtGui.QTextCursor.atStart": (),
-    "PySide2.QtGui.QTextCursor.beginEditBlock": (),
-    "PySide2.QtGui.QTextCursor.block": (),
-    "PySide2.QtGui.QTextCursor.blockCharFormat": (),
-    "PySide2.QtGui.QTextCursor.blockFormat": (),
-    "PySide2.QtGui.QTextCursor.blockNumber": (),
-    "PySide2.QtGui.QTextCursor.charFormat": (),
-    "PySide2.QtGui.QTextCursor.clearSelection": (),
-    "PySide2.QtGui.QTextCursor.columnNumber": (),
-    "PySide2.QtGui.QTextCursor.createList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.currentFrame": (),
-    "PySide2.QtGui.QTextCursor.currentList": (),
-    "PySide2.QtGui.QTextCursor.currentTable": (),
-    "PySide2.QtGui.QTextCursor.deleteChar": (),
-    "PySide2.QtGui.QTextCursor.deletePreviousChar": (),
-    "PySide2.QtGui.QTextCursor.document": (),
-    "PySide2.QtGui.QTextCursor.endEditBlock": (),
-    "PySide2.QtGui.QTextCursor.hasComplexSelection": (),
-    "PySide2.QtGui.QTextCursor.hasSelection": (),
-    "PySide2.QtGui.QTextCursor.insertBlock": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextBlockFormat', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.insertFragment": ('PySide2.QtGui.QTextDocumentFragment',),
-    "PySide2.QtGui.QTextCursor.insertFrame": ('PySide2.QtGui.QTextFrameFormat',),
-    "PySide2.QtGui.QTextCursor.insertHtml": ('str',),
-    "PySide2.QtGui.QTextCursor.insertImage": [('PySide2.QtGui.QImage', 'str'), ('PySide2.QtGui.QTextImageFormat',), ('PySide2.QtGui.QTextImageFormat', 'PySide2.QtGui.QTextFrameFormat.Position'), ('str',)],
-    "PySide2.QtGui.QTextCursor.insertList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.insertTable": [('int', 'int'), ('int', 'int', 'PySide2.QtGui.QTextTableFormat')],
-    "PySide2.QtGui.QTextCursor.insertText": [('str',), ('str', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.isCopyOf": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.isNull": (),
-    "PySide2.QtGui.QTextCursor.joinPreviousEditBlock": (),
-    "PySide2.QtGui.QTextCursor.keepPositionOnInsert": (),
-    "PySide2.QtGui.QTextCursor.mergeBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.mergeBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.mergeCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.movePosition": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode', 'int'),
-    "PySide2.QtGui.QTextCursor.position": (),
-    "PySide2.QtGui.QTextCursor.positionInBlock": (),
-    "PySide2.QtGui.QTextCursor.removeSelectedText": (),
-    "PySide2.QtGui.QTextCursor.select": ('PySide2.QtGui.QTextCursor.SelectionType',),
-    "PySide2.QtGui.QTextCursor.selectedTableCells": (),
-    "PySide2.QtGui.QTextCursor.selectedText": (),
-    "PySide2.QtGui.QTextCursor.selection": (),
-    "PySide2.QtGui.QTextCursor.selectionEnd": (),
-    "PySide2.QtGui.QTextCursor.selectionStart": (),
-    "PySide2.QtGui.QTextCursor.setBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.setCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setKeepPositionOnInsert": ('bool',),
-    "PySide2.QtGui.QTextCursor.setPosition": ('int', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtGui.QTextCursor.setVerticalMovementX": ('int',),
-    "PySide2.QtGui.QTextCursor.setVisualNavigation": ('bool',),
-    "PySide2.QtGui.QTextCursor.swap": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.verticalMovementX": (),
-    "PySide2.QtGui.QTextCursor.visualNavigation": (),
-# class PySide2.QtGui.QTextDocument:
-# class PySide2.QtGui.QTextDocument.FindFlag:
-# class PySide2.QtGui.QTextDocument.FindFlags:
-# class PySide2.QtGui.QTextDocument.MarkdownFeature:
-# class PySide2.QtGui.QTextDocument.MarkdownFeatures:
-# class PySide2.QtGui.QTextDocument.MetaInformation:
-# class PySide2.QtGui.QTextDocument.ResourceType:
-# class PySide2.QtGui.QTextDocument.Stacks:
-    "PySide2.QtGui.QTextDocument.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QTextDocument.addResource": ('int', 'PySide2.QtCore.QUrl', 'typing.Any'),
-    "PySide2.QtGui.QTextDocument.adjustSize": (),
-    "PySide2.QtGui.QTextDocument.allFormats": (),
-    "PySide2.QtGui.QTextDocument.availableRedoSteps": (),
-    "PySide2.QtGui.QTextDocument.availableUndoSteps": (),
-    "PySide2.QtGui.QTextDocument.baseUrl": (),
-    "PySide2.QtGui.QTextDocument.begin": (),
-    "PySide2.QtGui.QTextDocument.blockCount": (),
-    "PySide2.QtGui.QTextDocument.characterAt": ('int',),
-    "PySide2.QtGui.QTextDocument.characterCount": (),
-    "PySide2.QtGui.QTextDocument.clear": (),
-    "PySide2.QtGui.QTextDocument.clearUndoRedoStacks": ('PySide2.QtGui.QTextDocument.Stacks',),
-    "PySide2.QtGui.QTextDocument.clone": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTextDocument.createObject": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.defaultCursorMoveStyle": (),
-    "PySide2.QtGui.QTextDocument.defaultFont": (),
-    "PySide2.QtGui.QTextDocument.defaultStyleSheet": (),
-    "PySide2.QtGui.QTextDocument.defaultTextOption": (),
-    "PySide2.QtGui.QTextDocument.documentLayout": (),
-    "PySide2.QtGui.QTextDocument.documentMargin": (),
-    "PySide2.QtGui.QTextDocument.drawContents": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextDocument.end": (),
-    "PySide2.QtGui.QTextDocument.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegExp', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'int', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtGui.QTextDocument.findBlock": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByLineNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.firstBlock": (),
-    "PySide2.QtGui.QTextDocument.frameAt": ('int',),
-    "PySide2.QtGui.QTextDocument.idealWidth": (),
-    "PySide2.QtGui.QTextDocument.indentWidth": (),
-    "PySide2.QtGui.QTextDocument.isEmpty": (),
-    "PySide2.QtGui.QTextDocument.isModified": (),
-    "PySide2.QtGui.QTextDocument.isRedoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoRedoEnabled": (),
-    "PySide2.QtGui.QTextDocument.lastBlock": (),
-    "PySide2.QtGui.QTextDocument.lineCount": (),
-    "PySide2.QtGui.QTextDocument.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.markContentsDirty": ('int', 'int'),
-    "PySide2.QtGui.QTextDocument.maximumBlockCount": (),
-    "PySide2.QtGui.QTextDocument.metaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation',),
-    "PySide2.QtGui.QTextDocument.object": ('int',),
-    "PySide2.QtGui.QTextDocument.objectForFormat": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.pageCount": (),
-    "PySide2.QtGui.QTextDocument.pageSize": (),
-    "PySide2.QtGui.QTextDocument.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtGui.QTextDocument.redo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.resource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.revision": (),
-    "PySide2.QtGui.QTextDocument.rootFrame": (),
-    "PySide2.QtGui.QTextDocument.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QTextDocument.setDefaultCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextDocument.setDefaultFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextDocument.setDefaultStyleSheet": ('str',),
-    "PySide2.QtGui.QTextDocument.setDefaultTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextDocument.setDocumentLayout": ('PySide2.QtGui.QAbstractTextDocumentLayout',),
-    "PySide2.QtGui.QTextDocument.setDocumentMargin": ('float',),
-    "PySide2.QtGui.QTextDocument.setHtml": ('str',),
-    "PySide2.QtGui.QTextDocument.setIndentWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setMarkdown": ('str', 'PySide2.QtGui.QTextDocument.MarkdownFeatures'),
-    "PySide2.QtGui.QTextDocument.setMaximumBlockCount": ('int',),
-    "PySide2.QtGui.QTextDocument.setMetaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation', 'str'),
-    "PySide2.QtGui.QTextDocument.setModified": ('bool',),
-    "PySide2.QtGui.QTextDocument.setPageSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTextDocument.setPlainText": ('str',),
-    "PySide2.QtGui.QTextDocument.setTextWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtGui.QTextDocument.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextDocument.size": (),
-    "PySide2.QtGui.QTextDocument.textWidth": (),
-    "PySide2.QtGui.QTextDocument.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocument.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtGui.QTextDocument.toPlainText": (),
-    "PySide2.QtGui.QTextDocument.toRawText": (),
-    "PySide2.QtGui.QTextDocument.undo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.useDesignMetrics": (),
-# class PySide2.QtGui.QTextDocumentFragment:
-    "PySide2.QtGui.QTextDocumentFragment.__init__": [(), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-    "PySide2.QtGui.QTextDocumentFragment.__copy__": (),
-    "PySide2.QtGui.QTextDocumentFragment.fromHtml": [('str',), ('str', 'PySide2.QtGui.QTextDocument')],
-    "PySide2.QtGui.QTextDocumentFragment.fromPlainText": ('str',),
-    "PySide2.QtGui.QTextDocumentFragment.isEmpty": (),
-    "PySide2.QtGui.QTextDocumentFragment.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentFragment.toPlainText": (),
-# class PySide2.QtGui.QTextDocumentWriter:
-    "PySide2.QtGui.QTextDocumentWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QTextDocumentWriter.codec": (),
-    "PySide2.QtGui.QTextDocumentWriter.device": (),
-    "PySide2.QtGui.QTextDocumentWriter.fileName": (),
-    "PySide2.QtGui.QTextDocumentWriter.format": (),
-    "PySide2.QtGui.QTextDocumentWriter.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtGui.QTextDocumentWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QTextDocumentWriter.setFileName": ('str',),
-    "PySide2.QtGui.QTextDocumentWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentWriter.supportedDocumentFormats": (),
-    "PySide2.QtGui.QTextDocumentWriter.write": [('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-# class PySide2.QtGui.QTextFormat:
-# class PySide2.QtGui.QTextFormat.FormatType:
-# class PySide2.QtGui.QTextFormat.ObjectTypes:
-# class PySide2.QtGui.QTextFormat.PageBreakFlag:
-# class PySide2.QtGui.QTextFormat.PageBreakFlags:
-# class PySide2.QtGui.QTextFormat.Property:
-    "PySide2.QtGui.QTextFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('int',)],
-    "PySide2.QtGui.QTextFormat.__copy__": (),
-    "PySide2.QtGui.QTextFormat.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.background": (),
-    "PySide2.QtGui.QTextFormat.boolProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.brushProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.clearBackground": (),
-    "PySide2.QtGui.QTextFormat.clearForeground": (),
-    "PySide2.QtGui.QTextFormat.clearProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.colorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.doubleProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.foreground": (),
-    "PySide2.QtGui.QTextFormat.hasProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.intProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.isBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.isCharFormat": (),
-    "PySide2.QtGui.QTextFormat.isEmpty": (),
-    "PySide2.QtGui.QTextFormat.isFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.isImageFormat": (),
-    "PySide2.QtGui.QTextFormat.isListFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableFormat": (),
-    "PySide2.QtGui.QTextFormat.isValid": (),
-    "PySide2.QtGui.QTextFormat.layoutDirection": (),
-    "PySide2.QtGui.QTextFormat.lengthProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.lengthVectorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.merge": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.objectIndex": (),
-    "PySide2.QtGui.QTextFormat.objectType": (),
-    "PySide2.QtGui.QTextFormat.penProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.properties": (),
-    "PySide2.QtGui.QTextFormat.property": ('int',),
-    "PySide2.QtGui.QTextFormat.propertyCount": (),
-    "PySide2.QtGui.QTextFormat.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextFormat.setObjectIndex": ('int',),
-    "PySide2.QtGui.QTextFormat.setObjectType": ('int',),
-    "PySide2.QtGui.QTextFormat.setProperty": [('int', 'typing.Any'), ('int', 'typing.List')],
-    "PySide2.QtGui.QTextFormat.stringProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.swap": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.toBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.toCharFormat": (),
-    "PySide2.QtGui.QTextFormat.toFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.toImageFormat": (),
-    "PySide2.QtGui.QTextFormat.toListFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableFormat": (),
-    "PySide2.QtGui.QTextFormat.type": (),
-# class PySide2.QtGui.QTextFragment:
-    "PySide2.QtGui.QTextFragment.__init__": [(), ('PySide2.QtGui.QTextFragment',)],
-    "PySide2.QtGui.QTextFragment.__copy__": (),
-    "PySide2.QtGui.QTextFragment.charFormat": (),
-    "PySide2.QtGui.QTextFragment.charFormatIndex": (),
-    "PySide2.QtGui.QTextFragment.contains": ('int',),
-    "PySide2.QtGui.QTextFragment.isValid": (),
-    "PySide2.QtGui.QTextFragment.length": (),
-    "PySide2.QtGui.QTextFragment.position": (),
-    "PySide2.QtGui.QTextFragment.text": (),
-# class PySide2.QtGui.QTextFrame:
-# class PySide2.QtGui.QTextFrame.iterator:
-    "PySide2.QtGui.QTextFrame.iterator.__init__": [(), ('PySide2.QtGui.QTextFrame.iterator',)],
-    "PySide2.QtGui.QTextFrame.iterator.__copy__": (),
-    "PySide2.QtGui.QTextFrame.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__iter__": (),
-    "PySide2.QtGui.QTextFrame.iterator.atEnd": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentBlock": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentFrame": (),
-    "PySide2.QtGui.QTextFrame.iterator.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextFrame.__iter__": (),
-    "PySide2.QtGui.QTextFrame.begin": (),
-    "PySide2.QtGui.QTextFrame.childFrames": (),
-    "PySide2.QtGui.QTextFrame.end": (),
-    "PySide2.QtGui.QTextFrame.firstCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.firstPosition": (),
-    "PySide2.QtGui.QTextFrame.frameFormat": (),
-    "PySide2.QtGui.QTextFrame.lastCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.lastPosition": (),
-    "PySide2.QtGui.QTextFrame.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.setFrameFormat": ('PySide2.QtGui.QTextFrameFormat',),
-# class PySide2.QtGui.QTextFrameFormat:
-# class PySide2.QtGui.QTextFrameFormat.BorderStyle:
-# class PySide2.QtGui.QTextFrameFormat.Position:
-    "PySide2.QtGui.QTextFrameFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextFrameFormat',)],
-    "PySide2.QtGui.QTextFrameFormat.__copy__": (),
-    "PySide2.QtGui.QTextFrameFormat.border": (),
-    "PySide2.QtGui.QTextFrameFormat.borderBrush": (),
-    "PySide2.QtGui.QTextFrameFormat.borderStyle": (),
-    "PySide2.QtGui.QTextFrameFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.height": (),
-    "PySide2.QtGui.QTextFrameFormat.isValid": (),
-    "PySide2.QtGui.QTextFrameFormat.leftMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.margin": (),
-    "PySide2.QtGui.QTextFrameFormat.padding": (),
-    "PySide2.QtGui.QTextFrameFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextFrameFormat.position": (),
-    "PySide2.QtGui.QTextFrameFormat.rightMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextFrameFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setHeight": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextFrameFormat.setPosition": ('PySide2.QtGui.QTextFrameFormat.Position',),
-    "PySide2.QtGui.QTextFrameFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setWidth": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.topMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.width": (),
-# class PySide2.QtGui.QTextImageFormat:
-    "PySide2.QtGui.QTextImageFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextImageFormat',)],
-    "PySide2.QtGui.QTextImageFormat.__copy__": (),
-    "PySide2.QtGui.QTextImageFormat.height": (),
-    "PySide2.QtGui.QTextImageFormat.isValid": (),
-    "PySide2.QtGui.QTextImageFormat.name": (),
-    "PySide2.QtGui.QTextImageFormat.quality": (),
-    "PySide2.QtGui.QTextImageFormat.setHeight": ('float',),
-    "PySide2.QtGui.QTextImageFormat.setName": ('str',),
-    "PySide2.QtGui.QTextImageFormat.setQuality": ('int',),
-    "PySide2.QtGui.QTextImageFormat.setWidth": ('float',),
-    "PySide2.QtGui.QTextImageFormat.width": (),
-# class PySide2.QtGui.QTextInlineObject:
-    "PySide2.QtGui.QTextInlineObject.__init__": (),
-    "PySide2.QtGui.QTextInlineObject.__copy__": (),
-    "PySide2.QtGui.QTextInlineObject.ascent": (),
-    "PySide2.QtGui.QTextInlineObject.descent": (),
-    "PySide2.QtGui.QTextInlineObject.format": (),
-    "PySide2.QtGui.QTextInlineObject.formatIndex": (),
-    "PySide2.QtGui.QTextInlineObject.height": (),
-    "PySide2.QtGui.QTextInlineObject.isValid": (),
-    "PySide2.QtGui.QTextInlineObject.rect": (),
-    "PySide2.QtGui.QTextInlineObject.setAscent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setDescent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setWidth": ('float',),
-    "PySide2.QtGui.QTextInlineObject.textDirection": (),
-    "PySide2.QtGui.QTextInlineObject.textPosition": (),
-    "PySide2.QtGui.QTextInlineObject.width": (),
-# class PySide2.QtGui.QTextItem:
-# class PySide2.QtGui.QTextItem.RenderFlag:
-# class PySide2.QtGui.QTextItem.RenderFlags:
-    "PySide2.QtGui.QTextItem.__init__": (),
-    "PySide2.QtGui.QTextItem.ascent": (),
-    "PySide2.QtGui.QTextItem.descent": (),
-    "PySide2.QtGui.QTextItem.font": (),
-    "PySide2.QtGui.QTextItem.renderFlags": (),
-    "PySide2.QtGui.QTextItem.text": (),
-    "PySide2.QtGui.QTextItem.width": (),
-# class PySide2.QtGui.QTextLayout:
-# class PySide2.QtGui.QTextLayout.CursorMode:
-# class PySide2.QtGui.QTextLayout.FormatRange:
-    "PySide2.QtGui.QTextLayout.FormatRange.__init__": [(), ('PySide2.QtGui.QTextLayout.FormatRange',)],
-    "PySide2.QtGui.QTextLayout.FormatRange.__copy__": (),
-    "PySide2.QtGui.QTextLayout.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('str',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice')],
-    "PySide2.QtGui.QTextLayout.additionalFormats": (),
-    "PySide2.QtGui.QTextLayout.beginLayout": (),
-    "PySide2.QtGui.QTextLayout.boundingRect": (),
-    "PySide2.QtGui.QTextLayout.cacheEnabled": (),
-    "PySide2.QtGui.QTextLayout.clearAdditionalFormats": (),
-    "PySide2.QtGui.QTextLayout.clearFormats": (),
-    "PySide2.QtGui.QTextLayout.clearLayout": (),
-    "PySide2.QtGui.QTextLayout.createLine": (),
-    "PySide2.QtGui.QTextLayout.cursorMoveStyle": (),
-    "PySide2.QtGui.QTextLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'typing.List', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextLayout.drawCursor": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int', 'int')],
-    "PySide2.QtGui.QTextLayout.endLayout": (),
-    "PySide2.QtGui.QTextLayout.font": (),
-    "PySide2.QtGui.QTextLayout.formats": (),
-    "PySide2.QtGui.QTextLayout.isValidCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.leftCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.lineAt": ('int',),
-    "PySide2.QtGui.QTextLayout.lineCount": (),
-    "PySide2.QtGui.QTextLayout.lineForTextPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.maximumWidth": (),
-    "PySide2.QtGui.QTextLayout.minimumWidth": (),
-    "PySide2.QtGui.QTextLayout.nextCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.position": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaPosition": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaText": (),
-    "PySide2.QtGui.QTextLayout.previousCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.rightCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.setAdditionalFormats": ('typing.Sequence',),
-    "PySide2.QtGui.QTextLayout.setCacheEnabled": ('bool',),
-    "PySide2.QtGui.QTextLayout.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextLayout.setFlags": ('int',),
-    "PySide2.QtGui.QTextLayout.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextLayout.setFormats": ('typing.List',),
-    "PySide2.QtGui.QTextLayout.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLayout.setPreeditArea": ('int', 'str'),
-    "PySide2.QtGui.QTextLayout.setRawFont": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QTextLayout.setText": ('str',),
-    "PySide2.QtGui.QTextLayout.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextLayout.text": (),
-    "PySide2.QtGui.QTextLayout.textOption": (),
-# class PySide2.QtGui.QTextLength:
-# class PySide2.QtGui.QTextLength.Type:
-    "PySide2.QtGui.QTextLength.__init__": [(), ('PySide2.QtGui.QTextLength',), ('PySide2.QtGui.QTextLength.Type', 'float')],
-    "PySide2.QtGui.QTextLength.__copy__": (),
-    "PySide2.QtGui.QTextLength.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.rawValue": (),
-    "PySide2.QtGui.QTextLength.type": (),
-    "PySide2.QtGui.QTextLength.value": ('float',),
-# class PySide2.QtGui.QTextLine:
-# class PySide2.QtGui.QTextLine.CursorPosition:
-# class PySide2.QtGui.QTextLine.Edge:
-    "PySide2.QtGui.QTextLine.__init__": (),
-    "PySide2.QtGui.QTextLine.__copy__": (),
-    "PySide2.QtGui.QTextLine.ascent": (),
-    "PySide2.QtGui.QTextLine.cursorToX": ('int', 'PySide2.QtGui.QTextLine.Edge'),
-    "PySide2.QtGui.QTextLine.descent": (),
-    "PySide2.QtGui.QTextLine.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextLayout.FormatRange'),
-    "PySide2.QtGui.QTextLine.height": (),
-    "PySide2.QtGui.QTextLine.horizontalAdvance": (),
-    "PySide2.QtGui.QTextLine.isValid": (),
-    "PySide2.QtGui.QTextLine.leading": (),
-    "PySide2.QtGui.QTextLine.leadingIncluded": (),
-    "PySide2.QtGui.QTextLine.lineNumber": (),
-    "PySide2.QtGui.QTextLine.naturalTextRect": (),
-    "PySide2.QtGui.QTextLine.naturalTextWidth": (),
-    "PySide2.QtGui.QTextLine.position": (),
-    "PySide2.QtGui.QTextLine.rect": (),
-    "PySide2.QtGui.QTextLine.setLeadingIncluded": ('bool',),
-    "PySide2.QtGui.QTextLine.setLineWidth": ('float',),
-    "PySide2.QtGui.QTextLine.setNumColumns": [('int',), ('int', 'float')],
-    "PySide2.QtGui.QTextLine.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLine.textLength": (),
-    "PySide2.QtGui.QTextLine.textStart": (),
-    "PySide2.QtGui.QTextLine.width": (),
-    "PySide2.QtGui.QTextLine.x": (),
-    "PySide2.QtGui.QTextLine.xToCursor": ('float', 'PySide2.QtGui.QTextLine.CursorPosition'),
-    "PySide2.QtGui.QTextLine.y": (),
-# class PySide2.QtGui.QTextList:
-    "PySide2.QtGui.QTextList.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextList.add": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.count": (),
-    "PySide2.QtGui.QTextList.format": (),
-    "PySide2.QtGui.QTextList.item": ('int',),
-    "PySide2.QtGui.QTextList.itemNumber": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.itemText": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.remove": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.removeItem": ('int',),
-    "PySide2.QtGui.QTextList.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-# class PySide2.QtGui.QTextListFormat:
-# class PySide2.QtGui.QTextListFormat.Style:
-    "PySide2.QtGui.QTextListFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-    "PySide2.QtGui.QTextListFormat.__copy__": (),
-    "PySide2.QtGui.QTextListFormat.indent": (),
-    "PySide2.QtGui.QTextListFormat.isValid": (),
-    "PySide2.QtGui.QTextListFormat.numberPrefix": (),
-    "PySide2.QtGui.QTextListFormat.numberSuffix": (),
-    "PySide2.QtGui.QTextListFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextListFormat.setNumberPrefix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setNumberSuffix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setStyle": ('PySide2.QtGui.QTextListFormat.Style',),
-    "PySide2.QtGui.QTextListFormat.style": (),
-# class PySide2.QtGui.QTextObject:
-    "PySide2.QtGui.QTextObject.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextObject.document": (),
-    "PySide2.QtGui.QTextObject.format": (),
-    "PySide2.QtGui.QTextObject.formatIndex": (),
-    "PySide2.QtGui.QTextObject.objectIndex": (),
-    "PySide2.QtGui.QTextObject.setFormat": ('PySide2.QtGui.QTextFormat',),
-# class PySide2.QtGui.QTextObjectInterface:
-    "PySide2.QtGui.QTextObjectInterface.__init__": (),
-    "PySide2.QtGui.QTextObjectInterface.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QTextObjectInterface.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QTextOption:
-# class PySide2.QtGui.QTextOption.Flag:
-# class PySide2.QtGui.QTextOption.Flags:
-# class PySide2.QtGui.QTextOption.Tab:
-    "PySide2.QtGui.QTextOption.Tab.__init__": [(), ('PySide2.QtGui.QTextOption.Tab',), ('float', 'PySide2.QtGui.QTextOption.TabType', 'str')],
-    "PySide2.QtGui.QTextOption.Tab.__copy__": (),
-# class PySide2.QtGui.QTextOption.TabType:
-# class PySide2.QtGui.QTextOption.WrapMode:
-    "PySide2.QtGui.QTextOption.__init__": [(), ('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtGui.QTextOption',)],
-    "PySide2.QtGui.QTextOption.__copy__": (),
-    "PySide2.QtGui.QTextOption.alignment": (),
-    "PySide2.QtGui.QTextOption.flags": (),
-    "PySide2.QtGui.QTextOption.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextOption.setFlags": ('PySide2.QtGui.QTextOption.Flags',),
-    "PySide2.QtGui.QTextOption.setTabArray": ('typing.Sequence',),
-    "PySide2.QtGui.QTextOption.setTabStop": ('float',),
-    "PySide2.QtGui.QTextOption.setTabStopDistance": ('float',),
-    "PySide2.QtGui.QTextOption.setTabs": ('typing.Sequence',),
-    "PySide2.QtGui.QTextOption.setTextDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextOption.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextOption.setWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtGui.QTextOption.tabArray": (),
-    "PySide2.QtGui.QTextOption.tabStop": (),
-    "PySide2.QtGui.QTextOption.tabStopDistance": (),
-    "PySide2.QtGui.QTextOption.tabs": (),
-    "PySide2.QtGui.QTextOption.textDirection": (),
-    "PySide2.QtGui.QTextOption.useDesignMetrics": (),
-    "PySide2.QtGui.QTextOption.wrapMode": (),
-# class PySide2.QtGui.QTextTable:
-    "PySide2.QtGui.QTextTable.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextTable.appendColumns": ('int',),
-    "PySide2.QtGui.QTextTable.appendRows": ('int',),
-    "PySide2.QtGui.QTextTable.cellAt": [('PySide2.QtGui.QTextCursor',), ('int',), ('int', 'int')],
-    "PySide2.QtGui.QTextTable.columns": (),
-    "PySide2.QtGui.QTextTable.format": (),
-    "PySide2.QtGui.QTextTable.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.insertRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.mergeCells": [('PySide2.QtGui.QTextCursor',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QTextTable.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.resize": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.rowEnd": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rowStart": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rows": (),
-    "PySide2.QtGui.QTextTable.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTable.splitCell": ('int', 'int', 'int', 'int'),
-# class PySide2.QtGui.QTextTableCell:
-    "PySide2.QtGui.QTextTableCell.__init__": [(), ('PySide2.QtGui.QTextTableCell',)],
-    "PySide2.QtGui.QTextTableCell.__copy__": (),
-    "PySide2.QtGui.QTextTableCell.begin": (),
-    "PySide2.QtGui.QTextTableCell.column": (),
-    "PySide2.QtGui.QTextTableCell.columnSpan": (),
-    "PySide2.QtGui.QTextTableCell.end": (),
-    "PySide2.QtGui.QTextTableCell.firstCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.firstPosition": (),
-    "PySide2.QtGui.QTextTableCell.format": (),
-    "PySide2.QtGui.QTextTableCell.isValid": (),
-    "PySide2.QtGui.QTextTableCell.lastCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.lastPosition": (),
-    "PySide2.QtGui.QTextTableCell.row": (),
-    "PySide2.QtGui.QTextTableCell.rowSpan": (),
-    "PySide2.QtGui.QTextTableCell.setFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextTableCell.tableCellFormatIndex": (),
-# class PySide2.QtGui.QTextTableCellFormat:
-    "PySide2.QtGui.QTextTableCellFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableCellFormat',)],
-    "PySide2.QtGui.QTextTableCellFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.isValid": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.topBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.topPadding": (),
-# class PySide2.QtGui.QTextTableFormat:
-    "PySide2.QtGui.QTextTableFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTableFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableFormat.alignment": (),
-    "PySide2.QtGui.QTextTableFormat.borderCollapse": (),
-    "PySide2.QtGui.QTextTableFormat.cellPadding": (),
-    "PySide2.QtGui.QTextTableFormat.cellSpacing": (),
-    "PySide2.QtGui.QTextTableFormat.clearColumnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columns": (),
-    "PySide2.QtGui.QTextTableFormat.headerRowCount": (),
-    "PySide2.QtGui.QTextTableFormat.isValid": (),
-    "PySide2.QtGui.QTextTableFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextTableFormat.setBorderCollapse": ('bool',),
-    "PySide2.QtGui.QTextTableFormat.setCellPadding": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setCellSpacing": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setColumnWidthConstraints": ('typing.List',),
-    "PySide2.QtGui.QTextTableFormat.setColumns": ('int',),
-    "PySide2.QtGui.QTextTableFormat.setHeaderRowCount": ('int',),
-# class PySide2.QtGui.QToolBarChangeEvent:
-    "PySide2.QtGui.QToolBarChangeEvent.__init__": ('bool',),
-    "PySide2.QtGui.QToolBarChangeEvent.toggle": (),
-# class PySide2.QtGui.QTouchDevice:
-# class PySide2.QtGui.QTouchDevice.Capabilities:
-# class PySide2.QtGui.QTouchDevice.CapabilityFlag:
-# class PySide2.QtGui.QTouchDevice.DeviceType:
-    "PySide2.QtGui.QTouchDevice.__init__": (),
-    "PySide2.QtGui.QTouchDevice.capabilities": (),
-    "PySide2.QtGui.QTouchDevice.devices": (),
-    "PySide2.QtGui.QTouchDevice.maximumTouchPoints": (),
-    "PySide2.QtGui.QTouchDevice.name": (),
-    "PySide2.QtGui.QTouchDevice.setCapabilities": ('PySide2.QtGui.QTouchDevice.Capabilities',),
-    "PySide2.QtGui.QTouchDevice.setMaximumTouchPoints": ('int',),
-    "PySide2.QtGui.QTouchDevice.setName": ('str',),
-    "PySide2.QtGui.QTouchDevice.setType": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtGui.QTouchDevice.type": (),
-# class PySide2.QtGui.QTouchEvent:
-# class PySide2.QtGui.QTouchEvent.TouchPoint:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlag:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags:
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__init__": [('PySide2.QtGui.QTouchEvent.TouchPoint',), ('int',)],
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__copy__": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.ellipseDiameters": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.flags": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.id": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.normalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pressure": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rawScreenPositions": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rotation": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.scenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.sceneRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setEllipseDiameters": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setFlags": ('PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPressure": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRawScreenPositions": ('typing.List',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRotation": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setState": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setUniqueId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setVelocity": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.state": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.swap": ('PySide2.QtGui.QTouchEvent.TouchPoint',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.uniqueId": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.velocity": (),
-    "PySide2.QtGui.QTouchEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.TouchPointStates', 'typing.Sequence'),
-    "PySide2.QtGui.QTouchEvent.device": (),
-    "PySide2.QtGui.QTouchEvent.setDevice": ('PySide2.QtGui.QTouchDevice',),
-    "PySide2.QtGui.QTouchEvent.setTarget": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTouchEvent.setTouchPointStates": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.setTouchPoints": ('typing.Sequence',),
-    "PySide2.QtGui.QTouchEvent.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QTouchEvent.target": (),
-    "PySide2.QtGui.QTouchEvent.touchPointStates": (),
-    "PySide2.QtGui.QTouchEvent.touchPoints": (),
-    "PySide2.QtGui.QTouchEvent.window": (),
-# class PySide2.QtGui.QTransform:
-# class PySide2.QtGui.QTransform.TransformationType:
-    "PySide2.QtGui.QTransform.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QTransform.__add__": ('float',),
-    "PySide2.QtGui.QTransform.__copy__": (),
-    "PySide2.QtGui.QTransform.__iadd__": ('float',),
-    "PySide2.QtGui.QTransform.__imul__": [('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__isub__": ('float',),
-    "PySide2.QtGui.QTransform.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__reduce__": (),
-    "PySide2.QtGui.QTransform.__repr__": (),
-    "PySide2.QtGui.QTransform.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__sub__": ('float',),
-    "PySide2.QtGui.QTransform.adjoint": (),
-    "PySide2.QtGui.QTransform.det": (),
-    "PySide2.QtGui.QTransform.determinant": (),
-    "PySide2.QtGui.QTransform.dx": (),
-    "PySide2.QtGui.QTransform.dy": (),
-    "PySide2.QtGui.QTransform.fromScale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.fromTranslate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.inverted": (),
-    "PySide2.QtGui.QTransform.isAffine": (),
-    "PySide2.QtGui.QTransform.isIdentity": (),
-    "PySide2.QtGui.QTransform.isInvertible": (),
-    "PySide2.QtGui.QTransform.isRotating": (),
-    "PySide2.QtGui.QTransform.isScaling": (),
-    "PySide2.QtGui.QTransform.isTranslating": (),
-    "PySide2.QtGui.QTransform.m11": (),
-    "PySide2.QtGui.QTransform.m12": (),
-    "PySide2.QtGui.QTransform.m13": (),
-    "PySide2.QtGui.QTransform.m21": (),
-    "PySide2.QtGui.QTransform.m22": (),
-    "PySide2.QtGui.QTransform.m23": (),
-    "PySide2.QtGui.QTransform.m31": (),
-    "PySide2.QtGui.QTransform.m32": (),
-    "PySide2.QtGui.QTransform.m33": (),
-    "PySide2.QtGui.QTransform.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float')],
-    "PySide2.QtGui.QTransform.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QTransform.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QTransform.quadToQuad": [('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.quadToSquare": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.reset": (),
-    "PySide2.QtGui.QTransform.rotate": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.rotateRadians": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.scale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QTransform.shear": ('float', 'float'),
-    "PySide2.QtGui.QTransform.squareToQuad": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.toAffine": (),
-    "PySide2.QtGui.QTransform.translate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.transposed": (),
-    "PySide2.QtGui.QTransform.type": (),
-# class PySide2.QtGui.QValidator:
-# class PySide2.QtGui.QValidator.State:
-    "PySide2.QtGui.QValidator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QValidator.fixup": ('str',),
-    "PySide2.QtGui.QValidator.locale": (),
-    "PySide2.QtGui.QValidator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtGui.QValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QVector2D:
-    "PySide2.QtGui.QVector2D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',), ('float', 'float')],
-    "PySide2.QtGui.QVector2D.__add__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__copy__": (),
-    "PySide2.QtGui.QVector2D.__iadd__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__imul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__isub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__mul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__neg__": (),
-    "PySide2.QtGui.QVector2D.__reduce__": (),
-    "PySide2.QtGui.QVector2D.__repr__": (),
-    "PySide2.QtGui.QVector2D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__sub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.distanceToLine": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.distanceToPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.dotProduct": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.isNull": (),
-    "PySide2.QtGui.QVector2D.length": (),
-    "PySide2.QtGui.QVector2D.lengthSquared": (),
-    "PySide2.QtGui.QVector2D.normalize": (),
-    "PySide2.QtGui.QVector2D.normalized": (),
-    "PySide2.QtGui.QVector2D.setX": ('float',),
-    "PySide2.QtGui.QVector2D.setY": ('float',),
-    "PySide2.QtGui.QVector2D.toPoint": (),
-    "PySide2.QtGui.QVector2D.toPointF": (),
-    "PySide2.QtGui.QVector2D.toTuple": (),
-    "PySide2.QtGui.QVector2D.toVector3D": (),
-    "PySide2.QtGui.QVector2D.toVector4D": (),
-    "PySide2.QtGui.QVector2D.x": (),
-    "PySide2.QtGui.QVector2D.y": (),
-# class PySide2.QtGui.QVector3D:
-    "PySide2.QtGui.QVector3D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float'), ('PySide2.QtGui.QVector4D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QVector3D.__add__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__copy__": (),
-    "PySide2.QtGui.QVector3D.__iadd__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__imul__": [('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__isub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QQuaternion',), ('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__neg__": (),
-    "PySide2.QtGui.QVector3D.__reduce__": (),
-    "PySide2.QtGui.QVector3D.__repr__": (),
-    "PySide2.QtGui.QVector3D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__sub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.crossProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToLine": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToPlane": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.distanceToPoint": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.dotProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.isNull": (),
-    "PySide2.QtGui.QVector3D.length": (),
-    "PySide2.QtGui.QVector3D.lengthSquared": (),
-    "PySide2.QtGui.QVector3D.normal": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.normalize": (),
-    "PySide2.QtGui.QVector3D.normalized": (),
-    "PySide2.QtGui.QVector3D.project": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.setX": ('float',),
-    "PySide2.QtGui.QVector3D.setY": ('float',),
-    "PySide2.QtGui.QVector3D.setZ": ('float',),
-    "PySide2.QtGui.QVector3D.toPoint": (),
-    "PySide2.QtGui.QVector3D.toPointF": (),
-    "PySide2.QtGui.QVector3D.toTuple": (),
-    "PySide2.QtGui.QVector3D.toVector2D": (),
-    "PySide2.QtGui.QVector3D.toVector4D": (),
-    "PySide2.QtGui.QVector3D.unproject": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.x": (),
-    "PySide2.QtGui.QVector3D.y": (),
-    "PySide2.QtGui.QVector3D.z": (),
-# class PySide2.QtGui.QVector4D:
-    "PySide2.QtGui.QVector4D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float', 'float'), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QVector4D.__add__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__copy__": (),
-    "PySide2.QtGui.QVector4D.__iadd__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__imul__": [('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__isub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__neg__": (),
-    "PySide2.QtGui.QVector4D.__reduce__": (),
-    "PySide2.QtGui.QVector4D.__repr__": (),
-    "PySide2.QtGui.QVector4D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__sub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.dotProduct": ('PySide2.QtGui.QVector4D', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QVector4D.isNull": (),
-    "PySide2.QtGui.QVector4D.length": (),
-    "PySide2.QtGui.QVector4D.lengthSquared": (),
-    "PySide2.QtGui.QVector4D.normalize": (),
-    "PySide2.QtGui.QVector4D.normalized": (),
-    "PySide2.QtGui.QVector4D.setW": ('float',),
-    "PySide2.QtGui.QVector4D.setX": ('float',),
-    "PySide2.QtGui.QVector4D.setY": ('float',),
-    "PySide2.QtGui.QVector4D.setZ": ('float',),
-    "PySide2.QtGui.QVector4D.toPoint": (),
-    "PySide2.QtGui.QVector4D.toPointF": (),
-    "PySide2.QtGui.QVector4D.toTuple": (),
-    "PySide2.QtGui.QVector4D.toVector2D": (),
-    "PySide2.QtGui.QVector4D.toVector2DAffine": (),
-    "PySide2.QtGui.QVector4D.toVector3D": (),
-    "PySide2.QtGui.QVector4D.toVector3DAffine": (),
-    "PySide2.QtGui.QVector4D.w": (),
-    "PySide2.QtGui.QVector4D.x": (),
-    "PySide2.QtGui.QVector4D.y": (),
-    "PySide2.QtGui.QVector4D.z": (),
-# class PySide2.QtGui.QWhatsThisClickedEvent:
-    "PySide2.QtGui.QWhatsThisClickedEvent.__init__": ('str',),
-    "PySide2.QtGui.QWhatsThisClickedEvent.href": (),
-# class PySide2.QtGui.QWheelEvent:
-    "PySide2.QtGui.QWheelEvent.__init__": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'bool', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource', 'bool'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtGui.QWheelEvent.angleDelta": (),
-    "PySide2.QtGui.QWheelEvent.buttons": (),
-    "PySide2.QtGui.QWheelEvent.delta": (),
-    "PySide2.QtGui.QWheelEvent.globalPos": (),
-    "PySide2.QtGui.QWheelEvent.globalPosF": (),
-    "PySide2.QtGui.QWheelEvent.globalPosition": (),
-    "PySide2.QtGui.QWheelEvent.globalX": (),
-    "PySide2.QtGui.QWheelEvent.global""Y": (),
-    "PySide2.QtGui.QWheelEvent.inverted": (),
-    "PySide2.QtGui.QWheelEvent.orientation": (),
-    "PySide2.QtGui.QWheelEvent.phase": (),
-    "PySide2.QtGui.QWheelEvent.pixelDelta": (),
-    "PySide2.QtGui.QWheelEvent.pos": (),
-    "PySide2.QtGui.QWheelEvent.posF": (),
-    "PySide2.QtGui.QWheelEvent.position": (),
-    "PySide2.QtGui.QWheelEvent.source": (),
-    "PySide2.QtGui.QWheelEvent.x": (),
-    "PySide2.QtGui.QWheelEvent.y": (),
-# class PySide2.QtGui.QWindow:
-# class PySide2.QtGui.QWindow.AncestorMode:
-# class PySide2.QtGui.QWindow.Visibility:
-    "PySide2.QtGui.QWindow.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QWindow',)],
-    "PySide2.QtGui.QWindow.accessibleRoot": (),
-    "PySide2.QtGui.QWindow.alert": ('int',),
-    "PySide2.QtGui.QWindow.baseSize": (),
-    "PySide2.QtGui.QWindow.close": (),
-    "PySide2.QtGui.QWindow.contentOrientation": (),
-    "PySide2.QtGui.QWindow.create": (),
-    "PySide2.QtGui.QWindow.cursor": (),
-    "PySide2.QtGui.QWindow.destroy": (),
-    "PySide2.QtGui.QWindow.devicePixelRatio": (),
-    "PySide2.QtGui.QWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QWindow.filePath": (),
-    "PySide2.QtGui.QWindow.flags": (),
-    "PySide2.QtGui.QWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.focusObject": (),
-    "PySide2.QtGui.QWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.format": (),
-    "PySide2.QtGui.QWindow.frameGeometry": (),
-    "PySide2.QtGui.QWindow.frameMargins": (),
-    "PySide2.QtGui.QWindow.framePosition": (),
-    "PySide2.QtGui.QWindow.fromWinId": ('int',),
-    "PySide2.QtGui.QWindow.geometry": (),
-    "PySide2.QtGui.QWindow.height": (),
-    "PySide2.QtGui.QWindow.hide": (),
-    "PySide2.QtGui.QWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtGui.QWindow.icon": (),
-    "PySide2.QtGui.QWindow.isActive": (),
-    "PySide2.QtGui.QWindow.isAncestorOf": ('PySide2.QtGui.QWindow', 'PySide2.QtGui.QWindow.AncestorMode'),
-    "PySide2.QtGui.QWindow.isExposed": (),
-    "PySide2.QtGui.QWindow.isModal": (),
-    "PySide2.QtGui.QWindow.isTopLevel": (),
-    "PySide2.QtGui.QWindow.isVisible": (),
-    "PySide2.QtGui.QWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.lower": (),
-    "PySide2.QtGui.QWindow.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mask": (),
-    "PySide2.QtGui.QWindow.maximumHeight": (),
-    "PySide2.QtGui.QWindow.maximumSize": (),
-    "PySide2.QtGui.QWindow.maximumWidth": (),
-    "PySide2.QtGui.QWindow.minimumHeight": (),
-    "PySide2.QtGui.QWindow.minimumSize": (),
-    "PySide2.QtGui.QWindow.minimumWidth": (),
-    "PySide2.QtGui.QWindow.modality": (),
-    "PySide2.QtGui.QWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtGui.QWindow.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtGui.QWindow.opacity": (),
-    "PySide2.QtGui.QWindow.parent": [(), ('PySide2.QtGui.QWindow.AncestorMode',)],
-    "PySide2.QtGui.QWindow.position": (),
-    "PySide2.QtGui.QWindow.raise_": (),
-    "PySide2.QtGui.QWindow.reportContentOrientationChange": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QWindow.requestActivate": (),
-    "PySide2.QtGui.QWindow.requestUpdate": (),
-    "PySide2.QtGui.QWindow.requestedFormat": (),
-    "PySide2.QtGui.QWindow.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QWindow.screen": (),
-    "PySide2.QtGui.QWindow.setBaseSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QWindow.setFilePath": ('str',),
-    "PySide2.QtGui.QWindow.setFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtGui.QWindow.setFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtGui.QWindow.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QWindow.setFramePosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QWindow.setHeight": ('int',),
-    "PySide2.QtGui.QWindow.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QWindow.setKeyboardGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setMask": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QWindow.setMaximumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMaximumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMaximumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMinimumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtGui.QWindow.setMouseGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setOpacity": ('float',),
-    "PySide2.QtGui.QWindow.setParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setPosition": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QWindow.setSizeIncrement": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setSurfaceType": ('PySide2.QtGui.QSurface.SurfaceType',),
-    "PySide2.QtGui.QWindow.setTitle": ('str',),
-    "PySide2.QtGui.QWindow.setTransientParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setVisibility": ('PySide2.QtGui.QWindow.Visibility',),
-    "PySide2.QtGui.QWindow.setVisible": ('bool',),
-    "PySide2.QtGui.QWindow.setWidth": ('int',),
-    "PySide2.QtGui.QWindow.setWindowState": ('PySide2.QtCore.Qt.WindowState',),
-    "PySide2.QtGui.QWindow.setWindowStates": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtGui.QWindow.setX": ('int',),
-    "PySide2.QtGui.QWindow.setY": ('int',),
-    "PySide2.QtGui.QWindow.show": (),
-    "PySide2.QtGui.QWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtGui.QWindow.showFullScreen": (),
-    "PySide2.QtGui.QWindow.showMaximized": (),
-    "PySide2.QtGui.QWindow.showMinimized": (),
-    "PySide2.QtGui.QWindow.showNormal": (),
-    "PySide2.QtGui.QWindow.size": (),
-    "PySide2.QtGui.QWindow.sizeIncrement": (),
-    "PySide2.QtGui.QWindow.surfaceHandle": (),
-    "PySide2.QtGui.QWindow.surfaceType": (),
-    "PySide2.QtGui.QWindow.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtGui.QWindow.title": (),
-    "PySide2.QtGui.QWindow.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtGui.QWindow.transientParent": (),
-    "PySide2.QtGui.QWindow.type": (),
-    "PySide2.QtGui.QWindow.unsetCursor": (),
-    "PySide2.QtGui.QWindow.visibility": (),
-    "PySide2.QtGui.QWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtGui.QWindow.width": (),
-    "PySide2.QtGui.QWindow.winId": (),
-    "PySide2.QtGui.QWindow.windowState": (),
-    "PySide2.QtGui.QWindow.windowStates": (),
-    "PySide2.QtGui.QWindow.x": (),
-    "PySide2.QtGui.QWindow.y": (),
-# class PySide2.QtGui.QWindowStateChangeEvent:
-    "PySide2.QtGui.QWindowStateChangeEvent.__init__": ('PySide2.QtCore.Qt.WindowStates', 'bool'),
-    "PySide2.QtGui.QWindowStateChangeEvent.isOverride": (),
-    "PySide2.QtGui.QWindowStateChangeEvent.oldState": (),
-# class PySide2.QtGui.Qt:
-    "PySide2.QtGui.Qt.codecForHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.Qt.convertFromPlainText": ('str', 'PySide2.QtCore.Qt.WhiteSpaceMode'),
-    "PySide2.QtGui.Qt.mightBeRichText": ('str',),
-    "PySide2.QtGui.Qt.qAlpha": ('int',),
-    "PySide2.QtGui.Qt.qBlue": ('int',),
-    "PySide2.QtGui.Qt.qGray": [('int',), ('int', 'int', 'int')],
-    "PySide2.QtGui.Qt.qGreen": ('int',),
-    "PySide2.QtGui.Qt.qIsGray": ('int',),
-    "PySide2.QtGui.Qt.qRed": ('int',),
-    "PySide2.QtGui.Qt.qRgb": ('int', 'int', 'int'),
-    "PySide2.QtGui.Qt.qRgba": ('int', 'int', 'int', 'int'),
-    }) if "PySide2.QtGui" in sys.modules else None
-# Module PySide2.QtWidgets
-sig_dict.update({
-# class PySide2.QtWidgets.QAbstractButton:
-    "PySide2.QtWidgets.QAbstractButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractButton.animateClick": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.autoExclusive": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeat": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatDelay": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatInterval": (),
-    "PySide2.QtWidgets.QAbstractButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.checkStateSet": (),
-    "PySide2.QtWidgets.QAbstractButton.click": (),
-    "PySide2.QtWidgets.QAbstractButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.group": (),
-    "PySide2.QtWidgets.QAbstractButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractButton.icon": (),
-    "PySide2.QtWidgets.QAbstractButton.iconSize": (),
-    "PySide2.QtWidgets.QAbstractButton.isCheckable": (),
-    "PySide2.QtWidgets.QAbstractButton.isChecked": (),
-    "PySide2.QtWidgets.QAbstractButton.isDown": (),
-    "PySide2.QtWidgets.QAbstractButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.nextCheckState": (),
-    "PySide2.QtWidgets.QAbstractButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoExclusive": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatDelay": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatInterval": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAbstractButton.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractButton.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAbstractButton.setText": ('str',),
-    "PySide2.QtWidgets.QAbstractButton.shortcut": (),
-    "PySide2.QtWidgets.QAbstractButton.text": (),
-    "PySide2.QtWidgets.QAbstractButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractButton.toggle": (),
-# class PySide2.QtWidgets.QAbstractGraphicsShapeItem:
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.brush": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.opaqueArea": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.pen": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setPen": ('PySide2.QtGui.QPen',),
-# class PySide2.QtWidgets.QAbstractItemDelegate:
-# class PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint:
-    "PySide2.QtWidgets.QAbstractItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.destroyEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.elidedText": ('PySide2.QtGui.QFontMetrics', 'int', 'PySide2.QtCore.Qt.TextElideMode', 'str'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.helpEvent": ('PySide2.QtGui.QHelpEvent', 'PySide2.QtWidgets.QAbstractItemView', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paintingRoles": (),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QAbstractItemView:
-# class PySide2.QtWidgets.QAbstractItemView.CursorAction:
-# class PySide2.QtWidgets.QAbstractItemView.DragDropMode:
-# class PySide2.QtWidgets.QAbstractItemView.DropIndicatorPosition:
-# class PySide2.QtWidgets.QAbstractItemView.EditTrigger:
-# class PySide2.QtWidgets.QAbstractItemView.EditTriggers:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollHint:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollMode:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionBehavior:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionMode:
-# class PySide2.QtWidgets.QAbstractItemView.State:
-    "PySide2.QtWidgets.QAbstractItemView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.alternatingRowColors": (),
-    "PySide2.QtWidgets.QAbstractItemView.autoScrollMargin": (),
-    "PySide2.QtWidgets.QAbstractItemView.clearSelection": (),
-    "PySide2.QtWidgets.QAbstractItemView.closeEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint'),
-    "PySide2.QtWidgets.QAbstractItemView.closePersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.commitData": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemView.currentIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List'),
-    "PySide2.QtWidgets.QAbstractItemView.defaultDropAction": (),
-    "PySide2.QtWidgets.QAbstractItemView.dirtyRegionOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.doAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.doItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropOverwriteMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnabled": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropIndicatorPosition": (),
-    "PySide2.QtWidgets.QAbstractItemView.edit": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.EditTrigger', 'PySide2.QtCore.QEvent')],
-    "PySide2.QtWidgets.QAbstractItemView.editTriggers": (),
-    "PySide2.QtWidgets.QAbstractItemView.editorDestroyed": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.executeDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.hasAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.iconSize": (),
-    "PySide2.QtWidgets.QAbstractItemView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractItemView.indexWidget": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractItemView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.isPersistentEditorOpen": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegate": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QAbstractItemView.model": (),
-    "PySide2.QtWidgets.QAbstractItemView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QAbstractItemView.openPersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.reset": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetHorizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetVerticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.rootIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scheduleDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollDirtyRegion": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToBottom": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToTop": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectAll": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectedIndexes": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionBehavior": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionCommand": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionModel": (),
-    "PySide2.QtWidgets.QAbstractItemView.setAlternatingRowColors": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScroll": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScrollMargin": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setCurrentIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setDefaultDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QAbstractItemView.setDirtyRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropMode": ('PySide2.QtWidgets.QAbstractItemView.DragDropMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDropIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setEditTriggers": ('PySide2.QtWidgets.QAbstractItemView.EditTriggers',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractItemView.setIndexWidget": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForColumn": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForRow": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionBehavior": ('PySide2.QtWidgets.QAbstractItemView.SelectionBehavior',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionMode": ('PySide2.QtWidgets.QAbstractItemView.SelectionMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setState": ('PySide2.QtWidgets.QAbstractItemView.State',),
-    "PySide2.QtWidgets.QAbstractItemView.setTabKeyNavigation": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setTextElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.showDropIndicator": (),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.startAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QAbstractItemView.state": (),
-    "PySide2.QtWidgets.QAbstractItemView.stopAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.tabKeyNavigation": (),
-    "PySide2.QtWidgets.QAbstractItemView.textElideMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.update": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorData": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewOptions": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractItemView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QAbstractScrollArea:
-# class PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QAbstractScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.addScrollBarWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QAbstractScrollArea.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.cornerWidget": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.maximumViewportSize": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollBarWidgets": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractScrollArea.setCornerWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setSizeAdjustPolicy": ('PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewportMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QAbstractScrollArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewport": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportMargins": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSlider:
-# class PySide2.QtWidgets.QAbstractSlider.SliderAction:
-# class PySide2.QtWidgets.QAbstractSlider.SliderChange:
-    "PySide2.QtWidgets.QAbstractSlider.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSlider.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.hasTracking": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedAppearance": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedControls": (),
-    "PySide2.QtWidgets.QAbstractSlider.isSliderDown": (),
-    "PySide2.QtWidgets.QAbstractSlider.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.maximum": (),
-    "PySide2.QtWidgets.QAbstractSlider.minimum": (),
-    "PySide2.QtWidgets.QAbstractSlider.orientation": (),
-    "PySide2.QtWidgets.QAbstractSlider.pageStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.repeatAction": (),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedControls": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setMaximum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setMinimum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QAbstractSlider.setPageStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setRepeatAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderPosition": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setValue": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.singleStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QAbstractSlider.sliderPosition": (),
-    "PySide2.QtWidgets.QAbstractSlider.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.triggerAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction',),
-    "PySide2.QtWidgets.QAbstractSlider.value": (),
-    "PySide2.QtWidgets.QAbstractSlider.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSpinBox:
-# class PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols:
-# class PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabled:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabledFlag:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepType:
-    "PySide2.QtWidgets.QAbstractSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSpinBox.alignment": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.buttonSymbols": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.clear": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.correctionMode": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasFrame": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QAbstractSpinBox.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractSpinBox.interpretText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isAccelerated": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isGroupSeparatorShown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isReadOnly": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyboardTracking": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.lineEdit": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.selectAll": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAccelerated": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setButtonSymbols": ('PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setCorrectionMode": ('PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setGroupSeparatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setKeyboardTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setSpecialValueText": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.specialValueText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepBy": ('int',),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepDown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepEnabled": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepUp": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.text": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QAbstractSpinBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.wrapping": (),
-# class PySide2.QtWidgets.QAccessibleWidget:
-    "PySide2.QtWidgets.QAccessibleWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QAccessible.Role', 'str'),
-    "PySide2.QtWidgets.QAccessibleWidget.actionNames": (),
-    "PySide2.QtWidgets.QAccessibleWidget.addControllingSignal": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.backgroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.child": ('int',),
-    "PySide2.QtWidgets.QAccessibleWidget.childCount": (),
-    "PySide2.QtWidgets.QAccessibleWidget.doAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.focusChild": (),
-    "PySide2.QtWidgets.QAccessibleWidget.foregroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtWidgets.QAccessibleWidget.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtWidgets.QAccessibleWidget.isValid": (),
-    "PySide2.QtWidgets.QAccessibleWidget.keyBindingsForAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.parent": (),
-    "PySide2.QtWidgets.QAccessibleWidget.parentObject": (),
-    "PySide2.QtWidgets.QAccessibleWidget.rect": (),
-    "PySide2.QtWidgets.QAccessibleWidget.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtWidgets.QAccessibleWidget.role": (),
-    "PySide2.QtWidgets.QAccessibleWidget.state": (),
-    "PySide2.QtWidgets.QAccessibleWidget.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtWidgets.QAccessibleWidget.widget": (),
-    "PySide2.QtWidgets.QAccessibleWidget.window": (),
-# class PySide2.QtWidgets.QAction:
-# class PySide2.QtWidgets.QAction.ActionEvent:
-# class PySide2.QtWidgets.QAction.MenuRole:
-# class PySide2.QtWidgets.QAction.Priority:
-    "PySide2.QtWidgets.QAction.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QAction.actionGroup": (),
-    "PySide2.QtWidgets.QAction.activate": ('PySide2.QtWidgets.QAction.ActionEvent',),
-    "PySide2.QtWidgets.QAction.associatedGraphicsWidgets": (),
-    "PySide2.QtWidgets.QAction.associatedWidgets": (),
-    "PySide2.QtWidgets.QAction.autoRepeat": (),
-    "PySide2.QtWidgets.QAction.data": (),
-    "PySide2.QtWidgets.QAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAction.font": (),
-    "PySide2.QtWidgets.QAction.hover": (),
-    "PySide2.QtWidgets.QAction.icon": (),
-    "PySide2.QtWidgets.QAction.iconText": (),
-    "PySide2.QtWidgets.QAction.isCheckable": (),
-    "PySide2.QtWidgets.QAction.isChecked": (),
-    "PySide2.QtWidgets.QAction.isEnabled": (),
-    "PySide2.QtWidgets.QAction.isIconVisibleInMenu": (),
-    "PySide2.QtWidgets.QAction.isSeparator": (),
-    "PySide2.QtWidgets.QAction.isShortcutVisibleInContextMenu": (),
-    "PySide2.QtWidgets.QAction.isVisible": (),
-    "PySide2.QtWidgets.QAction.menu": (),
-    "PySide2.QtWidgets.QAction.menuRole": (),
-    "PySide2.QtWidgets.QAction.parentWidget": (),
-    "PySide2.QtWidgets.QAction.priority": (),
-    "PySide2.QtWidgets.QAction.setActionGroup": ('PySide2.QtWidgets.QActionGroup',),
-    "PySide2.QtWidgets.QAction.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAction.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAction.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAction.setData": ('typing.Any',),
-    "PySide2.QtWidgets.QAction.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QAction.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAction.setIconText": ('str',),
-    "PySide2.QtWidgets.QAction.setIconVisibleInMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QAction.setMenuRole": ('PySide2.QtWidgets.QAction.MenuRole',),
-    "PySide2.QtWidgets.QAction.setPriority": ('PySide2.QtWidgets.QAction.Priority',),
-    "PySide2.QtWidgets.QAction.setSeparator": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAction.setShortcutContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QAction.setShortcutVisibleInContextMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcuts": [('PySide2.QtGui.QKeySequence.StandardKey',), ('typing.Sequence',)],
-    "PySide2.QtWidgets.QAction.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QAction.setText": ('str',),
-    "PySide2.QtWidgets.QAction.setToolTip": ('str',),
-    "PySide2.QtWidgets.QAction.setVisible": ('bool',),
-    "PySide2.QtWidgets.QAction.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QAction.shortcut": (),
-    "PySide2.QtWidgets.QAction.shortcutContext": (),
-    "PySide2.QtWidgets.QAction.shortcuts": (),
-    "PySide2.QtWidgets.QAction.showStatusText": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAction.statusTip": (),
-    "PySide2.QtWidgets.QAction.text": (),
-    "PySide2.QtWidgets.QAction.toggle": (),
-    "PySide2.QtWidgets.QAction.toolTip": (),
-    "PySide2.QtWidgets.QAction.trigger": (),
-    "PySide2.QtWidgets.QAction.whatsThis": (),
-# class PySide2.QtWidgets.QActionGroup:
-# class PySide2.QtWidgets.QActionGroup.ExclusionPolicy:
-    "PySide2.QtWidgets.QActionGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QActionGroup.actions": (),
-    "PySide2.QtWidgets.QActionGroup.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction',), ('str',)],
-    "PySide2.QtWidgets.QActionGroup.checkedAction": (),
-    "PySide2.QtWidgets.QActionGroup.exclusionPolicy": (),
-    "PySide2.QtWidgets.QActionGroup.isEnabled": (),
-    "PySide2.QtWidgets.QActionGroup.isExclusive": (),
-    "PySide2.QtWidgets.QActionGroup.isVisible": (),
-    "PySide2.QtWidgets.QActionGroup.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QActionGroup.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setExclusionPolicy": ('PySide2.QtWidgets.QActionGroup.ExclusionPolicy',),
-    "PySide2.QtWidgets.QActionGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setVisible": ('bool',),
-# class PySide2.QtWidgets.QApplication:
-# class PySide2.QtWidgets.QApplication.ColorSpec:
-    "PySide2.QtWidgets.QApplication.__init__": [(), ('typing.Sequence',)],
-    "PySide2.QtWidgets.QApplication.aboutQt": (),
-    "PySide2.QtWidgets.QApplication.activeModalWidget": (),
-    "PySide2.QtWidgets.QApplication.activePopupWidget": (),
-    "PySide2.QtWidgets.QApplication.activeWindow": (),
-    "PySide2.QtWidgets.QApplication.alert": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QApplication.allWidgets": (),
-    "PySide2.QtWidgets.QApplication.autoSipEnabled": (),
-    "PySide2.QtWidgets.QApplication.beep": (),
-    "PySide2.QtWidgets.QApplication.closeAllWindows": (),
-    "PySide2.QtWidgets.QApplication.colorSpec": (),
-    "PySide2.QtWidgets.QApplication.cursorFlashTime": (),
-    "PySide2.QtWidgets.QApplication.desktop": (),
-    "PySide2.QtWidgets.QApplication.doubleClickInterval": (),
-    "PySide2.QtWidgets.QApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QApplication.exec_": (),
-    "PySide2.QtWidgets.QApplication.focusWidget": (),
-    "PySide2.QtWidgets.QApplication.font": [(), ('PySide2.QtWidgets.QWidget',), ('bytes',)],
-    "PySide2.QtWidgets.QApplication.fontMetrics": (),
-    "PySide2.QtWidgets.QApplication.globalStrut": (),
-    "PySide2.QtWidgets.QApplication.isEffectEnabled": ('PySide2.QtCore.Qt.UIEffect',),
-    "PySide2.QtWidgets.QApplication.keyboardInputInterval": (),
-    "PySide2.QtWidgets.QApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QApplication.palette": [(), ('PySide2.QtWidgets.QWidget',), ('bytes',)],
-    "PySide2.QtWidgets.QApplication.setActiveWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QApplication.setAutoSipEnabled": ('bool',),
-    "PySide2.QtWidgets.QApplication.setColorSpec": ('int',),
-    "PySide2.QtWidgets.QApplication.setCursorFlashTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setDoubleClickInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setEffectEnabled": ('PySide2.QtCore.Qt.UIEffect', 'bool'),
-    "PySide2.QtWidgets.QApplication.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'bytes')],
-    "PySide2.QtWidgets.QApplication.setGlobalStrut": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QApplication.setKeyboardInputInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setPalette": [('PySide2.QtGui.QPalette',), ('PySide2.QtGui.QPalette', 'bytes')],
-    "PySide2.QtWidgets.QApplication.setStartDragDistance": ('int',),
-    "PySide2.QtWidgets.QApplication.setStartDragTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setStyle": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QApplication.setWheelScrollLines": ('int',),
-    "PySide2.QtWidgets.QApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QApplication.startDragDistance": (),
-    "PySide2.QtWidgets.QApplication.startDragTime": (),
-    "PySide2.QtWidgets.QApplication.style": (),
-    "PySide2.QtWidgets.QApplication.styleSheet": (),
-    "PySide2.QtWidgets.QApplication.topLevelAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.topLevelWidgets": (),
-    "PySide2.QtWidgets.QApplication.wheelScrollLines": (),
-    "PySide2.QtWidgets.QApplication.widgetAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.windowIcon": (),
-# class PySide2.QtWidgets.QBoxLayout:
-# class PySide2.QtWidgets.QBoxLayout.Direction:
-    "PySide2.QtWidgets.QBoxLayout.__init__": ('PySide2.QtWidgets.QBoxLayout.Direction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QBoxLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QBoxLayout.addLayout": ('PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.addSpacerItem": ('PySide2.QtWidgets.QSpacerItem',),
-    "PySide2.QtWidgets.QBoxLayout.addSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStrut": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QBoxLayout.count": (),
-    "PySide2.QtWidgets.QBoxLayout.direction": (),
-    "PySide2.QtWidgets.QBoxLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QBoxLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QBoxLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.insertItem": ('int', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertLayout": ('int', 'PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacerItem": ('int', 'PySide2.QtWidgets.QSpacerItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacing": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QBoxLayout.invalidate": (),
-    "PySide2.QtWidgets.QBoxLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.maximumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.minimumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.setDirection": ('PySide2.QtWidgets.QBoxLayout.Direction',),
-    "PySide2.QtWidgets.QBoxLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QBoxLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.setStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.setStretchFactor": [('PySide2.QtWidgets.QLayout', 'int'), ('PySide2.QtWidgets.QWidget', 'int')],
-    "PySide2.QtWidgets.QBoxLayout.sizeHint": (),
-    "PySide2.QtWidgets.QBoxLayout.spacing": (),
-    "PySide2.QtWidgets.QBoxLayout.stretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.takeAt": ('int',),
-# class PySide2.QtWidgets.QButtonGroup:
-    "PySide2.QtWidgets.QButtonGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QButtonGroup.addButton": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-    "PySide2.QtWidgets.QButtonGroup.button": ('int',),
-    "PySide2.QtWidgets.QButtonGroup.buttons": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedButton": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedId": (),
-    "PySide2.QtWidgets.QButtonGroup.exclusive": (),
-    "PySide2.QtWidgets.QButtonGroup.id": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QButtonGroup.setId": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-# class PySide2.QtWidgets.QCalendarWidget:
-# class PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat:
-# class PySide2.QtWidgets.QCalendarWidget.SelectionMode:
-# class PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat:
-    "PySide2.QtWidgets.QCalendarWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCalendarWidget.calendar": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateEditAcceptDelay": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateTextFormat": [(), ('PySide2.QtCore.QDate',)],
-    "PySide2.QtWidgets.QCalendarWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCalendarWidget.firstDayOfWeek": (),
-    "PySide2.QtWidgets.QCalendarWidget.headerTextFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.horizontalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.isDateEditEnabled": (),
-    "PySide2.QtWidgets.QCalendarWidget.isGridVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.isNavigationBarVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.maximumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.monthShown": (),
-    "PySide2.QtWidgets.QCalendarWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.paintCell": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.selectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.selectionMode": (),
-    "PySide2.QtWidgets.QCalendarWidget.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QCalendarWidget.setCurrentPage": ('int', 'int'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditAcceptDelay": ('int',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditEnabled": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateTextFormat": ('PySide2.QtCore.QDate', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.setFirstDayOfWeek": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.setGridVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setHeaderTextFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setHorizontalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setNavigationBarVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectedDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectionMode": ('PySide2.QtWidgets.QCalendarWidget.SelectionMode',),
-    "PySide2.QtWidgets.QCalendarWidget.setVerticalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setWeekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.showNextMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showNextYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showSelectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.showToday": (),
-    "PySide2.QtWidgets.QCalendarWidget.sizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.updateCell": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.updateCells": (),
-    "PySide2.QtWidgets.QCalendarWidget.verticalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.weekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.yearShown": (),
-# class PySide2.QtWidgets.QCheckBox:
-    "PySide2.QtWidgets.QCheckBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCheckBox.checkState": (),
-    "PySide2.QtWidgets.QCheckBox.checkStateSet": (),
-    "PySide2.QtWidgets.QCheckBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCheckBox.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QCheckBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QCheckBox.isTristate": (),
-    "PySide2.QtWidgets.QCheckBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCheckBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCheckBox.nextCheckState": (),
-    "PySide2.QtWidgets.QCheckBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCheckBox.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QCheckBox.setTristate": ('bool',),
-    "PySide2.QtWidgets.QCheckBox.sizeHint": (),
-# class PySide2.QtWidgets.QColorDialog:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOption:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOptions:
-    "PySide2.QtWidgets.QColorDialog.__init__": [('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QColorDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QColorDialog.currentColor": (),
-    "PySide2.QtWidgets.QColorDialog.customColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.customCount": (),
-    "PySide2.QtWidgets.QColorDialog.done": ('int',),
-    "PySide2.QtWidgets.QColorDialog.getColor": ('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QColorDialog.ColorDialogOptions'),
-    "PySide2.QtWidgets.QColorDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QColorDialog.options": (),
-    "PySide2.QtWidgets.QColorDialog.selectedColor": (),
-    "PySide2.QtWidgets.QColorDialog.setCurrentColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColorDialog.setCustomColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption', 'bool'),
-    "PySide2.QtWidgets.QColorDialog.setOptions": ('PySide2.QtWidgets.QColorDialog.ColorDialogOptions',),
-    "PySide2.QtWidgets.QColorDialog.setStandardColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QColorDialog.standardColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.testOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption',),
-# class PySide2.QtWidgets.QColormap:
-# class PySide2.QtWidgets.QColormap.Mode:
-    "PySide2.QtWidgets.QColormap.__init__": ('PySide2.QtWidgets.QColormap',),
-    "PySide2.QtWidgets.QColormap.__copy__": (),
-    "PySide2.QtWidgets.QColormap.cleanup": (),
-    "PySide2.QtWidgets.QColormap.colorAt": ('int',),
-    "PySide2.QtWidgets.QColormap.colormap": (),
-    "PySide2.QtWidgets.QColormap.depth": (),
-    "PySide2.QtWidgets.QColormap.initialize": (),
-    "PySide2.QtWidgets.QColormap.instance": ('int',),
-    "PySide2.QtWidgets.QColormap.mode": (),
-    "PySide2.QtWidgets.QColormap.pixel": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColormap.size": (),
-# class PySide2.QtWidgets.QColumnView:
-    "PySide2.QtWidgets.QColumnView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.columnWidths": (),
-    "PySide2.QtWidgets.QColumnView.createColumn": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QColumnView.horizontalOffset": (),
-    "PySide2.QtWidgets.QColumnView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QColumnView.initializeColumn": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QColumnView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QColumnView.previewWidget": (),
-    "PySide2.QtWidgets.QColumnView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QColumnView.resizeGripsVisible": (),
-    "PySide2.QtWidgets.QColumnView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QColumnView.selectAll": (),
-    "PySide2.QtWidgets.QColumnView.setColumnWidths": ('typing.Sequence',),
-    "PySide2.QtWidgets.QColumnView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QColumnView.setPreviewWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.setResizeGripsVisible": ('bool',),
-    "PySide2.QtWidgets.QColumnView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QColumnView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QColumnView.sizeHint": (),
-    "PySide2.QtWidgets.QColumnView.verticalOffset": (),
-    "PySide2.QtWidgets.QColumnView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QComboBox:
-# class PySide2.QtWidgets.QComboBox.InsertPolicy:
-# class PySide2.QtWidgets.QComboBox.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QComboBox.addItem": [('PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.addItems": ('typing.Sequence',),
-    "PySide2.QtWidgets.QComboBox.autoCompletion": (),
-    "PySide2.QtWidgets.QComboBox.autoCompletionCaseSensitivity": (),
-    "PySide2.QtWidgets.QComboBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.clear": (),
-    "PySide2.QtWidgets.QComboBox.clearEditText": (),
-    "PySide2.QtWidgets.QComboBox.completer": (),
-    "PySide2.QtWidgets.QComboBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QComboBox.count": (),
-    "PySide2.QtWidgets.QComboBox.currentData": ('int',),
-    "PySide2.QtWidgets.QComboBox.currentIndex": (),
-    "PySide2.QtWidgets.QComboBox.currentText": (),
-    "PySide2.QtWidgets.QComboBox.duplicatesEnabled": (),
-    "PySide2.QtWidgets.QComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.findData": ('typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.findText": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.hasFrame": (),
-    "PySide2.QtWidgets.QComboBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QComboBox.hidePopup": (),
-    "PySide2.QtWidgets.QComboBox.iconSize": (),
-    "PySide2.QtWidgets.QComboBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionComboBox',),
-    "PySide2.QtWidgets.QComboBox.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QComboBox.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItem": [('int', 'PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('int', 'str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItems": ('int', 'typing.Sequence'),
-    "PySide2.QtWidgets.QComboBox.insertPolicy": (),
-    "PySide2.QtWidgets.QComboBox.insertSeparator": ('int',),
-    "PySide2.QtWidgets.QComboBox.isEditable": (),
-    "PySide2.QtWidgets.QComboBox.itemData": ('int', 'int'),
-    "PySide2.QtWidgets.QComboBox.itemDelegate": (),
-    "PySide2.QtWidgets.QComboBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QComboBox.itemText": ('int',),
-    "PySide2.QtWidgets.QComboBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.lineEdit": (),
-    "PySide2.QtWidgets.QComboBox.maxCount": (),
-    "PySide2.QtWidgets.QComboBox.maxVisibleItems": (),
-    "PySide2.QtWidgets.QComboBox.minimumContentsLength": (),
-    "PySide2.QtWidgets.QComboBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QComboBox.model": (),
-    "PySide2.QtWidgets.QComboBox.modelColumn": (),
-    "PySide2.QtWidgets.QComboBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QComboBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QComboBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QComboBox.rootModelIndex": (),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletion": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletionCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QComboBox.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QComboBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QComboBox.setCurrentText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setDuplicatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setEditText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setEditable": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QComboBox.setInsertPolicy": ('PySide2.QtWidgets.QComboBox.InsertPolicy',),
-    "PySide2.QtWidgets.QComboBox.setItemData": ('int', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QComboBox.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QComboBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QComboBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QComboBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QComboBox.setMaxCount": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMinimumContentsLength": ('int',),
-    "PySide2.QtWidgets.QComboBox.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QComboBox.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QComboBox.setRootModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QComboBox.setSizeAdjustPolicy": ('PySide2.QtWidgets.QComboBox.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QComboBox.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QComboBox.setView": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QComboBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QComboBox.showPopup": (),
-    "PySide2.QtWidgets.QComboBox.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QComboBox.validator": (),
-    "PySide2.QtWidgets.QComboBox.view": (),
-    "PySide2.QtWidgets.QComboBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QCommandLinkButton:
-    "PySide2.QtWidgets.QCommandLinkButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget'), ('str', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCommandLinkButton.description": (),
-    "PySide2.QtWidgets.QCommandLinkButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QCommandLinkButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCommandLinkButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.setDescription": ('str',),
-    "PySide2.QtWidgets.QCommandLinkButton.sizeHint": (),
-# class PySide2.QtWidgets.QCommonStyle:
-    "PySide2.QtWidgets.QCommonStyle.__init__": (),
-    "PySide2.QtWidgets.QCommonStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QCommonStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QCommonStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QCommonStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QCompleter:
-# class PySide2.QtWidgets.QCompleter.CompletionMode:
-# class PySide2.QtWidgets.QCompleter.ModelSorting:
-    "PySide2.QtWidgets.QCompleter.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('typing.Sequence', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QCompleter.caseSensitivity": (),
-    "PySide2.QtWidgets.QCompleter.complete": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QCompleter.completionColumn": (),
-    "PySide2.QtWidgets.QCompleter.completionCount": (),
-    "PySide2.QtWidgets.QCompleter.completionMode": (),
-    "PySide2.QtWidgets.QCompleter.completionModel": (),
-    "PySide2.QtWidgets.QCompleter.completionPrefix": (),
-    "PySide2.QtWidgets.QCompleter.completionRole": (),
-    "PySide2.QtWidgets.QCompleter.currentCompletion": (),
-    "PySide2.QtWidgets.QCompleter.currentIndex": (),
-    "PySide2.QtWidgets.QCompleter.currentRow": (),
-    "PySide2.QtWidgets.QCompleter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCompleter.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCompleter.filterMode": (),
-    "PySide2.QtWidgets.QCompleter.maxVisibleItems": (),
-    "PySide2.QtWidgets.QCompleter.model": (),
-    "PySide2.QtWidgets.QCompleter.modelSorting": (),
-    "PySide2.QtWidgets.QCompleter.pathFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QCompleter.popup": (),
-    "PySide2.QtWidgets.QCompleter.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QCompleter.setCompletionColumn": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCompletionMode": ('PySide2.QtWidgets.QCompleter.CompletionMode',),
-    "PySide2.QtWidgets.QCompleter.setCompletionPrefix": ('str',),
-    "PySide2.QtWidgets.QCompleter.setCompletionRole": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCurrentRow": ('int',),
-    "PySide2.QtWidgets.QCompleter.setFilterMode": ('PySide2.QtCore.Qt.MatchFlags',),
-    "PySide2.QtWidgets.QCompleter.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QCompleter.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QCompleter.setModelSorting": ('PySide2.QtWidgets.QCompleter.ModelSorting',),
-    "PySide2.QtWidgets.QCompleter.setPopup": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QCompleter.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCompleter.setWrapAround": ('bool',),
-    "PySide2.QtWidgets.QCompleter.splitPath": ('str',),
-    "PySide2.QtWidgets.QCompleter.widget": (),
-    "PySide2.QtWidgets.QCompleter.wrapAround": (),
-# class PySide2.QtWidgets.QDataWidgetMapper:
-# class PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy:
-    "PySide2.QtWidgets.QDataWidgetMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QDataWidgetMapper.addMapping": [('PySide2.QtWidgets.QWidget', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtWidgets.QDataWidgetMapper.clearMapping": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.currentIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.itemDelegate": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedPropertyName": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedSection": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedWidgetAt": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.model": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.orientation": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.removeMapping": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.revert": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.rootIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setSubmitPolicy": ('PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy',),
-    "PySide2.QtWidgets.QDataWidgetMapper.submit": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.submitPolicy": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toFirst": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toLast": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toNext": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toPrevious": (),
-# class PySide2.QtWidgets.QDateEdit:
-    "PySide2.QtWidgets.QDateEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDateTimeEdit:
-# class PySide2.QtWidgets.QDateTimeEdit.Section:
-# class PySide2.QtWidgets.QDateTimeEdit.Sections:
-    "PySide2.QtWidgets.QDateTimeEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QDateTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('typing.Any', 'type', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QDateTimeEdit.calendar": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarPopup": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarWidget": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clear": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSection": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSectionIndex": (),
-    "PySide2.QtWidgets.QDateTimeEdit.date": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTimeFromText": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.displayFormat": (),
-    "PySide2.QtWidgets.QDateTimeEdit.displayedSections": (),
-    "PySide2.QtWidgets.QDateTimeEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.fixup": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QDateTimeEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionAt": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionCount": (),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionText": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarPopup": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarWidget": ('PySide2.QtWidgets.QCalendarWidget',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSectionIndex": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTimeRange": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDisplayFormat": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setSelectedSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeRange": ('PySide2.QtCore.QTime', 'PySide2.QtCore.QTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtWidgets.QDateTimeEdit.sizeHint": (),
-    "PySide2.QtWidgets.QDateTimeEdit.stepBy": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.stepEnabled": (),
-    "PySide2.QtWidgets.QDateTimeEdit.textFromDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.time": (),
-    "PySide2.QtWidgets.QDateTimeEdit.timeSpec": (),
-    "PySide2.QtWidgets.QDateTimeEdit.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDateTimeEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QDesktopWidget:
-    "PySide2.QtWidgets.QDesktopWidget.__init__": (),
-    "PySide2.QtWidgets.QDesktopWidget.availableGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.isVirtualDesktop": (),
-    "PySide2.QtWidgets.QDesktopWidget.numScreens": (),
-    "PySide2.QtWidgets.QDesktopWidget.primaryScreen": (),
-    "PySide2.QtWidgets.QDesktopWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDesktopWidget.screen": [(), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenCount": (),
-    "PySide2.QtWidgets.QDesktopWidget.screenGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenNumber": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDial:
-    "PySide2.QtWidgets.QDial.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDial.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDial.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QDial.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDial.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.notchSize": (),
-    "PySide2.QtWidgets.QDial.notchTarget": (),
-    "PySide2.QtWidgets.QDial.notchesVisible": (),
-    "PySide2.QtWidgets.QDial.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDial.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDial.setNotchTarget": ('float',),
-    "PySide2.QtWidgets.QDial.setNotchesVisible": ('bool',),
-    "PySide2.QtWidgets.QDial.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QDial.sizeHint": (),
-    "PySide2.QtWidgets.QDial.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QDial.wrapping": (),
-# class PySide2.QtWidgets.QDialog:
-# class PySide2.QtWidgets.QDialog.DialogCode:
-    "PySide2.QtWidgets.QDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QDialog.accept": (),
-    "PySide2.QtWidgets.QDialog.adjustPosition": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDialog.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QDialog.done": ('int',),
-    "PySide2.QtWidgets.QDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QDialog.exec_": (),
-    "PySide2.QtWidgets.QDialog.extension": (),
-    "PySide2.QtWidgets.QDialog.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QDialog.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDialog.open": (),
-    "PySide2.QtWidgets.QDialog.orientation": (),
-    "PySide2.QtWidgets.QDialog.reject": (),
-    "PySide2.QtWidgets.QDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDialog.result": (),
-    "PySide2.QtWidgets.QDialog.setExtension": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.setModal": ('bool',),
-    "PySide2.QtWidgets.QDialog.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialog.setResult": ('int',),
-    "PySide2.QtWidgets.QDialog.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QDialog.showExtension": ('bool',),
-    "PySide2.QtWidgets.QDialog.sizeHint": (),
-# class PySide2.QtWidgets.QDialogButtonBox:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonLayout:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonRole:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButton:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButtons:
-    "PySide2.QtWidgets.QDialogButtonBox.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QDialogButtonBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',), ('str', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole')],
-    "PySide2.QtWidgets.QDialogButtonBox.button": ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.centerButtons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.clear": (),
-    "PySide2.QtWidgets.QDialogButtonBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.orientation": (),
-    "PySide2.QtWidgets.QDialogButtonBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.setCenterButtons": ('bool',),
-    "PySide2.QtWidgets.QDialogButtonBox.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialogButtonBox.setStandardButtons": ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButtons": (),
-# class PySide2.QtWidgets.QDirModel:
-# class PySide2.QtWidgets.QDirModel.Roles:
-    "PySide2.QtWidgets.QDirModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QDirModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QDirModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QDirModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filter": (),
-    "PySide2.QtWidgets.QDirModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QDirModel.iconProvider": (),
-    "PySide2.QtWidgets.QDirModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QDirModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.isReadOnly": (),
-    "PySide2.QtWidgets.QDirModel.lazyChildCount": (),
-    "PySide2.QtWidgets.QDirModel.mimeData": ('typing.List',),
-    "PySide2.QtWidgets.QDirModel.mimeTypes": (),
-    "PySide2.QtWidgets.QDirModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QDirModel.nameFilters": (),
-    "PySide2.QtWidgets.QDirModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QDirModel.refresh": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QDirModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QDirModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QDirModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QDirModel.setLazyChildCount": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setNameFilters": ('typing.Sequence',),
-    "PySide2.QtWidgets.QDirModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtWidgets.QDirModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QDirModel.sorting": (),
-    "PySide2.QtWidgets.QDirModel.supportedDropActions": (),
-# class PySide2.QtWidgets.QDockWidget:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeature:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeatures:
-    "PySide2.QtWidgets.QDockWidget.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QDockWidget.allowedAreas": (),
-    "PySide2.QtWidgets.QDockWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDockWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.features": (),
-    "PySide2.QtWidgets.QDockWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionDockWidget',),
-    "PySide2.QtWidgets.QDockWidget.isAreaAllowed": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QDockWidget.isFloating": (),
-    "PySide2.QtWidgets.QDockWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDockWidget.setAllowedAreas": ('PySide2.QtCore.Qt.DockWidgetAreas',),
-    "PySide2.QtWidgets.QDockWidget.setFeatures": ('PySide2.QtWidgets.QDockWidget.DockWidgetFeatures',),
-    "PySide2.QtWidgets.QDockWidget.setFloating": ('bool',),
-    "PySide2.QtWidgets.QDockWidget.setTitleBarWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.titleBarWidget": (),
-    "PySide2.QtWidgets.QDockWidget.toggleViewAction": (),
-    "PySide2.QtWidgets.QDockWidget.widget": (),
-# class PySide2.QtWidgets.QDoubleSpinBox:
-    "PySide2.QtWidgets.QDoubleSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDoubleSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.decimals": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.maximum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.minimum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.prefix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.setDecimals": ('int',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMaximum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMinimum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setRange": ('float', 'float'),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSingleStep": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.stepType": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.suffix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.textFromValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDoubleSpinBox.value": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QErrorMessage:
-    "PySide2.QtWidgets.QErrorMessage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QErrorMessage.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QErrorMessage.done": ('int',),
-    "PySide2.QtWidgets.QErrorMessage.qtHandler": (),
-    "PySide2.QtWidgets.QErrorMessage.showMessage": [('str',), ('str', 'str')],
-# class PySide2.QtWidgets.QFileDialog:
-# class PySide2.QtWidgets.QFileDialog.AcceptMode:
-# class PySide2.QtWidgets.QFileDialog.DialogLabel:
-# class PySide2.QtWidgets.QFileDialog.FileMode:
-# class PySide2.QtWidgets.QFileDialog.Option:
-# class PySide2.QtWidgets.QFileDialog.Options:
-# class PySide2.QtWidgets.QFileDialog.ViewMode:
-    "PySide2.QtWidgets.QFileDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str')],
-    "PySide2.QtWidgets.QFileDialog.accept": (),
-    "PySide2.QtWidgets.QFileDialog.acceptMode": (),
-    "PySide2.QtWidgets.QFileDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileDialog.confirmOverwrite": (),
-    "PySide2.QtWidgets.QFileDialog.defaultSuffix": (),
-    "PySide2.QtWidgets.QFileDialog.directory": (),
-    "PySide2.QtWidgets.QFileDialog.directoryUrl": (),
-    "PySide2.QtWidgets.QFileDialog.done": ('int',),
-    "PySide2.QtWidgets.QFileDialog.fileMode": (),
-    "PySide2.QtWidgets.QFileDialog.filter": (),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectory": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectoryUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileNames": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrls": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence'),
-    "PySide2.QtWidgets.QFileDialog.history": (),
-    "PySide2.QtWidgets.QFileDialog.iconProvider": (),
-    "PySide2.QtWidgets.QFileDialog.isNameFilterDetailsVisible": (),
-    "PySide2.QtWidgets.QFileDialog.isReadOnly": (),
-    "PySide2.QtWidgets.QFileDialog.itemDelegate": (),
-    "PySide2.QtWidgets.QFileDialog.labelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel',),
-    "PySide2.QtWidgets.QFileDialog.mimeTypeFilters": (),
-    "PySide2.QtWidgets.QFileDialog.nameFilters": (),
-    "PySide2.QtWidgets.QFileDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QFileDialog.options": (),
-    "PySide2.QtWidgets.QFileDialog.proxyModel": (),
-    "PySide2.QtWidgets.QFileDialog.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileDialog.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QFileDialog.saveFileContent": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtWidgets.QFileDialog.saveState": (),
-    "PySide2.QtWidgets.QFileDialog.selectFile": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectMimeTypeFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.selectedFiles": (),
-    "PySide2.QtWidgets.QFileDialog.selectedMimeTypeFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedNameFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedUrls": (),
-    "PySide2.QtWidgets.QFileDialog.setAcceptMode": ('PySide2.QtWidgets.QFileDialog.AcceptMode',),
-    "PySide2.QtWidgets.QFileDialog.setConfirmOverwrite": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setDefaultSuffix": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setDirectory": [('PySide2.QtCore.QDir',), ('str',)],
-    "PySide2.QtWidgets.QFileDialog.setDirectoryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.setFileMode": ('PySide2.QtWidgets.QFileDialog.FileMode',),
-    "PySide2.QtWidgets.QFileDialog.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileDialog.setHistory": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileDialog.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileDialog.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QFileDialog.setLabelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel', 'str'),
-    "PySide2.QtWidgets.QFileDialog.setMimeTypeFilters": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilterDetailsVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilters": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileDialog.setOption": ('PySide2.QtWidgets.QFileDialog.Option', 'bool'),
-    "PySide2.QtWidgets.QFileDialog.setOptions": ('PySide2.QtWidgets.QFileDialog.Options',),
-    "PySide2.QtWidgets.QFileDialog.setProxyModel": ('PySide2.QtCore.QAbstractProxyModel',),
-    "PySide2.QtWidgets.QFileDialog.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setSidebarUrls": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileDialog.setSupportedSchemes": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileDialog.setViewMode": ('PySide2.QtWidgets.QFileDialog.ViewMode',),
-    "PySide2.QtWidgets.QFileDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.sidebarUrls": (),
-    "PySide2.QtWidgets.QFileDialog.supportedSchemes": (),
-    "PySide2.QtWidgets.QFileDialog.testOption": ('PySide2.QtWidgets.QFileDialog.Option',),
-    "PySide2.QtWidgets.QFileDialog.viewMode": (),
-# class PySide2.QtWidgets.QFileIconProvider:
-# class PySide2.QtWidgets.QFileIconProvider.IconType:
-# class PySide2.QtWidgets.QFileIconProvider.Option:
-# class PySide2.QtWidgets.QFileIconProvider.Options:
-    "PySide2.QtWidgets.QFileIconProvider.__init__": (),
-    "PySide2.QtWidgets.QFileIconProvider.icon": [('PySide2.QtCore.QFileInfo',), ('PySide2.QtWidgets.QFileIconProvider.IconType',)],
-    "PySide2.QtWidgets.QFileIconProvider.options": (),
-    "PySide2.QtWidgets.QFileIconProvider.setOptions": ('PySide2.QtWidgets.QFileIconProvider.Options',),
-    "PySide2.QtWidgets.QFileIconProvider.type": ('PySide2.QtCore.QFileInfo',),
-# class PySide2.QtWidgets.QFileSystemModel:
-# class PySide2.QtWidgets.QFileSystemModel.Option:
-# class PySide2.QtWidgets.QFileSystemModel.Options:
-# class PySide2.QtWidgets.QFileSystemModel.Roles:
-    "PySide2.QtWidgets.QFileSystemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QFileSystemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filter": (),
-    "PySide2.QtWidgets.QFileSystemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.iconProvider": (),
-    "PySide2.QtWidgets.QFileSystemModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QFileSystemModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.isReadOnly": (),
-    "PySide2.QtWidgets.QFileSystemModel.lastModified": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeData": ('typing.List',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeTypes": (),
-    "PySide2.QtWidgets.QFileSystemModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QFileSystemModel.myComputer": ('int',),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilterDisables": (),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilters": (),
-    "PySide2.QtWidgets.QFileSystemModel.options": (),
-    "PySide2.QtWidgets.QFileSystemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QFileSystemModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileSystemModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.rootDirectory": (),
-    "PySide2.QtWidgets.QFileSystemModel.rootPath": (),
-    "PySide2.QtWidgets.QFileSystemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileSystemModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilterDisables": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilters": ('typing.Sequence',),
-    "PySide2.QtWidgets.QFileSystemModel.setOption": ('PySide2.QtWidgets.QFileSystemModel.Option', 'bool'),
-    "PySide2.QtWidgets.QFileSystemModel.setOptions": ('PySide2.QtWidgets.QFileSystemModel.Options',),
-    "PySide2.QtWidgets.QFileSystemModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setRootPath": ('str',),
-    "PySide2.QtWidgets.QFileSystemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.size": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QFileSystemModel.supportedDropActions": (),
-    "PySide2.QtWidgets.QFileSystemModel.testOption": ('PySide2.QtWidgets.QFileSystemModel.Option',),
-    "PySide2.QtWidgets.QFileSystemModel.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.type": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtWidgets.QFocusFrame:
-    "PySide2.QtWidgets.QFocusFrame.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFocusFrame.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFocusFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QFocusFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFocusFrame.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.widget": (),
-# class PySide2.QtWidgets.QFontComboBox:
-# class PySide2.QtWidgets.QFontComboBox.FontFilter:
-# class PySide2.QtWidgets.QFontComboBox.FontFilters:
-    "PySide2.QtWidgets.QFontComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFontComboBox.currentFont": (),
-    "PySide2.QtWidgets.QFontComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontComboBox.fontFilters": (),
-    "PySide2.QtWidgets.QFontComboBox.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontComboBox.setFontFilters": ('PySide2.QtWidgets.QFontComboBox.FontFilters',),
-    "PySide2.QtWidgets.QFontComboBox.setWritingSystem": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtWidgets.QFontComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QFontComboBox.writingSystem": (),
-# class PySide2.QtWidgets.QFontDialog:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOption:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOptions:
-    "PySide2.QtWidgets.QFontDialog.__init__": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontDialog.currentFont": (),
-    "PySide2.QtWidgets.QFontDialog.done": ('int',),
-    "PySide2.QtWidgets.QFontDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFontDialog.getFont": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QFontDialog.FontDialogOptions'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QFontDialog.options": (),
-    "PySide2.QtWidgets.QFontDialog.selectedFont": (),
-    "PySide2.QtWidgets.QFontDialog.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontDialog.setOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption', 'bool'),
-    "PySide2.QtWidgets.QFontDialog.setOptions": ('PySide2.QtWidgets.QFontDialog.FontDialogOptions',),
-    "PySide2.QtWidgets.QFontDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFontDialog.testOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption',),
-# class PySide2.QtWidgets.QFormLayout:
-# class PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy:
-# class PySide2.QtWidgets.QFormLayout.ItemRole:
-# class PySide2.QtWidgets.QFormLayout.RowWrapPolicy:
-    "PySide2.QtWidgets.QFormLayout.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFormLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QFormLayout.addRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QLayout'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.count": (),
-    "PySide2.QtWidgets.QFormLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QFormLayout.fieldGrowthPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.formAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.getItemPosition": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getLayoutPosition": ('PySide2.QtWidgets.QLayout', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getWidgetPosition": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QFormLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QFormLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QFormLayout.insertRow": [('int', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('int', 'str', 'PySide2.QtWidgets.QLayout'), ('int', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.invalidate": (),
-    "PySide2.QtWidgets.QFormLayout.itemAt": [('int',), ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole')],
-    "PySide2.QtWidgets.QFormLayout.labelAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.labelForField": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFormLayout.minimumSize": (),
-    "PySide2.QtWidgets.QFormLayout.removeRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QFormLayout.rowCount": (),
-    "PySide2.QtWidgets.QFormLayout.rowWrapPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.setFieldGrowthPolicy": ('PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setFormAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFormLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setItem": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QFormLayout.setLabelAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setLayout": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayout'),
-    "PySide2.QtWidgets.QFormLayout.setRowWrapPolicy": ('PySide2.QtWidgets.QFormLayout.RowWrapPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setWidget": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QFormLayout.sizeHint": (),
-    "PySide2.QtWidgets.QFormLayout.spacing": (),
-    "PySide2.QtWidgets.QFormLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QFormLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QFrame:
-# class PySide2.QtWidgets.QFrame.Shadow:
-# class PySide2.QtWidgets.QFrame.Shape:
-# class PySide2.QtWidgets.QFrame.StyleMask:
-    "PySide2.QtWidgets.QFrame.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QFrame.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.drawFrame": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.frameRect": (),
-    "PySide2.QtWidgets.QFrame.frameShadow": (),
-    "PySide2.QtWidgets.QFrame.frameShape": (),
-    "PySide2.QtWidgets.QFrame.frameStyle": (),
-    "PySide2.QtWidgets.QFrame.frameWidth": (),
-    "PySide2.QtWidgets.QFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QFrame.lineWidth": (),
-    "PySide2.QtWidgets.QFrame.midLineWidth": (),
-    "PySide2.QtWidgets.QFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFrame.setFrameRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFrame.setFrameShadow": ('PySide2.QtWidgets.QFrame.Shadow',),
-    "PySide2.QtWidgets.QFrame.setFrameShape": ('PySide2.QtWidgets.QFrame.Shape',),
-    "PySide2.QtWidgets.QFrame.setFrameStyle": ('int',),
-    "PySide2.QtWidgets.QFrame.setLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.setMidLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.sizeHint": (),
-# class PySide2.QtWidgets.QGesture:
-# class PySide2.QtWidgets.QGesture.GestureCancelPolicy:
-    "PySide2.QtWidgets.QGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGesture.gestureCancelPolicy": (),
-    "PySide2.QtWidgets.QGesture.gestureType": (),
-    "PySide2.QtWidgets.QGesture.hasHotSpot": (),
-    "PySide2.QtWidgets.QGesture.hotSpot": (),
-    "PySide2.QtWidgets.QGesture.setGestureCancelPolicy": ('PySide2.QtWidgets.QGesture.GestureCancelPolicy',),
-    "PySide2.QtWidgets.QGesture.setHotSpot": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGesture.state": (),
-    "PySide2.QtWidgets.QGesture.unsetHotSpot": (),
-# class PySide2.QtWidgets.QGestureEvent:
-    "PySide2.QtWidgets.QGestureEvent.__init__": ('typing.Sequence',),
-    "PySide2.QtWidgets.QGestureEvent.accept": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.activeGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.canceledGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.gesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGestureEvent.gestures": (),
-    "PySide2.QtWidgets.QGestureEvent.ignore": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.isAccepted": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.mapToGraphicsScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGestureEvent.setAccepted": [('PySide2.QtCore.Qt.GestureType', 'bool'), ('PySide2.QtWidgets.QGesture', 'bool'), ('bool',)],
-    "PySide2.QtWidgets.QGestureEvent.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGestureEvent.widget": (),
-# class PySide2.QtWidgets.QGestureRecognizer:
-# class PySide2.QtWidgets.QGestureRecognizer.Result:
-# class PySide2.QtWidgets.QGestureRecognizer.ResultFlag:
-    "PySide2.QtWidgets.QGestureRecognizer.__init__": (),
-    "PySide2.QtWidgets.QGestureRecognizer.create": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGestureRecognizer.recognize": ('PySide2.QtWidgets.QGesture', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGestureRecognizer.registerRecognizer": ('PySide2.QtWidgets.QGestureRecognizer',),
-    "PySide2.QtWidgets.QGestureRecognizer.reset": ('PySide2.QtWidgets.QGesture',),
-    "PySide2.QtWidgets.QGestureRecognizer.unregisterRecognizer": ('PySide2.QtCore.Qt.GestureType',),
-# class PySide2.QtWidgets.QGraphicsAnchor:
-    "PySide2.QtWidgets.QGraphicsAnchor.setSizePolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QGraphicsAnchor.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchor.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.spacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.unsetSpacing": (),
-# class PySide2.QtWidgets.QGraphicsAnchorLayout:
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Orientations'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addCornerAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.anchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsBlurEffect:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHint:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints:
-    "PySide2.QtWidgets.QGraphicsBlurEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurHints": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurHints": ('PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurRadius": ('float',),
-# class PySide2.QtWidgets.QGraphicsColorizeEffect:
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setStrength": ('float',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.strength": (),
-# class PySide2.QtWidgets.QGraphicsDropShadowEffect:
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.offset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setBlurRadius": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setOffset": [('PySide2.QtCore.QPointF',), ('float',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setXOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setYOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.xOffset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.yOffset": (),
-# class PySide2.QtWidgets.QGraphicsEffect:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlag:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlags:
-# class PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode:
-    "PySide2.QtWidgets.QGraphicsEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.drawSource": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsEffect.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceBoundingRect": ('PySide2.QtCore.Qt.CoordinateSystem',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceChanged": ('PySide2.QtWidgets.QGraphicsEffect.ChangeFlags',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceIsPixmap": (),
-    "PySide2.QtWidgets.QGraphicsEffect.sourcePixmap": ('PySide2.QtCore.Qt.CoordinateSystem', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode'),
-    "PySide2.QtWidgets.QGraphicsEffect.update": (),
-    "PySide2.QtWidgets.QGraphicsEffect.updateBoundingRect": (),
-# class PySide2.QtWidgets.QGraphicsEllipseItem:
-    "PySide2.QtWidgets.QGraphicsEllipseItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setSpanAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setStartAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.spanAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.startAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.type": (),
-# class PySide2.QtWidgets.QGraphicsGridLayout:
-    "PySide2.QtWidgets.QGraphicsGridLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.addItem": [('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnPreferredWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.itemAt": [('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowPreferredHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnFixedWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMaximumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMinimumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnPreferredWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowFixedHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMaximumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMinimumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowPreferredHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsItem:
-# class PySide2.QtWidgets.QGraphicsItem.CacheMode:
-# class PySide2.QtWidgets.QGraphicsItem.Extension:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags:
-# class PySide2.QtWidgets.QGraphicsItem.PanelModality:
-    "PySide2.QtWidgets.QGraphicsItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.acceptDrops": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptHoverEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptTouchEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptedMouseButtons": (),
-    "PySide2.QtWidgets.QGraphicsItem.addToIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.advance": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegion": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegionGranularity": (),
-    "PySide2.QtWidgets.QGraphicsItem.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsItem.childItems": (),
-    "PySide2.QtWidgets.QGraphicsItem.childrenBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.clipPath": (),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidingItems": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsItem.commonAncestorItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.cursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.data": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.deviceTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.effectiveOpacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsItem.filtersChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.flags": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusProxy": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusScopeItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.graphicsEffect": (),
-    "PySide2.QtWidgets.QGraphicsItem.group": (),
-    "PySide2.QtWidgets.QGraphicsItem.handlesChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.hide": (),
-    "PySide2.QtWidgets.QGraphicsItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodHints": (),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsItem.installSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isActive": (),
-    "PySide2.QtWidgets.QGraphicsItem.isAncestorOf": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isBlockedByModalPanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isClipped": (),
-    "PySide2.QtWidgets.QGraphicsItem.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsItem.isObscured": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isPanel": (),
-    "PySide2.QtWidgets.QGraphicsItem.isSelected": (),
-    "PySide2.QtWidgets.QGraphicsItem.isUnderMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisible": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisibleTo": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.isWindow": (),
-    "PySide2.QtWidgets.QGraphicsItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.itemTransform": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mapFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.matrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.moveBy": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItem.opacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItem.panel": (),
-    "PySide2.QtWidgets.QGraphicsItem.panelModality": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.pos": (),
-    "PySide2.QtWidgets.QGraphicsItem.prepareGeometryChange": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeFromIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.rotation": (),
-    "PySide2.QtWidgets.QGraphicsItem.scale": (),
-    "PySide2.QtWidgets.QGraphicsItem.scene": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsItem.sceneMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.scroll": ('float', 'float', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsItem.setActive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setBoundingRegionGranularity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setCacheMode": ('PySide2.QtWidgets.QGraphicsItem.CacheMode', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QGraphicsItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QGraphicsItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFiltersChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFlag": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setFlags": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocusProxy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QGraphicsItem.setGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsItem.setHandlesChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QGraphicsItem.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setPanelModality": ('PySide2.QtWidgets.QGraphicsItem.PanelModality',),
-    "PySide2.QtWidgets.QGraphicsItem.setParentItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setPos": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setRotation": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QGraphicsItem.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setTransformOriginPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setTransformations": ('typing.Sequence',),
-    "PySide2.QtWidgets.QGraphicsItem.setVisible": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setX": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setY": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setZValue": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsItem.show": (),
-    "PySide2.QtWidgets.QGraphicsItem.stackBefore": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.toGraphicsObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.toolTip": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.transform": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformOriginPoint": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformations": (),
-    "PySide2.QtWidgets.QGraphicsItem.type": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.unsetCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.updateMicroFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.window": (),
-    "PySide2.QtWidgets.QGraphicsItem.x": (),
-    "PySide2.QtWidgets.QGraphicsItem.y": (),
-    "PySide2.QtWidgets.QGraphicsItem.zValue": (),
-# class PySide2.QtWidgets.QGraphicsItemAnimation:
-    "PySide2.QtWidgets.QGraphicsItemAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.afterAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.beforeAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.clear": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.item": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.matrixAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.reset": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.scaleList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setPosAt": ('float', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setRotationAt": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setScaleAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setShearAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTimeLine": ('PySide2.QtCore.QTimeLine',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTranslationAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.shearList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.timeLine": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.transformAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.translationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.xTranslationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.yTranslationAt": ('float',),
-# class PySide2.QtWidgets.QGraphicsItemGroup:
-    "PySide2.QtWidgets.QGraphicsItemGroup.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.addToGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItemGroup.removeFromGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.type": (),
-# class PySide2.QtWidgets.QGraphicsLayout:
-    "PySide2.QtWidgets.QGraphicsLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.activate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.addChildLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayout.instantInvalidatePropagation": (),
-    "PySide2.QtWidgets.QGraphicsLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.isActivated": (),
-    "PySide2.QtWidgets.QGraphicsLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.setContentsMargins": ('float', 'float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsLayout.setInstantInvalidatePropagation": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayout.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QGraphicsLayoutItem:
-    "PySide2.QtWidgets.QGraphicsLayoutItem.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'bool'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.contentsRect": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.effectiveSizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.graphicsItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.isLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.ownedByLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.parentLayoutItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGraphicsItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setOwnedByLayout": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setParentLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.updateGeometry": (),
-# class PySide2.QtWidgets.QGraphicsLineItem:
-    "PySide2.QtWidgets.QGraphicsLineItem.__init__": [('PySide2.QtCore.QLineF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsLineItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsLineItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsLineItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLineItem.line": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsLineItem.pen": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.setLine": [('PySide2.QtCore.QLineF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLineItem.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtWidgets.QGraphicsLineItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.type": (),
-# class PySide2.QtWidgets.QGraphicsLinearLayout:
-    "PySide2.QtWidgets.QGraphicsLinearLayout.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QGraphicsLayoutItem'), ('PySide2.QtWidgets.QGraphicsLayoutItem',)],
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.dump": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertItem": ('int', 'PySide2.QtWidgets.QGraphicsLayoutItem'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.orientation": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setItemSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setStretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.spacing": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.stretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-# class PySide2.QtWidgets.QGraphicsObject:
-    "PySide2.QtWidgets.QGraphicsObject.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsObject.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QGraphicsObject.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGraphicsObject.updateMicroFocus": (),
-# class PySide2.QtWidgets.QGraphicsOpacityEffect:
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacity": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacityMask": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacityMask": ('PySide2.QtGui.QBrush',),
-# class PySide2.QtWidgets.QGraphicsPathItem:
-    "PySide2.QtWidgets.QGraphicsPathItem.__init__": [('PySide2.QtGui.QPainterPath', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPathItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPathItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPathItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPathItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPathItem.path": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.setPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QGraphicsPathItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPixmapItem:
-# class PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode:
-    "PySide2.QtWidgets.QGraphicsPixmapItem.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.offset": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.pixmap": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setOffset": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setShapeMode": ('PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setTransformationMode": ('PySide2.QtCore.Qt.TransformationMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shapeMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.transformationMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPolygonItem:
-    "PySide2.QtWidgets.QGraphicsPolygonItem.__init__": [('PySide2.QtGui.QPolygonF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPolygonItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.fillRule": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.polygon": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.type": (),
-# class PySide2.QtWidgets.QGraphicsProxyWidget:
-    "PySide2.QtWidgets.QGraphicsProxyWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.createProxyForChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.newProxyWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.subWidgetRect": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.widget": (),
-# class PySide2.QtWidgets.QGraphicsRectItem:
-    "PySide2.QtWidgets.QGraphicsRectItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsRectItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsRectItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsRectItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsRectItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsRectItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsRectItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.type": (),
-# class PySide2.QtWidgets.QGraphicsRotation:
-    "PySide2.QtWidgets.QGraphicsRotation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsRotation.angle": (),
-    "PySide2.QtWidgets.QGraphicsRotation.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsRotation.axis": (),
-    "PySide2.QtWidgets.QGraphicsRotation.origin": (),
-    "PySide2.QtWidgets.QGraphicsRotation.setAngle": ('float',),
-    "PySide2.QtWidgets.QGraphicsRotation.setAxis": [('PySide2.QtCore.Qt.Axis',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtWidgets.QGraphicsRotation.setOrigin": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtWidgets.QGraphicsScale:
-    "PySide2.QtWidgets.QGraphicsScale.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsScale.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsScale.origin": (),
-    "PySide2.QtWidgets.QGraphicsScale.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtWidgets.QGraphicsScale.setXScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setYScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setZScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.xScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.yScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.zScale": (),
-# class PySide2.QtWidgets.QGraphicsScene:
-# class PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayer:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayers:
-    "PySide2.QtWidgets.QGraphicsScene.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QGraphicsScene.activePanel": (),
-    "PySide2.QtWidgets.QGraphicsScene.activeWindow": (),
-    "PySide2.QtWidgets.QGraphicsScene.addEllipse": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.addLine": [('PySide2.QtCore.QLineF', 'PySide2.QtGui.QPen'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen')],
-    "PySide2.QtWidgets.QGraphicsScene.addPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsScene.addPolygon": ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addRect": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addSimpleText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsScene.advance": (),
-    "PySide2.QtWidgets.QGraphicsScene.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.bspTreeDepth": (),
-    "PySide2.QtWidgets.QGraphicsScene.clear": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearSelection": (),
-    "PySide2.QtWidgets.QGraphicsScene.collidingItems": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsScene.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.createItemGroup": ('typing.Sequence',),
-    "PySide2.QtWidgets.QGraphicsScene.destroyItemGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsScene.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.focusOnTouch": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.font": (),
-    "PySide2.QtWidgets.QGraphicsScene.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.height": (),
-    "PySide2.QtWidgets.QGraphicsScene.helpEvent": ('PySide2.QtWidgets.QGraphicsSceneHelpEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsScene.invalidate": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers')],
-    "PySide2.QtWidgets.QGraphicsScene.isActive": (),
-    "PySide2.QtWidgets.QGraphicsScene.isSortCacheEnabled": (),
-    "PySide2.QtWidgets.QGraphicsScene.itemAt": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTransform'), ('float', 'float', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemIndexMethod": (),
-    "PySide2.QtWidgets.QGraphicsScene.items": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.Qt.SortOrder',), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemsBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.minimumRenderSize": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseGrabberItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.palette": (),
-    "PySide2.QtWidgets.QGraphicsScene.removeItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.render": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'),
-    "PySide2.QtWidgets.QGraphicsScene.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectedItems": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectionArea": (),
-    "PySide2.QtWidgets.QGraphicsScene.sendEvent": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.setActivePanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.setActiveWindow": ('PySide2.QtWidgets.QGraphicsWidget',),
-    "PySide2.QtWidgets.QGraphicsScene.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setBspTreeDepth": ('int',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusOnTouch": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsScene.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setItemIndexMethod": ('PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod',),
-    "PySide2.QtWidgets.QGraphicsScene.setMinimumRenderSize": ('float',),
-    "PySide2.QtWidgets.QGraphicsScene.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsScene.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.setSelectionArea": [('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionOperation', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.setSortCacheEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStickyFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsScene.stickyFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.style": (),
-    "PySide2.QtWidgets.QGraphicsScene.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.views": (),
-    "PySide2.QtWidgets.QGraphicsScene.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.width": (),
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent:
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason:
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.reason": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setReason": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneDragDropEvent:
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.acceptProposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.dropAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.mimeData": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.possibleActions": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.proposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPossibleActions": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setProposedAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneEvent:
-    "PySide2.QtWidgets.QGraphicsSceneEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneEvent.widget": (),
-# class PySide2.QtWidgets.QGraphicsSceneHelpEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneHoverEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneMouseEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.button": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScenePos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.flags": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScenePos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setFlags": ('PySide2.QtCore.Qt.MouseEventFlags',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setSource": ('PySide2.QtCore.Qt.MouseEventSource',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneMoveEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.newPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.oldPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setNewPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setOldPos": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QGraphicsSceneResizeEvent:
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.newSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.oldSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setNewSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setOldSize": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtWidgets.QGraphicsSceneWheelEvent:
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.delta": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.orientation": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setDelta": ('int',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSimpleTextItem:
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setText": ('str',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.text": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTextItem:
-    "PySide2.QtWidgets.QGraphicsTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsTextItem.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsTextItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.defaultTextColor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.document": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.openExternalLinks": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsTextItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDefaultTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setHtml": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setPlainText": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.tabChangesFocus": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textCursor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textInteractionFlags": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textWidth": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toHtml": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toPlainText": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTransform:
-    "PySide2.QtWidgets.QGraphicsTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsTransform.update": (),
-# class PySide2.QtWidgets.QGraphicsView:
-# class PySide2.QtWidgets.QGraphicsView.CacheMode:
-# class PySide2.QtWidgets.QGraphicsView.CacheModeFlag:
-# class PySide2.QtWidgets.QGraphicsView.DragMode:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlag:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlags:
-# class PySide2.QtWidgets.QGraphicsView.ViewportAnchor:
-# class PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode:
-    "PySide2.QtWidgets.QGraphicsView.__init__": [('PySide2.QtWidgets.QGraphicsScene', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGraphicsView.alignment": (),
-    "PySide2.QtWidgets.QGraphicsView.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsView.centerOn": [('PySide2.QtCore.QPointF',), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragMode": (),
-    "PySide2.QtWidgets.QGraphicsView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawItems": ('PySide2.QtGui.QPainter', 'int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtWidgets.QGraphicsView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QGraphicsView.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('PySide2.QtWidgets.QGraphicsItem', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.fitInView": [('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsView.invalidateScene": ('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'),
-    "PySide2.QtWidgets.QGraphicsView.isInteractive": (),
-    "PySide2.QtWidgets.QGraphicsView.isTransformed": (),
-    "PySide2.QtWidgets.QGraphicsView.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.items": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ItemSelectionMode')],
-    "PySide2.QtWidgets.QGraphicsView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.mapToScene": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('int', 'int'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.matrix": (),
-    "PySide2.QtWidgets.QGraphicsView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.optimizationFlags": (),
-    "PySide2.QtWidgets.QGraphicsView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGraphicsView.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.renderHints": (),
-    "PySide2.QtWidgets.QGraphicsView.resetCachedContent": (),
-    "PySide2.QtWidgets.QGraphicsView.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsView.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsView.rotate": ('float',),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandRect": (),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandSelectionMode": (),
-    "PySide2.QtWidgets.QGraphicsView.scale": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.scene": (),
-    "PySide2.QtWidgets.QGraphicsView.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsView.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QGraphicsView.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setCacheMode": ('PySide2.QtWidgets.QGraphicsView.CacheMode',),
-    "PySide2.QtWidgets.QGraphicsView.setDragMode": ('PySide2.QtWidgets.QGraphicsView.DragMode',),
-    "PySide2.QtWidgets.QGraphicsView.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setInteractive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlag": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlags": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlags',),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints',),
-    "PySide2.QtWidgets.QGraphicsView.setResizeAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setRubberBandSelectionMode": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsView.setScene": ('PySide2.QtWidgets.QGraphicsScene',),
-    "PySide2.QtWidgets.QGraphicsView.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setTransformationAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setViewportUpdateMode": ('PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode',),
-    "PySide2.QtWidgets.QGraphicsView.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsView.shear": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsView.sizeHint": (),
-    "PySide2.QtWidgets.QGraphicsView.transform": (),
-    "PySide2.QtWidgets.QGraphicsView.transformationAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.translate": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.updateScene": ('typing.Sequence',),
-    "PySide2.QtWidgets.QGraphicsView.updateSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.viewportTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.viewportUpdateMode": (),
-    "PySide2.QtWidgets.QGraphicsView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QGraphicsWidget:
-    "PySide2.QtWidgets.QGraphicsWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsWidget.actions": (),
-    "PySide2.QtWidgets.QGraphicsWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.addActions": ('typing.Sequence',),
-    "PySide2.QtWidgets.QGraphicsWidget.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QGraphicsWidget.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.close": (),
-    "PySide2.QtWidgets.QGraphicsWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QGraphicsWidget.focusWidget": (),
-    "PySide2.QtWidgets.QGraphicsWidget.font": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.grabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QGraphicsWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QGraphicsWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QGraphicsWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence'),
-    "PySide2.QtWidgets.QGraphicsWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QGraphicsWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.layout": (),
-    "PySide2.QtWidgets.QGraphicsWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.moveEvent": ('PySide2.QtWidgets.QGraphicsSceneMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.paintWindowFrame": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.palette": (),
-    "PySide2.QtWidgets.QGraphicsWidget.polishEvent": (),
-    "PySide2.QtWidgets.QGraphicsWidget.propertyChange": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.rect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QGraphicsWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.resize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.setContentsMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QGraphicsWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsWidget.setGeometry": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setLayout": ('PySide2.QtWidgets.QGraphicsLayout',),
-    "PySide2.QtWidgets.QGraphicsWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QGraphicsWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsWidget.setTabOrder": ('PySide2.QtWidgets.QGraphicsWidget', 'PySide2.QtWidgets.QGraphicsWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFrameMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QGraphicsWidget.shape": (),
-    "PySide2.QtWidgets.QGraphicsWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.size": (),
-    "PySide2.QtWidgets.QGraphicsWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsWidget.style": (),
-    "PySide2.QtWidgets.QGraphicsWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QGraphicsWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFlags": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameSectionAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowTitle": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowType": (),
-# class PySide2.QtWidgets.QGridLayout:
-    "PySide2.QtWidgets.QGridLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGridLayout.addItem": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addLayout": [('PySide2.QtWidgets.QLayout', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QLayout', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.cellRect": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.columnStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.count": (),
-    "PySide2.QtWidgets.QGridLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QGridLayout.getItemPosition": ('int',),
-    "PySide2.QtWidgets.QGridLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QGridLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGridLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.itemAtPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.maximumSize": (),
-    "PySide2.QtWidgets.QGridLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.minimumSize": (),
-    "PySide2.QtWidgets.QGridLayout.originCorner": (),
-    "PySide2.QtWidgets.QGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGridLayout.rowStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setColumnMinimumWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setColumnStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setDefaultPositioning": ('int', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QGridLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QGridLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setOriginCorner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QGridLayout.setRowMinimumHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setRowStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.sizeHint": (),
-    "PySide2.QtWidgets.QGridLayout.spacing": (),
-    "PySide2.QtWidgets.QGridLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGroupBox:
-    "PySide2.QtWidgets.QGroupBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QGroupBox.alignment": (),
-    "PySide2.QtWidgets.QGroupBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QGroupBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGroupBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionGroupBox',),
-    "PySide2.QtWidgets.QGroupBox.isCheckable": (),
-    "PySide2.QtWidgets.QGroupBox.isChecked": (),
-    "PySide2.QtWidgets.QGroupBox.isFlat": (),
-    "PySide2.QtWidgets.QGroupBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QGroupBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGroupBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGroupBox.setAlignment": ('int',),
-    "PySide2.QtWidgets.QGroupBox.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setChecked": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setFlat": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setTitle": ('str',),
-    "PySide2.QtWidgets.QGroupBox.title": (),
-# class PySide2.QtWidgets.QHBoxLayout:
-    "PySide2.QtWidgets.QHBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QHeaderView:
-# class PySide2.QtWidgets.QHeaderView.ResizeMode:
-    "PySide2.QtWidgets.QHeaderView.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QHeaderView.cascadingSectionResizes": (),
-    "PySide2.QtWidgets.QHeaderView.count": (),
-    "PySide2.QtWidgets.QHeaderView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QHeaderView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List'),
-    "PySide2.QtWidgets.QHeaderView.defaultAlignment": (),
-    "PySide2.QtWidgets.QHeaderView.defaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.doItemsLayout": (),
-    "PySide2.QtWidgets.QHeaderView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.headerDataChanged": ('PySide2.QtCore.Qt.Orientation', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.hiddenSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.hideSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.highlightSections": (),
-    "PySide2.QtWidgets.QHeaderView.horizontalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QHeaderView.initStyleOption": [('PySide2.QtWidgets.QStyleOptionFrame',), ('PySide2.QtWidgets.QStyleOptionHeader',)],
-    "PySide2.QtWidgets.QHeaderView.initialize": (),
-    "PySide2.QtWidgets.QHeaderView.initializeSections": [(), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.isFirstSectionMovable": (),
-    "PySide2.QtWidgets.QHeaderView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.isSectionHidden": ('int',),
-    "PySide2.QtWidgets.QHeaderView.isSortIndicatorShown": (),
-    "PySide2.QtWidgets.QHeaderView.length": (),
-    "PySide2.QtWidgets.QHeaderView.logicalIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.logicalIndexAt": [('PySide2.QtCore.QPoint',), ('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.maximumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.minimumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QHeaderView.moveSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.offset": (),
-    "PySide2.QtWidgets.QHeaderView.orientation": (),
-    "PySide2.QtWidgets.QHeaderView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QHeaderView.paintSection": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtWidgets.QHeaderView.reset": (),
-    "PySide2.QtWidgets.QHeaderView.resetDefaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.resizeContentsPrecision": (),
-    "PySide2.QtWidgets.QHeaderView.resizeSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.resizeSections": [(), ('PySide2.QtWidgets.QHeaderView.ResizeMode',)],
-    "PySide2.QtWidgets.QHeaderView.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QHeaderView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.saveState": (),
-    "PySide2.QtWidgets.QHeaderView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QHeaderView.sectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionResizeMode": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeFromContents": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeHint": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionViewportPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsClickable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsHidden": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsMovable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsMoved": (),
-    "PySide2.QtWidgets.QHeaderView.setCascadingSectionResizes": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setFirstSectionMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setHighlightSections": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setMaximumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setMinimumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QHeaderView.setOffset": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToSectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setResizeContentsPrecision": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setSectionHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QHeaderView.setSectionResizeMode": [('PySide2.QtWidgets.QHeaderView.ResizeMode',), ('int', 'PySide2.QtWidgets.QHeaderView.ResizeMode')],
-    "PySide2.QtWidgets.QHeaderView.setSectionsClickable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSectionsMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicator": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setStretchLastSection": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setVisible": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.showSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sizeHint": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorOrder": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.swapSections": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.updateGeometries": (),
-    "PySide2.QtWidgets.QHeaderView.updateSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.verticalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.visualIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualIndexAt": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QInputDialog:
-# class PySide2.QtWidgets.QInputDialog.InputDialogOption:
-# class PySide2.QtWidgets.QInputDialog.InputMode:
-    "PySide2.QtWidgets.QInputDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.cancelButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.comboBoxItems": (),
-    "PySide2.QtWidgets.QInputDialog.done": ('int',),
-    "PySide2.QtWidgets.QInputDialog.doubleDecimals": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleStep": (),
-    "PySide2.QtWidgets.QInputDialog.doubleValue": (),
-    "PySide2.QtWidgets.QInputDialog.getDouble": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags', 'float')],
-    "PySide2.QtWidgets.QInputDialog.getInt": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.getItem": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'typing.Sequence', 'int', 'bool', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getMultiLineText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QLineEdit.EchoMode', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.inputMode": (),
-    "PySide2.QtWidgets.QInputDialog.intMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.intMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.intStep": (),
-    "PySide2.QtWidgets.QInputDialog.intValue": (),
-    "PySide2.QtWidgets.QInputDialog.isComboBoxEditable": (),
-    "PySide2.QtWidgets.QInputDialog.labelText": (),
-    "PySide2.QtWidgets.QInputDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.okButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QInputDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxEditable": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxItems": ('typing.Sequence',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleDecimals": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMaximum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMinimum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleRange": ('float', 'float'),
-    "PySide2.QtWidgets.QInputDialog.setDoubleStep": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleValue": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setInputMode": ('PySide2.QtWidgets.QInputDialog.InputMode',),
-    "PySide2.QtWidgets.QInputDialog.setIntMaximum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntMinimum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntRange": ('int', 'int'),
-    "PySide2.QtWidgets.QInputDialog.setIntStep": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntValue": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOkButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption', 'bool'),
-    "PySide2.QtWidgets.QInputDialog.setTextEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QInputDialog.setTextValue": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.sizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.testOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption',),
-    "PySide2.QtWidgets.QInputDialog.textEchoMode": (),
-    "PySide2.QtWidgets.QInputDialog.textValue": (),
-# class PySide2.QtWidgets.QItemDelegate:
-    "PySide2.QtWidgets.QItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.decoration": ('PySide2.QtWidgets.QStyleOptionViewItem', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.doCheck": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.drawCheck": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QItemDelegate.drawDecoration": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QItemDelegate.drawDisplay": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.drawFocus": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QItemDelegate.hasClipping": (),
-    "PySide2.QtWidgets.QItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.rect": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QItemDelegate.selectedPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPalette', 'bool'),
-    "PySide2.QtWidgets.QItemDelegate.setClipping": ('bool',),
-    "PySide2.QtWidgets.QItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setOptions": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QStyleOptionViewItem'),
-    "PySide2.QtWidgets.QItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.textRectangle": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QFont', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QItemEditorCreatorBase:
-    "PySide2.QtWidgets.QItemEditorCreatorBase.__init__": (),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.valuePropertyName": (),
-# class PySide2.QtWidgets.QItemEditorFactory:
-    "PySide2.QtWidgets.QItemEditorFactory.__init__": (),
-    "PySide2.QtWidgets.QItemEditorFactory.createEditor": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QItemEditorFactory.defaultFactory": (),
-    "PySide2.QtWidgets.QItemEditorFactory.registerEditor": ('int', 'PySide2.QtWidgets.QItemEditorCreatorBase'),
-    "PySide2.QtWidgets.QItemEditorFactory.setDefaultFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemEditorFactory.valuePropertyName": ('int',),
-# class PySide2.QtWidgets.QKeyEventTransition:
-    "PySide2.QtWidgets.QKeyEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QKeyEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.key": (),
-    "PySide2.QtWidgets.QKeyEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QKeyEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.setKey": ('int',),
-    "PySide2.QtWidgets.QKeyEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QKeySequenceEdit:
-    "PySide2.QtWidgets.QKeySequenceEdit.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QKeySequenceEdit.clear": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keySequence": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.setKeySequence": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QKeySequenceEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QLCDNumber:
-# class PySide2.QtWidgets.QLCDNumber.Mode:
-# class PySide2.QtWidgets.QLCDNumber.SegmentStyle:
-    "PySide2.QtWidgets.QLCDNumber.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLCDNumber.checkOverflow": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLCDNumber.digitCount": (),
-    "PySide2.QtWidgets.QLCDNumber.display": [('float',), ('int',), ('str',)],
-    "PySide2.QtWidgets.QLCDNumber.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLCDNumber.intValue": (),
-    "PySide2.QtWidgets.QLCDNumber.mode": (),
-    "PySide2.QtWidgets.QLCDNumber.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLCDNumber.segmentStyle": (),
-    "PySide2.QtWidgets.QLCDNumber.setBinMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDecMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDigitCount": ('int',),
-    "PySide2.QtWidgets.QLCDNumber.setHexMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setMode": ('PySide2.QtWidgets.QLCDNumber.Mode',),
-    "PySide2.QtWidgets.QLCDNumber.setOctMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setSegmentStyle": ('PySide2.QtWidgets.QLCDNumber.SegmentStyle',),
-    "PySide2.QtWidgets.QLCDNumber.setSmallDecimalPoint": ('bool',),
-    "PySide2.QtWidgets.QLCDNumber.sizeHint": (),
-    "PySide2.QtWidgets.QLCDNumber.smallDecimalPoint": (),
-    "PySide2.QtWidgets.QLCDNumber.value": (),
-# class PySide2.QtWidgets.QLabel:
-    "PySide2.QtWidgets.QLabel.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QLabel.alignment": (),
-    "PySide2.QtWidgets.QLabel.buddy": (),
-    "PySide2.QtWidgets.QLabel.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.clear": (),
-    "PySide2.QtWidgets.QLabel.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLabel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QLabel.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.hasScaledContents": (),
-    "PySide2.QtWidgets.QLabel.hasSelectedText": (),
-    "PySide2.QtWidgets.QLabel.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLabel.indent": (),
-    "PySide2.QtWidgets.QLabel.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLabel.margin": (),
-    "PySide2.QtWidgets.QLabel.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLabel.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.movie": (),
-    "PySide2.QtWidgets.QLabel.openExternalLinks": (),
-    "PySide2.QtWidgets.QLabel.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLabel.picture": (),
-    "PySide2.QtWidgets.QLabel.pixmap": (),
-    "PySide2.QtWidgets.QLabel.selectedText": (),
-    "PySide2.QtWidgets.QLabel.selectionStart": (),
-    "PySide2.QtWidgets.QLabel.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLabel.setBuddy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLabel.setIndent": ('int',),
-    "PySide2.QtWidgets.QLabel.setMargin": ('int',),
-    "PySide2.QtWidgets.QLabel.setMovie": ('PySide2.QtGui.QMovie',),
-    "PySide2.QtWidgets.QLabel.setNum": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLabel.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QLabel.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtWidgets.QLabel.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QLabel.setScaledContents": ('bool',),
-    "PySide2.QtWidgets.QLabel.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLabel.setText": ('str',),
-    "PySide2.QtWidgets.QLabel.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QLabel.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QLabel.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QLabel.sizeHint": (),
-    "PySide2.QtWidgets.QLabel.text": (),
-    "PySide2.QtWidgets.QLabel.textFormat": (),
-    "PySide2.QtWidgets.QLabel.textInteractionFlags": (),
-    "PySide2.QtWidgets.QLabel.wordWrap": (),
-# class PySide2.QtWidgets.QLayout:
-# class PySide2.QtWidgets.QLayout.SizeConstraint:
-    "PySide2.QtWidgets.QLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.activate": (),
-    "PySide2.QtWidgets.QLayout.addChildLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.addChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.adoptLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.alignmentRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QLayout.closestAcceptableSize": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QLayout.contentsMargins": (),
-    "PySide2.QtWidgets.QLayout.contentsRect": (),
-    "PySide2.QtWidgets.QLayout.controlTypes": (),
-    "PySide2.QtWidgets.QLayout.count": (),
-    "PySide2.QtWidgets.QLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QLayout.geometry": (),
-    "PySide2.QtWidgets.QLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QLayout.indexOf": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.invalidate": (),
-    "PySide2.QtWidgets.QLayout.isEmpty": (),
-    "PySide2.QtWidgets.QLayout.isEnabled": (),
-    "PySide2.QtWidgets.QLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QLayout.layout": (),
-    "PySide2.QtWidgets.QLayout.margin": (),
-    "PySide2.QtWidgets.QLayout.maximumSize": (),
-    "PySide2.QtWidgets.QLayout.menuBar": (),
-    "PySide2.QtWidgets.QLayout.minimumSize": (),
-    "PySide2.QtWidgets.QLayout.parentWidget": (),
-    "PySide2.QtWidgets.QLayout.removeItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.replaceWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.FindChildOptions'),
-    "PySide2.QtWidgets.QLayout.setAlignment": [('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtWidgets.QLayout', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QLayout.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLayout.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.setMargin": ('int',),
-    "PySide2.QtWidgets.QLayout.setMenuBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.setSizeConstraint": ('PySide2.QtWidgets.QLayout.SizeConstraint',),
-    "PySide2.QtWidgets.QLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QLayout.sizeConstraint": (),
-    "PySide2.QtWidgets.QLayout.spacing": (),
-    "PySide2.QtWidgets.QLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QLayout.totalHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayout.totalMaximumSize": (),
-    "PySide2.QtWidgets.QLayout.totalMinimumSize": (),
-    "PySide2.QtWidgets.QLayout.totalSizeHint": (),
-    "PySide2.QtWidgets.QLayout.update": (),
-    "PySide2.QtWidgets.QLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QLayoutItem:
-    "PySide2.QtWidgets.QLayoutItem.__init__": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.alignment": (),
-    "PySide2.QtWidgets.QLayoutItem.controlTypes": (),
-    "PySide2.QtWidgets.QLayoutItem.expandingDirections": (),
-    "PySide2.QtWidgets.QLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QLayoutItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QLayoutItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.invalidate": (),
-    "PySide2.QtWidgets.QLayoutItem.isEmpty": (),
-    "PySide2.QtWidgets.QLayoutItem.layout": (),
-    "PySide2.QtWidgets.QLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayoutItem.sizeHint": (),
-    "PySide2.QtWidgets.QLayoutItem.spacerItem": (),
-    "PySide2.QtWidgets.QLayoutItem.widget": (),
-# class PySide2.QtWidgets.QLineEdit:
-# class PySide2.QtWidgets.QLineEdit.ActionPosition:
-# class PySide2.QtWidgets.QLineEdit.EchoMode:
-    "PySide2.QtWidgets.QLineEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLineEdit.addAction": [('PySide2.QtGui.QIcon', 'PySide2.QtWidgets.QLineEdit.ActionPosition'), ('PySide2.QtWidgets.QAction',), ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QLineEdit.ActionPosition')],
-    "PySide2.QtWidgets.QLineEdit.alignment": (),
-    "PySide2.QtWidgets.QLineEdit.backspace": (),
-    "PySide2.QtWidgets.QLineEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.clear": (),
-    "PySide2.QtWidgets.QLineEdit.completer": (),
-    "PySide2.QtWidgets.QLineEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLineEdit.copy": (),
-    "PySide2.QtWidgets.QLineEdit.createStandardContextMenu": (),
-    "PySide2.QtWidgets.QLineEdit.cursorBackward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorForward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorMoveStyle": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPosition": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPositionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QLineEdit.cursorRect": (),
-    "PySide2.QtWidgets.QLineEdit.cursorWordBackward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cursorWordForward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cut": (),
-    "PySide2.QtWidgets.QLineEdit.del_": (),
-    "PySide2.QtWidgets.QLineEdit.deselect": (),
-    "PySide2.QtWidgets.QLineEdit.displayText": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QLineEdit.echoMode": (),
-    "PySide2.QtWidgets.QLineEdit.end": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.getTextMargins": (),
-    "PySide2.QtWidgets.QLineEdit.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QLineEdit.hasFrame": (),
-    "PySide2.QtWidgets.QLineEdit.hasSelectedText": (),
-    "PySide2.QtWidgets.QLineEdit.home": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QLineEdit.inputMask": (),
-    "PySide2.QtWidgets.QLineEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QLineEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QLineEdit.insert": ('str',),
-    "PySide2.QtWidgets.QLineEdit.isClearButtonEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.isModified": (),
-    "PySide2.QtWidgets.QLineEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QLineEdit.isRedoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.isUndoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLineEdit.maxLength": (),
-    "PySide2.QtWidgets.QLineEdit.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLineEdit.paste": (),
-    "PySide2.QtWidgets.QLineEdit.placeholderText": (),
-    "PySide2.QtWidgets.QLineEdit.redo": (),
-    "PySide2.QtWidgets.QLineEdit.selectAll": (),
-    "PySide2.QtWidgets.QLineEdit.selectedText": (),
-    "PySide2.QtWidgets.QLineEdit.selectionEnd": (),
-    "PySide2.QtWidgets.QLineEdit.selectionLength": (),
-    "PySide2.QtWidgets.QLineEdit.selectionStart": (),
-    "PySide2.QtWidgets.QLineEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLineEdit.setClearButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QLineEdit.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtWidgets.QLineEdit.setCursorPosition": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QLineEdit.setFrame": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setInputMask": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setMaxLength": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setModified": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLineEdit.setText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setTextMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLineEdit.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QLineEdit.sizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.text": (),
-    "PySide2.QtWidgets.QLineEdit.textMargins": (),
-    "PySide2.QtWidgets.QLineEdit.undo": (),
-    "PySide2.QtWidgets.QLineEdit.validator": (),
-# class PySide2.QtWidgets.QListView:
-# class PySide2.QtWidgets.QListView.Flow:
-# class PySide2.QtWidgets.QListView.LayoutMode:
-# class PySide2.QtWidgets.QListView.Movement:
-# class PySide2.QtWidgets.QListView.ResizeMode:
-# class PySide2.QtWidgets.QListView.ViewMode:
-    "PySide2.QtWidgets.QListView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListView.batchSize": (),
-    "PySide2.QtWidgets.QListView.clearPropertyFlags": (),
-    "PySide2.QtWidgets.QListView.contentsSize": (),
-    "PySide2.QtWidgets.QListView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List'),
-    "PySide2.QtWidgets.QListView.doItemsLayout": (),
-    "PySide2.QtWidgets.QListView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QListView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QListView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListView.flow": (),
-    "PySide2.QtWidgets.QListView.gridSize": (),
-    "PySide2.QtWidgets.QListView.horizontalOffset": (),
-    "PySide2.QtWidgets.QListView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QListView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QListView.isSelectionRectVisible": (),
-    "PySide2.QtWidgets.QListView.isWrapping": (),
-    "PySide2.QtWidgets.QListView.itemAlignment": (),
-    "PySide2.QtWidgets.QListView.layoutMode": (),
-    "PySide2.QtWidgets.QListView.modelColumn": (),
-    "PySide2.QtWidgets.QListView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QListView.movement": (),
-    "PySide2.QtWidgets.QListView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QListView.rectForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.reset": (),
-    "PySide2.QtWidgets.QListView.resizeContents": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QListView.resizeMode": (),
-    "PySide2.QtWidgets.QListView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListView.selectedIndexes": (),
-    "PySide2.QtWidgets.QListView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QListView.setBatchSize": ('int',),
-    "PySide2.QtWidgets.QListView.setFlow": ('PySide2.QtWidgets.QListView.Flow',),
-    "PySide2.QtWidgets.QListView.setGridSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListView.setItemAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QListView.setLayoutMode": ('PySide2.QtWidgets.QListView.LayoutMode',),
-    "PySide2.QtWidgets.QListView.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QListView.setMovement": ('PySide2.QtWidgets.QListView.Movement',),
-    "PySide2.QtWidgets.QListView.setPositionForIndex": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.setResizeMode": ('PySide2.QtWidgets.QListView.ResizeMode',),
-    "PySide2.QtWidgets.QListView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QListView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QListView.setSelectionRectVisible": ('bool',),
-    "PySide2.QtWidgets.QListView.setSpacing": ('int',),
-    "PySide2.QtWidgets.QListView.setUniformItemSizes": ('bool',),
-    "PySide2.QtWidgets.QListView.setViewMode": ('PySide2.QtWidgets.QListView.ViewMode',),
-    "PySide2.QtWidgets.QListView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QListView.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QListView.spacing": (),
-    "PySide2.QtWidgets.QListView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QListView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QListView.uniformItemSizes": (),
-    "PySide2.QtWidgets.QListView.updateGeometries": (),
-    "PySide2.QtWidgets.QListView.verticalOffset": (),
-    "PySide2.QtWidgets.QListView.viewMode": (),
-    "PySide2.QtWidgets.QListView.viewOptions": (),
-    "PySide2.QtWidgets.QListView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QListView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QListView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QListView.wordWrap": (),
-# class PySide2.QtWidgets.QListWidget:
-    "PySide2.QtWidgets.QListWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListWidget.addItem": [('PySide2.QtWidgets.QListWidgetItem',), ('str',)],
-    "PySide2.QtWidgets.QListWidget.addItems": ('typing.Sequence',),
-    "PySide2.QtWidgets.QListWidget.clear": (),
-    "PySide2.QtWidgets.QListWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.count": (),
-    "PySide2.QtWidgets.QListWidget.currentItem": (),
-    "PySide2.QtWidgets.QListWidget.currentRow": (),
-    "PySide2.QtWidgets.QListWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListWidget.dropMimeData": ('int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QListWidget.editItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QListWidget.indexFromItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.insertItem": [('int', 'PySide2.QtWidgets.QListWidgetItem'), ('int', 'str')],
-    "PySide2.QtWidgets.QListWidget.insertItems": ('int', 'typing.Sequence'),
-    "PySide2.QtWidgets.QListWidget.isItemHidden": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isItemSelected": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QListWidget.item": ('int',),
-    "PySide2.QtWidgets.QListWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QListWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListWidget.itemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QListWidget.mimeData": ('typing.Sequence',),
-    "PySide2.QtWidgets.QListWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QListWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.removeItemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.row": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.scrollToItem": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListWidget.selectedItems": (),
-    "PySide2.QtWidgets.QListWidget.setCurrentItem": [('PySide2.QtWidgets.QListWidgetItem',), ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setCurrentRow": [('int',), ('int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setItemHidden": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemSelected": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemWidget": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QListWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QListWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QListWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QListWidget.sortItems": ('PySide2.QtCore.Qt.SortOrder',),
-    "PySide2.QtWidgets.QListWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QListWidget.takeItem": ('int',),
-    "PySide2.QtWidgets.QListWidget.visualItemRect": ('PySide2.QtWidgets.QListWidgetItem',),
-# class PySide2.QtWidgets.QListWidgetItem:
-# class PySide2.QtWidgets.QListWidgetItem.ItemType:
-    "PySide2.QtWidgets.QListWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidgetItem',), ('str', 'PySide2.QtWidgets.QListWidget', 'int')],
-    "PySide2.QtWidgets.QListWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.background": (),
-    "PySide2.QtWidgets.QListWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QListWidgetItem.clone": (),
-    "PySide2.QtWidgets.QListWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.flags": (),
-    "PySide2.QtWidgets.QListWidgetItem.font": (),
-    "PySide2.QtWidgets.QListWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QListWidgetItem.icon": (),
-    "PySide2.QtWidgets.QListWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QListWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QListWidgetItem.listWidget": (),
-    "PySide2.QtWidgets.QListWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QListWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QListWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QListWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QListWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QListWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QListWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.text": (),
-    "PySide2.QtWidgets.QListWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QListWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.type": (),
-    "PySide2.QtWidgets.QListWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QListWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QMainWindow:
-# class PySide2.QtWidgets.QMainWindow.DockOption:
-# class PySide2.QtWidgets.QMainWindow.DockOptions:
-    "PySide2.QtWidgets.QMainWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMainWindow.addDockWidget": [('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget'), ('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtWidgets.QMainWindow.addToolBar": [('PySide2.QtCore.Qt.ToolBarArea', 'PySide2.QtWidgets.QToolBar'), ('PySide2.QtWidgets.QToolBar',), ('str',)],
-    "PySide2.QtWidgets.QMainWindow.addToolBarBreak": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QMainWindow.centralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMainWindow.corner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMainWindow.createPopupMenu": (),
-    "PySide2.QtWidgets.QMainWindow.dockOptions": (),
-    "PySide2.QtWidgets.QMainWindow.dockWidgetArea": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.documentMode": (),
-    "PySide2.QtWidgets.QMainWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMainWindow.iconSize": (),
-    "PySide2.QtWidgets.QMainWindow.insertToolBar": ('PySide2.QtWidgets.QToolBar', 'PySide2.QtWidgets.QToolBar'),
-    "PySide2.QtWidgets.QMainWindow.insertToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.isAnimated": (),
-    "PySide2.QtWidgets.QMainWindow.isDockNestingEnabled": (),
-    "PySide2.QtWidgets.QMainWindow.isSeparator": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMainWindow.menuBar": (),
-    "PySide2.QtWidgets.QMainWindow.menuWidget": (),
-    "PySide2.QtWidgets.QMainWindow.removeDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBar": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.resizeDocks": ('typing.Sequence', 'typing.Sequence', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.restoreDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.restoreState": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QMainWindow.saveState": ('int',),
-    "PySide2.QtWidgets.QMainWindow.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setCentralWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setCorner": ('PySide2.QtCore.Qt.Corner', 'PySide2.QtCore.Qt.DockWidgetArea'),
-    "PySide2.QtWidgets.QMainWindow.setDockNestingEnabled": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setDockOptions": ('PySide2.QtWidgets.QMainWindow.DockOptions',),
-    "PySide2.QtWidgets.QMainWindow.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QMainWindow.setMenuBar": ('PySide2.QtWidgets.QMenuBar',),
-    "PySide2.QtWidgets.QMainWindow.setMenuWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setStatusBar": ('PySide2.QtWidgets.QStatusBar',),
-    "PySide2.QtWidgets.QMainWindow.setTabPosition": ('PySide2.QtCore.Qt.DockWidgetAreas', 'PySide2.QtWidgets.QTabWidget.TabPosition'),
-    "PySide2.QtWidgets.QMainWindow.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMainWindow.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QMainWindow.setUnifiedTitleAndToolBarOnMac": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.splitDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.statusBar": (),
-    "PySide2.QtWidgets.QMainWindow.tabPosition": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QMainWindow.tabShape": (),
-    "PySide2.QtWidgets.QMainWindow.tabifiedDockWidgets": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.tabifyDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget'),
-    "PySide2.QtWidgets.QMainWindow.takeCentralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.toolBarArea": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolButtonStyle": (),
-    "PySide2.QtWidgets.QMainWindow.unifiedTitleAndToolBarOnMac": (),
-# class PySide2.QtWidgets.QMdiArea:
-# class PySide2.QtWidgets.QMdiArea.AreaOption:
-# class PySide2.QtWidgets.QMdiArea.AreaOptions:
-# class PySide2.QtWidgets.QMdiArea.ViewMode:
-# class PySide2.QtWidgets.QMdiArea.WindowOrder:
-    "PySide2.QtWidgets.QMdiArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.activateNextSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activatePreviousSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activationOrder": (),
-    "PySide2.QtWidgets.QMdiArea.activeSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.addSubWindow": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiArea.background": (),
-    "PySide2.QtWidgets.QMdiArea.cascadeSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiArea.closeActiveSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.closeAllSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.currentSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.documentMode": (),
-    "PySide2.QtWidgets.QMdiArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiArea.removeSubWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QMdiArea.setActivationOrder": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.setActiveSubWindow": ('PySide2.QtWidgets.QMdiSubWindow',),
-    "PySide2.QtWidgets.QMdiArea.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QMdiArea.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setOption": ('PySide2.QtWidgets.QMdiArea.AreaOption', 'bool'),
-    "PySide2.QtWidgets.QMdiArea.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QMdiArea.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMdiArea.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setTabsMovable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setViewMode": ('PySide2.QtWidgets.QMdiArea.ViewMode',),
-    "PySide2.QtWidgets.QMdiArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiArea.sizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.subWindowList": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.tabPosition": (),
-    "PySide2.QtWidgets.QMdiArea.tabShape": (),
-    "PySide2.QtWidgets.QMdiArea.tabsClosable": (),
-    "PySide2.QtWidgets.QMdiArea.tabsMovable": (),
-    "PySide2.QtWidgets.QMdiArea.testOption": ('PySide2.QtWidgets.QMdiArea.AreaOption',),
-    "PySide2.QtWidgets.QMdiArea.tileSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiArea.viewMode": (),
-    "PySide2.QtWidgets.QMdiArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QMdiSubWindow:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOption:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOptions:
-    "PySide2.QtWidgets.QMdiSubWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiSubWindow.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiSubWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.isShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardPageStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardSingleStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedButtonsWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedSystemMenuIconWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mdiArea": (),
-    "PySide2.QtWidgets.QMdiSubWindow.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardPageStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardSingleStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption', 'bool'),
-    "PySide2.QtWidgets.QMdiSubWindow.setSystemMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QMdiSubWindow.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiSubWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.showShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.showSystemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.sizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.systemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.testOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption',),
-    "PySide2.QtWidgets.QMdiSubWindow.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.widget": (),
-# class PySide2.QtWidgets.QMenu:
-    "PySide2.QtWidgets.QMenu.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenu.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenu.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.activeAction": (),
-    "PySide2.QtWidgets.QMenu.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtGui.QIcon', 'str', 'object', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtGui.QKeySequence'), ('str', 'object', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtWidgets.QMenu.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSection": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSeparator": (),
-    "PySide2.QtWidgets.QMenu.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.clear": (),
-    "PySide2.QtWidgets.QMenu.columnCount": (),
-    "PySide2.QtWidgets.QMenu.defaultAction": (),
-    "PySide2.QtWidgets.QMenu.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.exec_": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'), ('typing.Sequence', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QMenu.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMenu.hideTearOffMenu": (),
-    "PySide2.QtWidgets.QMenu.icon": (),
-    "PySide2.QtWidgets.QMenu.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenu.insertSection": [('PySide2.QtWidgets.QAction', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction', 'str')],
-    "PySide2.QtWidgets.QMenu.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.isEmpty": (),
-    "PySide2.QtWidgets.QMenu.isTearOffEnabled": (),
-    "PySide2.QtWidgets.QMenu.isTearOffMenuVisible": (),
-    "PySide2.QtWidgets.QMenu.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenu.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.menuAction": (),
-    "PySide2.QtWidgets.QMenu.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenu.popup": ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.separatorsCollapsible": (),
-    "PySide2.QtWidgets.QMenu.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QMenu.setSeparatorsCollapsible": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTearOffEnabled": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTitle": ('str',),
-    "PySide2.QtWidgets.QMenu.setToolTipsVisible": ('bool',),
-    "PySide2.QtWidgets.QMenu.showTearOffMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QMenu.sizeHint": (),
-    "PySide2.QtWidgets.QMenu.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMenu.title": (),
-    "PySide2.QtWidgets.QMenu.toolTipsVisible": (),
-    "PySide2.QtWidgets.QMenu.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QMenuBar:
-    "PySide2.QtWidgets.QMenuBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMenuBar.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenuBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenuBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.activeAction": (),
-    "PySide2.QtWidgets.QMenuBar.addAction": [('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'bytes'), ('str', 'object')],
-    "PySide2.QtWidgets.QMenuBar.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenuBar.addSeparator": (),
-    "PySide2.QtWidgets.QMenuBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.clear": (),
-    "PySide2.QtWidgets.QMenuBar.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMenuBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMenuBar.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QMenuBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenuBar.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenuBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.isDefaultUp": (),
-    "PySide2.QtWidgets.QMenuBar.isNativeMenuBar": (),
-    "PySide2.QtWidgets.QMenuBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenuBar.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenuBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMenuBar.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QMenuBar.setDefaultUp": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setNativeMenuBar": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setVisible": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.sizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QMessageBox:
-# class PySide2.QtWidgets.QMessageBox.ButtonRole:
-# class PySide2.QtWidgets.QMessageBox.Icon:
-# class PySide2.QtWidgets.QMessageBox.StandardButton:
-# class PySide2.QtWidgets.QMessageBox.StandardButtons:
-    "PySide2.QtWidgets.QMessageBox.__init__": [('PySide2.QtWidgets.QMessageBox.Icon', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QMessageBox.about": ('PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QMessageBox.aboutQt": ('PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtWidgets.QMessageBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QMessageBox.ButtonRole'), ('PySide2.QtWidgets.QMessageBox.StandardButton',), ('str', 'PySide2.QtWidgets.QMessageBox.ButtonRole')],
-    "PySide2.QtWidgets.QMessageBox.button": ('PySide2.QtWidgets.QMessageBox.StandardButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonText": ('int',),
-    "PySide2.QtWidgets.QMessageBox.buttons": (),
-    "PySide2.QtWidgets.QMessageBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.checkBox": (),
-    "PySide2.QtWidgets.QMessageBox.clickedButton": (),
-    "PySide2.QtWidgets.QMessageBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMessageBox.critical": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.defaultButton": (),
-    "PySide2.QtWidgets.QMessageBox.detailedText": (),
-    "PySide2.QtWidgets.QMessageBox.escapeButton": (),
-    "PySide2.QtWidgets.QMessageBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.icon": (),
-    "PySide2.QtWidgets.QMessageBox.iconPixmap": (),
-    "PySide2.QtWidgets.QMessageBox.information": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.informativeText": (),
-    "PySide2.QtWidgets.QMessageBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMessageBox.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QMessageBox.question": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMessageBox.setButtonText": ('int', 'str'),
-    "PySide2.QtWidgets.QMessageBox.setCheckBox": ('PySide2.QtWidgets.QCheckBox',),
-    "PySide2.QtWidgets.QMessageBox.setDefaultButton": [('PySide2.QtWidgets.QMessageBox.StandardButton',), ('PySide2.QtWidgets.QPushButton',)],
-    "PySide2.QtWidgets.QMessageBox.setDetailedText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setEscapeButton": [('PySide2.QtWidgets.QAbstractButton',), ('PySide2.QtWidgets.QMessageBox.StandardButton',)],
-    "PySide2.QtWidgets.QMessageBox.setIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.setIconPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QMessageBox.setInformativeText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setStandardButtons": ('PySide2.QtWidgets.QMessageBox.StandardButtons',),
-    "PySide2.QtWidgets.QMessageBox.setText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QMessageBox.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QMessageBox.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QMessageBox.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QMessageBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMessageBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.standardButtons": (),
-    "PySide2.QtWidgets.QMessageBox.standardIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.text": (),
-    "PySide2.QtWidgets.QMessageBox.textFormat": (),
-    "PySide2.QtWidgets.QMessageBox.textInteractionFlags": (),
-    "PySide2.QtWidgets.QMessageBox.warning": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-# class PySide2.QtWidgets.QMouseEventTransition:
-    "PySide2.QtWidgets.QMouseEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QMouseEventTransition.button": (),
-    "PySide2.QtWidgets.QMouseEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.hitTestPath": (),
-    "PySide2.QtWidgets.QMouseEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QMouseEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QMouseEventTransition.setHitTestPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QMouseEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QOpenGLWidget:
-# class PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior:
-    "PySide2.QtWidgets.QOpenGLWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QOpenGLWidget.context": (),
-    "PySide2.QtWidgets.QOpenGLWidget.defaultFramebufferObject": (),
-    "PySide2.QtWidgets.QOpenGLWidget.doneCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.format": (),
-    "PySide2.QtWidgets.QOpenGLWidget.grabFramebuffer": (),
-    "PySide2.QtWidgets.QOpenGLWidget.initializeGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.isValid": (),
-    "PySide2.QtWidgets.QOpenGLWidget.makeCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEngine": (),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtWidgets.QOpenGLWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtWidgets.QOpenGLWidget.setTextureFormat": ('int',),
-    "PySide2.QtWidgets.QOpenGLWidget.setUpdateBehavior": ('PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior',),
-    "PySide2.QtWidgets.QOpenGLWidget.textureFormat": (),
-    "PySide2.QtWidgets.QOpenGLWidget.updateBehavior": (),
-# class PySide2.QtWidgets.QPanGesture:
-    "PySide2.QtWidgets.QPanGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPanGesture.acceleration": (),
-    "PySide2.QtWidgets.QPanGesture.delta": (),
-    "PySide2.QtWidgets.QPanGesture.lastOffset": (),
-    "PySide2.QtWidgets.QPanGesture.offset": (),
-    "PySide2.QtWidgets.QPanGesture.setAcceleration": ('float',),
-    "PySide2.QtWidgets.QPanGesture.setLastOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPanGesture.setOffset": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QPinchGesture:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlag:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlags:
-    "PySide2.QtWidgets.QPinchGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPinchGesture.centerPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.changeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.lastCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.lastRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.lastScaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.rotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.scaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.setCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setLastCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setLastRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setLastScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setStartCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.startCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.totalChangeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.totalRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.totalScaleFactor": (),
-# class PySide2.QtWidgets.QPlainTextDocumentLayout:
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentSize": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.ensureBlockLayout": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.pageCount": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.requestUpdate": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.setCursorWidth": ('int',),
-# class PySide2.QtWidgets.QPlainTextEdit:
-# class PySide2.QtWidgets.QPlainTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QPlainTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPlainTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendHtml": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.backgroundVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingGeometry": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerOnScroll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.clear": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contentOffset": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.copy": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QPlainTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QPlainTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cut": (),
-    "PySide2.QtWidgets.QPlainTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.document": (),
-    "PySide2.QtWidgets.QPlainTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QPlainTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QPlainTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QPlainTextEdit.firstVisibleBlock": (),
-    "PySide2.QtWidgets.QPlainTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.getPaintContext": (),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QPlainTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QPlainTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QPlainTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QPlainTextEdit.maximumBlockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QPlainTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.paste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QPlainTextEdit.redo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QPlainTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.setBackgroundVisible": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCenterOnScroll": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setExtraSelections": ('typing.Sequence',),
-    "PySide2.QtWidgets.QPlainTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QPlainTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.setMaximumBlockCount": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QPlainTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QPlainTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.undo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QProgressBar:
-# class PySide2.QtWidgets.QProgressBar.Direction:
-    "PySide2.QtWidgets.QProgressBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QProgressBar.alignment": (),
-    "PySide2.QtWidgets.QProgressBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressBar.format": (),
-    "PySide2.QtWidgets.QProgressBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionProgressBar',),
-    "PySide2.QtWidgets.QProgressBar.invertedAppearance": (),
-    "PySide2.QtWidgets.QProgressBar.isTextVisible": (),
-    "PySide2.QtWidgets.QProgressBar.maximum": (),
-    "PySide2.QtWidgets.QProgressBar.minimum": (),
-    "PySide2.QtWidgets.QProgressBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.orientation": (),
-    "PySide2.QtWidgets.QProgressBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QProgressBar.reset": (),
-    "PySide2.QtWidgets.QProgressBar.resetFormat": (),
-    "PySide2.QtWidgets.QProgressBar.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QProgressBar.setFormat": ('str',),
-    "PySide2.QtWidgets.QProgressBar.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QProgressBar.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressBar.setTextDirection": ('PySide2.QtWidgets.QProgressBar.Direction',),
-    "PySide2.QtWidgets.QProgressBar.setTextVisible": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressBar.sizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.text": (),
-    "PySide2.QtWidgets.QProgressBar.textDirection": (),
-    "PySide2.QtWidgets.QProgressBar.value": (),
-# class PySide2.QtWidgets.QProgressDialog:
-    "PySide2.QtWidgets.QProgressDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'str', 'int', 'int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QProgressDialog.autoClose": (),
-    "PySide2.QtWidgets.QProgressDialog.autoReset": (),
-    "PySide2.QtWidgets.QProgressDialog.cancel": (),
-    "PySide2.QtWidgets.QProgressDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QProgressDialog.forceShow": (),
-    "PySide2.QtWidgets.QProgressDialog.labelText": (),
-    "PySide2.QtWidgets.QProgressDialog.maximum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimumDuration": (),
-    "PySide2.QtWidgets.QProgressDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QProgressDialog.reset": (),
-    "PySide2.QtWidgets.QProgressDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoClose": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoReset": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setBar": ('PySide2.QtWidgets.QProgressBar',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButton": ('PySide2.QtWidgets.QPushButton',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setLabel": ('PySide2.QtWidgets.QLabel',),
-    "PySide2.QtWidgets.QProgressDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimumDuration": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressDialog.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QProgressDialog.sizeHint": (),
-    "PySide2.QtWidgets.QProgressDialog.value": (),
-    "PySide2.QtWidgets.QProgressDialog.wasCanceled": (),
-# class PySide2.QtWidgets.QProxyStyle:
-    "PySide2.QtWidgets.QProxyStyle.__init__": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QProxyStyle.baseStyle": (),
-    "PySide2.QtWidgets.QProxyStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QProxyStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProxyStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QProxyStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QProxyStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QProxyStyle.setBaseStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QProxyStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardPalette": (),
-    "PySide2.QtWidgets.QProxyStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QProxyStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QPushButton:
-    "PySide2.QtWidgets.QPushButton.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPushButton.autoDefault": (),
-    "PySide2.QtWidgets.QPushButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPushButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QPushButton.isDefault": (),
-    "PySide2.QtWidgets.QPushButton.isFlat": (),
-    "PySide2.QtWidgets.QPushButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPushButton.menu": (),
-    "PySide2.QtWidgets.QPushButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QPushButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPushButton.setAutoDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setFlat": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QPushButton.showMenu": (),
-    "PySide2.QtWidgets.QPushButton.sizeHint": (),
-# class PySide2.QtWidgets.QRadioButton:
-    "PySide2.QtWidgets.QRadioButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QRadioButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRadioButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QRadioButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QRadioButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QRadioButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QRadioButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRadioButton.sizeHint": (),
-# class PySide2.QtWidgets.QRubberBand:
-# class PySide2.QtWidgets.QRubberBand.Shape:
-    "PySide2.QtWidgets.QRubberBand.__init__": ('PySide2.QtWidgets.QRubberBand.Shape', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QRubberBand.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.initStyleOption": ('PySide2.QtWidgets.QStyleOptionRubberBand',),
-    "PySide2.QtWidgets.QRubberBand.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QRubberBand.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRubberBand.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QRubberBand.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.shape": (),
-    "PySide2.QtWidgets.QRubberBand.showEvent": ('PySide2.QtGui.QShowEvent',),
-# class PySide2.QtWidgets.QScrollArea:
-    "PySide2.QtWidgets.QScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.alignment": (),
-    "PySide2.QtWidgets.QScrollArea.ensureVisible": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.ensureWidgetVisible": ('PySide2.QtWidgets.QWidget', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QScrollArea.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QScrollArea.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.setWidgetResizable": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.takeWidget": (),
-    "PySide2.QtWidgets.QScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.widget": (),
-    "PySide2.QtWidgets.QScrollArea.widgetResizable": (),
-# class PySide2.QtWidgets.QScrollBar:
-    "PySide2.QtWidgets.QScrollBar.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QScrollBar.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QScrollBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QScrollBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QScrollBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QScrollBar.sizeHint": (),
-    "PySide2.QtWidgets.QScrollBar.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QScrollBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QScroller:
-# class PySide2.QtWidgets.QScroller.Input:
-# class PySide2.QtWidgets.QScroller.ScrollerGestureType:
-# class PySide2.QtWidgets.QScroller.State:
-    "PySide2.QtWidgets.QScroller.activeScrollers": (),
-    "PySide2.QtWidgets.QScroller.ensureVisible": [('PySide2.QtCore.QRectF', 'float', 'float'), ('PySide2.QtCore.QRectF', 'float', 'float', 'int')],
-    "PySide2.QtWidgets.QScroller.finalPosition": (),
-    "PySide2.QtWidgets.QScroller.grabGesture": ('PySide2.QtCore.QObject', 'PySide2.QtWidgets.QScroller.ScrollerGestureType'),
-    "PySide2.QtWidgets.QScroller.grabbedGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.handleInput": ('PySide2.QtWidgets.QScroller.Input', 'PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtWidgets.QScroller.hasScroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.pixelPerMeter": (),
-    "PySide2.QtWidgets.QScroller.resendPrepareEvent": (),
-    "PySide2.QtWidgets.QScroller.scrollTo": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtWidgets.QScroller.scroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.scrollerProperties": (),
-    "PySide2.QtWidgets.QScroller.setScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScroller.setSnapPositionsX": [('float', 'float'), ('typing.Sequence',)],
-    "PySide2.QtWidgets.QScroller.setSnapPositionsY": [('float', 'float'), ('typing.Sequence',)],
-    "PySide2.QtWidgets.QScroller.state": (),
-    "PySide2.QtWidgets.QScroller.stop": (),
-    "PySide2.QtWidgets.QScroller.target": (),
-    "PySide2.QtWidgets.QScroller.ungrabGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.velocity": (),
-# class PySide2.QtWidgets.QScrollerProperties:
-# class PySide2.QtWidgets.QScrollerProperties.FrameRates:
-# class PySide2.QtWidgets.QScrollerProperties.OvershootPolicy:
-# class PySide2.QtWidgets.QScrollerProperties.ScrollMetric:
-    "PySide2.QtWidgets.QScrollerProperties.__init__": [(), ('PySide2.QtWidgets.QScrollerProperties',)],
-    "PySide2.QtWidgets.QScrollerProperties.__copy__": (),
-    "PySide2.QtWidgets.QScrollerProperties.scrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric',),
-    "PySide2.QtWidgets.QScrollerProperties.setDefaultScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScrollerProperties.setScrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric', 'typing.Any'),
-    "PySide2.QtWidgets.QScrollerProperties.unsetDefaultScrollerProperties": (),
-# class PySide2.QtWidgets.QShortcut:
-    "PySide2.QtWidgets.QShortcut.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'bytes', 'bytes', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'typing.Callable', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QShortcut.autoRepeat": (),
-    "PySide2.QtWidgets.QShortcut.context": (),
-    "PySide2.QtWidgets.QShortcut.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QShortcut.id": (),
-    "PySide2.QtWidgets.QShortcut.isEnabled": (),
-    "PySide2.QtWidgets.QShortcut.key": (),
-    "PySide2.QtWidgets.QShortcut.parentWidget": (),
-    "PySide2.QtWidgets.QShortcut.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QShortcut.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setKey": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QShortcut.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QShortcut.whatsThis": (),
-# class PySide2.QtWidgets.QSizeGrip:
-    "PySide2.QtWidgets.QSizeGrip.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSizeGrip.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSizeGrip.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QSizeGrip.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QSizeGrip.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSizeGrip.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSizeGrip.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QSizeGrip.sizeHint": (),
-# class PySide2.QtWidgets.QSizePolicy:
-# class PySide2.QtWidgets.QSizePolicy.ControlType:
-# class PySide2.QtWidgets.QSizePolicy.ControlTypes:
-# class PySide2.QtWidgets.QSizePolicy.Policy:
-# class PySide2.QtWidgets.QSizePolicy.PolicyFlag:
-    "PySide2.QtWidgets.QSizePolicy.__init__": [(), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QSizePolicy.__copy__": (),
-    "PySide2.QtWidgets.QSizePolicy.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.controlType": (),
-    "PySide2.QtWidgets.QSizePolicy.expandingDirections": (),
-    "PySide2.QtWidgets.QSizePolicy.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QSizePolicy.hasWidthForHeight": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalStretch": (),
-    "PySide2.QtWidgets.QSizePolicy.retainSizeWhenHidden": (),
-    "PySide2.QtWidgets.QSizePolicy.setControlType": ('PySide2.QtWidgets.QSizePolicy.ControlType',),
-    "PySide2.QtWidgets.QSizePolicy.setHeightForWidth": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setRetainSizeWhenHidden": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setWidthForHeight": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.transpose": (),
-    "PySide2.QtWidgets.QSizePolicy.transposed": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalStretch": (),
-# class PySide2.QtWidgets.QSlider:
-# class PySide2.QtWidgets.QSlider.TickPosition:
-    "PySide2.QtWidgets.QSlider.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSlider.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QSlider.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSlider.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSlider.setTickInterval": ('int',),
-    "PySide2.QtWidgets.QSlider.setTickPosition": ('PySide2.QtWidgets.QSlider.TickPosition',),
-    "PySide2.QtWidgets.QSlider.sizeHint": (),
-    "PySide2.QtWidgets.QSlider.tickInterval": (),
-    "PySide2.QtWidgets.QSlider.tickPosition": (),
-# class PySide2.QtWidgets.QSpacerItem:
-    "PySide2.QtWidgets.QSpacerItem.__init__": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.changeSize": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.expandingDirections": (),
-    "PySide2.QtWidgets.QSpacerItem.geometry": (),
-    "PySide2.QtWidgets.QSpacerItem.isEmpty": (),
-    "PySide2.QtWidgets.QSpacerItem.maximumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.minimumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QSpacerItem.sizeHint": (),
-    "PySide2.QtWidgets.QSpacerItem.sizePolicy": (),
-    "PySide2.QtWidgets.QSpacerItem.spacerItem": (),
-# class PySide2.QtWidgets.QSpinBox:
-    "PySide2.QtWidgets.QSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QSpinBox.displayIntegerBase": (),
-    "PySide2.QtWidgets.QSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QSpinBox.maximum": (),
-    "PySide2.QtWidgets.QSpinBox.minimum": (),
-    "PySide2.QtWidgets.QSpinBox.prefix": (),
-    "PySide2.QtWidgets.QSpinBox.setDisplayIntegerBase": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMaximum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMinimum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QSpinBox.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QSpinBox.stepType": (),
-    "PySide2.QtWidgets.QSpinBox.suffix": (),
-    "PySide2.QtWidgets.QSpinBox.textFromValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QSpinBox.value": (),
-    "PySide2.QtWidgets.QSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QSplashScreen:
-    "PySide2.QtWidgets.QSplashScreen.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QSplashScreen.clearMessage": (),
-    "PySide2.QtWidgets.QSplashScreen.drawContents": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QSplashScreen.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplashScreen.finish": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplashScreen.message": (),
-    "PySide2.QtWidgets.QSplashScreen.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplashScreen.pixmap": (),
-    "PySide2.QtWidgets.QSplashScreen.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QSplashScreen.showMessage": ('str', 'int', 'PySide2.QtGui.QColor'),
-# class PySide2.QtWidgets.QSplitter:
-    "PySide2.QtWidgets.QSplitter.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSplitter.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.__rshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QSplitter.childrenCollapsible": (),
-    "PySide2.QtWidgets.QSplitter.closestLegalPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.count": (),
-    "PySide2.QtWidgets.QSplitter.createHandle": (),
-    "PySide2.QtWidgets.QSplitter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.getRange": ('int',),
-    "PySide2.QtWidgets.QSplitter.handle": ('int',),
-    "PySide2.QtWidgets.QSplitter.handleWidth": (),
-    "PySide2.QtWidgets.QSplitter.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.isCollapsible": ('int',),
-    "PySide2.QtWidgets.QSplitter.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSplitter.moveSplitter": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitter.orientation": (),
-    "PySide2.QtWidgets.QSplitter.refresh": (),
-    "PySide2.QtWidgets.QSplitter.replaceWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitter.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QSplitter.saveState": (),
-    "PySide2.QtWidgets.QSplitter.setChildrenCollapsible": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setCollapsible": ('int', 'bool'),
-    "PySide2.QtWidgets.QSplitter.setHandleWidth": ('int',),
-    "PySide2.QtWidgets.QSplitter.setOpaqueResize": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitter.setRubberBand": ('int',),
-    "PySide2.QtWidgets.QSplitter.setSizes": ('typing.Sequence',),
-    "PySide2.QtWidgets.QSplitter.setStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.sizeHint": (),
-    "PySide2.QtWidgets.QSplitter.sizes": (),
-    "PySide2.QtWidgets.QSplitter.widget": ('int',),
-# class PySide2.QtWidgets.QSplitterHandle:
-    "PySide2.QtWidgets.QSplitterHandle.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QSplitter'),
-    "PySide2.QtWidgets.QSplitterHandle.closestLegalPosition": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.moveSplitter": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitterHandle.orientation": (),
-    "PySide2.QtWidgets.QSplitterHandle.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitterHandle.sizeHint": (),
-    "PySide2.QtWidgets.QSplitterHandle.splitter": (),
-# class PySide2.QtWidgets.QStackedLayout:
-# class PySide2.QtWidgets.QStackedLayout.StackingMode:
-    "PySide2.QtWidgets.QStackedLayout.__init__": [(), ('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStackedLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QStackedLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.count": (),
-    "PySide2.QtWidgets.QStackedLayout.currentIndex": (),
-    "PySide2.QtWidgets.QStackedLayout.currentWidget": (),
-    "PySide2.QtWidgets.QStackedLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QStackedLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.minimumSize": (),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QStackedLayout.setStackingMode": ('PySide2.QtWidgets.QStackedLayout.StackingMode',),
-    "PySide2.QtWidgets.QStackedLayout.sizeHint": (),
-    "PySide2.QtWidgets.QStackedLayout.stackingMode": (),
-    "PySide2.QtWidgets.QStackedLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.widget": [(), ('int',)],
-# class PySide2.QtWidgets.QStackedWidget:
-    "PySide2.QtWidgets.QStackedWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.count": (),
-    "PySide2.QtWidgets.QStackedWidget.currentIndex": (),
-    "PySide2.QtWidgets.QStackedWidget.currentWidget": (),
-    "PySide2.QtWidgets.QStackedWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStackedWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedWidget.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.widget": ('int',),
-# class PySide2.QtWidgets.QStatusBar:
-    "PySide2.QtWidgets.QStatusBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.addPermanentWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.addWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.clearMessage": (),
-    "PySide2.QtWidgets.QStatusBar.currentMessage": (),
-    "PySide2.QtWidgets.QStatusBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStatusBar.hideOrShow": (),
-    "PySide2.QtWidgets.QStatusBar.insertPermanentWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QStatusBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QStatusBar.reformat": (),
-    "PySide2.QtWidgets.QStatusBar.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QStatusBar.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QStatusBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QStatusBar.showMessage": ('str', 'int'),
-# class PySide2.QtWidgets.QStyle:
-# class PySide2.QtWidgets.QStyle.ComplexControl:
-# class PySide2.QtWidgets.QStyle.ContentsType:
-# class PySide2.QtWidgets.QStyle.ControlElement:
-# class PySide2.QtWidgets.QStyle.PixelMetric:
-# class PySide2.QtWidgets.QStyle.PrimitiveElement:
-# class PySide2.QtWidgets.QStyle.RequestSoftwareInputPanel:
-# class PySide2.QtWidgets.QStyle.StandardPixmap:
-# class PySide2.QtWidgets.QStyle.State:
-# class PySide2.QtWidgets.QStyle.StateFlag:
-# class PySide2.QtWidgets.QStyle.StyleHint:
-# class PySide2.QtWidgets.QStyle.SubControl:
-# class PySide2.QtWidgets.QStyle.SubControls:
-# class PySide2.QtWidgets.QStyle.SubElement:
-    "PySide2.QtWidgets.QStyle.__init__": (),
-    "PySide2.QtWidgets.QStyle.alignedRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QStyle.combinedLayoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.proxy": (),
-    "PySide2.QtWidgets.QStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.sliderPositionFromValue": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.sliderValueFromPosition": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.standardPalette": (),
-    "PySide2.QtWidgets.QStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.visualAlignment": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QStyle.visualPos": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QStyle.visualRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QRect'),
-# class PySide2.QtWidgets.QStyleFactory:
-    "PySide2.QtWidgets.QStyleFactory.__init__": (),
-    "PySide2.QtWidgets.QStyleFactory.create": ('str',),
-    "PySide2.QtWidgets.QStyleFactory.keys": (),
-# class PySide2.QtWidgets.QStyleHintReturn:
-# class PySide2.QtWidgets.QStyleHintReturn.HintReturnType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturn.__init__": ('int', 'int'),
-# class PySide2.QtWidgets.QStyleHintReturnMask:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnMask.__init__": (),
-# class PySide2.QtWidgets.QStyleHintReturnVariant:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnVariant.__init__": (),
-# class PySide2.QtWidgets.QStyleOption:
-# class PySide2.QtWidgets.QStyleOption.OptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOption.__init__": [('PySide2.QtWidgets.QStyleOption',), ('int', 'int')],
-    "PySide2.QtWidgets.QStyleOption.init": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStyleOption.initFrom": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QStyleOptionButton:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeatures:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComboBox:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComboBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionComboBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComplex:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComplex.__init__": [('PySide2.QtWidgets.QStyleOptionComplex',), ('int', 'int')],
-# class PySide2.QtWidgets.QStyleOptionDockWidget:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionDockWidget.__init__": [(), ('PySide2.QtWidgets.QStyleOptionDockWidget',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFocusRect:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFocusRect.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFocusRect',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFrame:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeature:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeatures:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGraphicsItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.levelOfDetailFromTransform": ('PySide2.QtGui.QTransform',),
-# class PySide2.QtWidgets.QStyleOptionGroupBox:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGroupBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGroupBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionHeader:
-# class PySide2.QtWidgets.QStyleOptionHeader.SectionPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SortIndicator:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionHeader.__init__": [(), ('PySide2.QtWidgets.QStyleOptionHeader',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionMenuItem:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.CheckType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.MenuItemType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionMenuItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionMenuItem',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionProgressBar:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionProgressBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionProgressBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionRubberBand:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionRubberBand.__init__": [(), ('PySide2.QtWidgets.QStyleOptionRubberBand',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSizeGrip:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSizeGrip.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSizeGrip',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSlider:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSlider.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSlider',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSpinBox:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSpinBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSpinBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTab:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidget:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidgets:
-# class PySide2.QtWidgets.QStyleOptionTab.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeature:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeatures:
-# class PySide2.QtWidgets.QStyleOptionTab.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionTab.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTab',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabBarBase:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabBarBase.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabBarBase',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabWidgetFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTitleBar:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTitleBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTitleBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBar:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeature:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeatures:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBox:
-# class PySide2.QtWidgets.QStyleOptionToolBox.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBox.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolButton:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeatures:
-    "PySide2.QtWidgets.QStyleOptionToolButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionViewItem:
-# class PySide2.QtWidgets.QStyleOptionViewItem.Position:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeature:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeatures:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemPosition:
-    "PySide2.QtWidgets.QStyleOptionViewItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionViewItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionViewItem.__copy__": (),
-# class PySide2.QtWidgets.QStylePainter:
-    "PySide2.QtWidgets.QStylePainter.__init__": [(), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.begin": [('PySide2.QtGui.QPaintDevice',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex'),
-    "PySide2.QtWidgets.QStylePainter.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.drawItemPixmap": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStylePainter.drawItemText": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStylePainter.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.style": (),
-# class PySide2.QtWidgets.QStyledItemDelegate:
-    "PySide2.QtWidgets.QStyledItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QStyledItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.displayText": ('typing.Any', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtWidgets.QStyledItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QStyledItemDelegate.initStyleOption": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QStyledItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QStyledItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QSwipeGesture:
-# class PySide2.QtWidgets.QSwipeGesture.SwipeDirection:
-    "PySide2.QtWidgets.QSwipeGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QSwipeGesture.horizontalDirection": (),
-    "PySide2.QtWidgets.QSwipeGesture.setSwipeAngle": ('float',),
-    "PySide2.QtWidgets.QSwipeGesture.swipeAngle": (),
-    "PySide2.QtWidgets.QSwipeGesture.verticalDirection": (),
-# class PySide2.QtWidgets.QSystemTrayIcon:
-# class PySide2.QtWidgets.QSystemTrayIcon.ActivationReason:
-# class PySide2.QtWidgets.QSystemTrayIcon.MessageIcon:
-    "PySide2.QtWidgets.QSystemTrayIcon.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QSystemTrayIcon.contextMenu": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSystemTrayIcon.geometry": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.hide": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.icon": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isSystemTrayAvailable": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isVisible": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.setContextMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setToolTip": ('str',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSystemTrayIcon.show": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.showMessage": [('str', 'str', 'PySide2.QtGui.QIcon', 'int'), ('str', 'str', 'PySide2.QtWidgets.QSystemTrayIcon.MessageIcon', 'int')],
-    "PySide2.QtWidgets.QSystemTrayIcon.supportsMessages": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.toolTip": (),
-# class PySide2.QtWidgets.QTabBar:
-# class PySide2.QtWidgets.QTabBar.ButtonPosition:
-# class PySide2.QtWidgets.QTabBar.SelectionBehavior:
-# class PySide2.QtWidgets.QTabBar.Shape:
-    "PySide2.QtWidgets.QTabBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabBar.accessibleTabName": ('int',),
-    "PySide2.QtWidgets.QTabBar.addTab": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QTabBar.autoHide": (),
-    "PySide2.QtWidgets.QTabBar.changeCurrentOnDrag": (),
-    "PySide2.QtWidgets.QTabBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.count": (),
-    "PySide2.QtWidgets.QTabBar.currentIndex": (),
-    "PySide2.QtWidgets.QTabBar.documentMode": (),
-    "PySide2.QtWidgets.QTabBar.drawBase": (),
-    "PySide2.QtWidgets.QTabBar.elideMode": (),
-    "PySide2.QtWidgets.QTabBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.expanding": (),
-    "PySide2.QtWidgets.QTabBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QTabBar.iconSize": (),
-    "PySide2.QtWidgets.QTabBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTab', 'int'),
-    "PySide2.QtWidgets.QTabBar.insertTab": [('int', 'PySide2.QtGui.QIcon', 'str'), ('int', 'str')],
-    "PySide2.QtWidgets.QTabBar.isMovable": (),
-    "PySide2.QtWidgets.QTabBar.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabBar.minimumTabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.moveTab": ('int', 'int'),
-    "PySide2.QtWidgets.QTabBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabBar.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabBar.selectionBehaviorOnRemove": (),
-    "PySide2.QtWidgets.QTabBar.setAccessibleTabName": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setChangeCurrentOnDrag": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabBar.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setDrawBase": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabBar.setExpanding": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setSelectionBehaviorOnRemove": ('PySide2.QtWidgets.QTabBar.SelectionBehavior',),
-    "PySide2.QtWidgets.QTabBar.setShape": ('PySide2.QtWidgets.QTabBar.Shape',),
-    "PySide2.QtWidgets.QTabBar.setTabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTabBar.setTabData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTabBar.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabBar.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabBar.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTabBar.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabBar.shape": (),
-    "PySide2.QtWidgets.QTabBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabBar.sizeHint": (),
-    "PySide2.QtWidgets.QTabBar.tabAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTabBar.tabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition'),
-    "PySide2.QtWidgets.QTabBar.tabData": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabLayoutChange": (),
-    "PySide2.QtWidgets.QTabBar.tabRect": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabText": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabTextColor": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabsClosable": (),
-    "PySide2.QtWidgets.QTabBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTabBar.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QTabWidget:
-# class PySide2.QtWidgets.QTabWidget.TabPosition:
-# class PySide2.QtWidgets.QTabWidget.TabShape:
-    "PySide2.QtWidgets.QTabWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.addTab": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.clear": (),
-    "PySide2.QtWidgets.QTabWidget.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QTabWidget.count": (),
-    "PySide2.QtWidgets.QTabWidget.currentIndex": (),
-    "PySide2.QtWidgets.QTabWidget.currentWidget": (),
-    "PySide2.QtWidgets.QTabWidget.documentMode": (),
-    "PySide2.QtWidgets.QTabWidget.elideMode": (),
-    "PySide2.QtWidgets.QTabWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QTabWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QTabWidget.iconSize": (),
-    "PySide2.QtWidgets.QTabWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',),
-    "PySide2.QtWidgets.QTabWidget.insertTab": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.isMovable": (),
-    "PySide2.QtWidgets.QTabWidget.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabWidget.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabWidget.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QTabWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabWidget.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabWidget.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabBar": ('PySide2.QtWidgets.QTabBar',),
-    "PySide2.QtWidgets.QTabWidget.setTabBarAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabWidget.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabWidget.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QTabWidget.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QTabWidget.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabWidget.sizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.tabBar": (),
-    "PySide2.QtWidgets.QTabWidget.tabBarAutoHide": (),
-    "PySide2.QtWidgets.QTabWidget.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabPosition": (),
-    "PySide2.QtWidgets.QTabWidget.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabShape": (),
-    "PySide2.QtWidgets.QTabWidget.tabText": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabsClosable": (),
-    "PySide2.QtWidgets.QTabWidget.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabWidget.widget": ('int',),
-# class PySide2.QtWidgets.QTableView:
-    "PySide2.QtWidgets.QTableView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTableView.clearSpans": (),
-    "PySide2.QtWidgets.QTableView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTableView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTableView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTableView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTableView.gridStyle": (),
-    "PySide2.QtWidgets.QTableView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.hideRow": ('int',),
-    "PySide2.QtWidgets.QTableView.horizontalHeader": (),
-    "PySide2.QtWidgets.QTableView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTableView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTableView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isCornerButtonEnabled": (),
-    "PySide2.QtWidgets.QTableView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTableView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTableView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeColumnsToContents": (),
-    "PySide2.QtWidgets.QTableView.resizeRowToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeRowsToContents": (),
-    "PySide2.QtWidgets.QTableView.rowAt": ('int',),
-    "PySide2.QtWidgets.QTableView.rowCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowHeight": ('int',),
-    "PySide2.QtWidgets.QTableView.rowMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableView.selectColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.selectRow": ('int',),
-    "PySide2.QtWidgets.QTableView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTableView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTableView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setCornerButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setGridStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtWidgets.QTableView.setHorizontalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.setRowHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTableView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTableView.setShowGrid": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSpan": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.setVerticalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTableView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.showGrid": (),
-    "PySide2.QtWidgets.QTableView.showRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTableView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTableView.updateGeometries": (),
-    "PySide2.QtWidgets.QTableView.verticalHeader": (),
-    "PySide2.QtWidgets.QTableView.verticalOffset": (),
-    "PySide2.QtWidgets.QTableView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.viewOptions": (),
-    "PySide2.QtWidgets.QTableView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTableView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTableView.wordWrap": (),
-# class PySide2.QtWidgets.QTableWidget:
-    "PySide2.QtWidgets.QTableWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTableWidget.cellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.clear": (),
-    "PySide2.QtWidgets.QTableWidget.clearContents": (),
-    "PySide2.QtWidgets.QTableWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.column": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.columnCount": (),
-    "PySide2.QtWidgets.QTableWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTableWidget.currentItem": (),
-    "PySide2.QtWidgets.QTableWidget.currentRow": (),
-    "PySide2.QtWidgets.QTableWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTableWidget.dropMimeData": ('int', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTableWidget.editItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTableWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QTableWidget.horizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.indexFromItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.insertColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.insertRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.isItemSelected": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableWidget.item": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTableWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableWidget.itemPrototype": (),
-    "PySide2.QtWidgets.QTableWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTableWidget.mimeData": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTableWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTableWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.removeCellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.removeColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.removeRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.row": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.rowCount": (),
-    "PySide2.QtWidgets.QTableWidget.scrollToItem": ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTableWidget.selectedRanges": (),
-    "PySide2.QtWidgets.QTableWidget.setCellWidget": ('int', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTableWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setCurrentCell": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setCurrentItem": [('PySide2.QtWidgets.QTableWidgetItem',), ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderLabels": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTableWidget.setItem": ('int', 'int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setItemPrototype": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.setItemSelected": ('PySide2.QtWidgets.QTableWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableWidget.setRangeSelected": ('PySide2.QtWidgets.QTableWidgetSelectionRange', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setRowCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderLabels": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTableWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTableWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTableWidget.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.takeItem": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.verticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualItemRect": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.visualRow": ('int',),
-# class PySide2.QtWidgets.QTableWidgetItem:
-# class PySide2.QtWidgets.QTableWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTableWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'int'), ('PySide2.QtWidgets.QTableWidgetItem',), ('int',), ('str', 'int')],
-    "PySide2.QtWidgets.QTableWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.background": (),
-    "PySide2.QtWidgets.QTableWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QTableWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTableWidgetItem.column": (),
-    "PySide2.QtWidgets.QTableWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTableWidgetItem.font": (),
-    "PySide2.QtWidgets.QTableWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QTableWidgetItem.icon": (),
-    "PySide2.QtWidgets.QTableWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTableWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.row": (),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QTableWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTableWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTableWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTableWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTableWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QTableWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.tableWidget": (),
-    "PySide2.QtWidgets.QTableWidgetItem.text": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.type": (),
-    "PySide2.QtWidgets.QTableWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QTableWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTableWidgetSelectionRange:
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__init__": [(), ('PySide2.QtWidgets.QTableWidgetSelectionRange',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__copy__": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.bottomRow": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.columnCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.leftColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rightColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rowCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.topRow": (),
-# class PySide2.QtWidgets.QTapAndHoldGesture:
-    "PySide2.QtWidgets.QTapAndHoldGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.position": (),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setTimeout": ('int',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.timeout": (),
-# class PySide2.QtWidgets.QTapGesture:
-    "PySide2.QtWidgets.QTapGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapGesture.position": (),
-    "PySide2.QtWidgets.QTapGesture.setPosition": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QTextBrowser:
-    "PySide2.QtWidgets.QTextBrowser.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTextBrowser.backward": (),
-    "PySide2.QtWidgets.QTextBrowser.backwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.clearHistory": (),
-    "PySide2.QtWidgets.QTextBrowser.doSetSource": ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType'),
-    "PySide2.QtWidgets.QTextBrowser.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextBrowser.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextBrowser.forward": (),
-    "PySide2.QtWidgets.QTextBrowser.forwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.historyTitle": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.historyUrl": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.home": (),
-    "PySide2.QtWidgets.QTextBrowser.isBackwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.isForwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextBrowser.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextBrowser.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.openExternalLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.openLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextBrowser.reload": (),
-    "PySide2.QtWidgets.QTextBrowser.searchPaths": (),
-    "PySide2.QtWidgets.QTextBrowser.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setOpenLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setSearchPaths": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTextBrowser.setSource": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType')],
-    "PySide2.QtWidgets.QTextBrowser.source": (),
-    "PySide2.QtWidgets.QTextBrowser.sourceType": (),
-# class PySide2.QtWidgets.QTextEdit:
-# class PySide2.QtWidgets.QTextEdit.AutoFormatting:
-# class PySide2.QtWidgets.QTextEdit.AutoFormattingFlag:
-# class PySide2.QtWidgets.QTextEdit.ExtraSelection:
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__init__": [(), ('PySide2.QtWidgets.QTextEdit.ExtraSelection',)],
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__copy__": (),
-# class PySide2.QtWidgets.QTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTextEdit.acceptRichText": (),
-    "PySide2.QtWidgets.QTextEdit.alignment": (),
-    "PySide2.QtWidgets.QTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.append": ('str',),
-    "PySide2.QtWidgets.QTextEdit.autoFormatting": (),
-    "PySide2.QtWidgets.QTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.clear": (),
-    "PySide2.QtWidgets.QTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QTextEdit.copy": (),
-    "PySide2.QtWidgets.QTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QTextEdit.currentFont": (),
-    "PySide2.QtWidgets.QTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QTextEdit.cut": (),
-    "PySide2.QtWidgets.QTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.document": (),
-    "PySide2.QtWidgets.QTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.fontFamily": (),
-    "PySide2.QtWidgets.QTextEdit.fontItalic": (),
-    "PySide2.QtWidgets.QTextEdit.fontPointSize": (),
-    "PySide2.QtWidgets.QTextEdit.fontUnderline": (),
-    "PySide2.QtWidgets.QTextEdit.fontWeight": (),
-    "PySide2.QtWidgets.QTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.insertHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.lineWrapColumnOrWidth": (),
-    "PySide2.QtWidgets.QTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextEdit.paste": (),
-    "PySide2.QtWidgets.QTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QTextEdit.redo": (),
-    "PySide2.QtWidgets.QTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTextEdit.scrollToAnchor": ('str',),
-    "PySide2.QtWidgets.QTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QTextEdit.setAcceptRichText": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QTextEdit.setAutoFormatting": ('PySide2.QtWidgets.QTextEdit.AutoFormatting',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setExtraSelections": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTextEdit.setFontFamily": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setFontItalic": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontPointSize": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setFontUnderline": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontWeight": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapColumnOrWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QTextEdit.setMarkdown": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setTextBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QTextEdit.textBackgroundColor": (),
-    "PySide2.QtWidgets.QTextEdit.textColor": (),
-    "PySide2.QtWidgets.QTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTextEdit.toHtml": (),
-    "PySide2.QtWidgets.QTextEdit.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtWidgets.QTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QTextEdit.undo": (),
-    "PySide2.QtWidgets.QTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QTileRules:
-    "PySide2.QtWidgets.QTileRules.__init__": [('PySide2.QtCore.Qt.TileRule',), ('PySide2.QtCore.Qt.TileRule', 'PySide2.QtCore.Qt.TileRule'), ('PySide2.QtWidgets.QTileRules',)],
-    "PySide2.QtWidgets.QTileRules.__copy__": (),
-# class PySide2.QtWidgets.QTimeEdit:
-    "PySide2.QtWidgets.QTimeEdit.__init__": [('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QToolBar:
-    "PySide2.QtWidgets.QToolBar.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QToolBar.actionAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QToolBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtWidgets.QToolBar.addSeparator": (),
-    "PySide2.QtWidgets.QToolBar.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBar.allowedAreas": (),
-    "PySide2.QtWidgets.QToolBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.clear": (),
-    "PySide2.QtWidgets.QToolBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.iconSize": (),
-    "PySide2.QtWidgets.QToolBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolBar',),
-    "PySide2.QtWidgets.QToolBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.insertWidget": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QToolBar.isAreaAllowed": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QToolBar.isFloatable": (),
-    "PySide2.QtWidgets.QToolBar.isFloating": (),
-    "PySide2.QtWidgets.QToolBar.isMovable": (),
-    "PySide2.QtWidgets.QToolBar.orientation": (),
-    "PySide2.QtWidgets.QToolBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolBar.setAllowedAreas": ('PySide2.QtCore.Qt.ToolBarAreas',),
-    "PySide2.QtWidgets.QToolBar.setFloatable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QToolBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QToolBar.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolBar.toggleViewAction": (),
-    "PySide2.QtWidgets.QToolBar.toolButtonStyle": (),
-    "PySide2.QtWidgets.QToolBar.widgetForAction": ('PySide2.QtWidgets.QAction',),
-# class PySide2.QtWidgets.QToolBox:
-    "PySide2.QtWidgets.QToolBox.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QToolBox.addItem": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.count": (),
-    "PySide2.QtWidgets.QToolBox.currentIndex": (),
-    "PySide2.QtWidgets.QToolBox.currentWidget": (),
-    "PySide2.QtWidgets.QToolBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.insertItem": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.isItemEnabled": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemInserted": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemRemoved": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemText": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemToolTip": ('int',),
-    "PySide2.QtWidgets.QToolBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.setItemEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QToolBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QToolBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.setItemToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QToolBox.widget": ('int',),
-# class PySide2.QtWidgets.QToolButton:
-# class PySide2.QtWidgets.QToolButton.ToolButtonPopupMode:
-    "PySide2.QtWidgets.QToolButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolButton.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolButton.arrowType": (),
-    "PySide2.QtWidgets.QToolButton.autoRaise": (),
-    "PySide2.QtWidgets.QToolButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.defaultAction": (),
-    "PySide2.QtWidgets.QToolButton.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QToolButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolButton',),
-    "PySide2.QtWidgets.QToolButton.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.menu": (),
-    "PySide2.QtWidgets.QToolButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QToolButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.nextCheckState": (),
-    "PySide2.QtWidgets.QToolButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolButton.popupMode": (),
-    "PySide2.QtWidgets.QToolButton.setArrowType": ('PySide2.QtCore.Qt.ArrowType',),
-    "PySide2.QtWidgets.QToolButton.setAutoRaise": ('bool',),
-    "PySide2.QtWidgets.QToolButton.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QToolButton.setPopupMode": ('PySide2.QtWidgets.QToolButton.ToolButtonPopupMode',),
-    "PySide2.QtWidgets.QToolButton.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolButton.showMenu": (),
-    "PySide2.QtWidgets.QToolButton.sizeHint": (),
-    "PySide2.QtWidgets.QToolButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QToolButton.toolButtonStyle": (),
-# class PySide2.QtWidgets.QToolTip:
-    "PySide2.QtWidgets.QToolTip.font": (),
-    "PySide2.QtWidgets.QToolTip.hideText": (),
-    "PySide2.QtWidgets.QToolTip.isVisible": (),
-    "PySide2.QtWidgets.QToolTip.palette": (),
-    "PySide2.QtWidgets.QToolTip.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QToolTip.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QToolTip.showText": [('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect', 'int')],
-    "PySide2.QtWidgets.QToolTip.text": (),
-# class PySide2.QtWidgets.QTreeView:
-    "PySide2.QtWidgets.QTreeView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeView.allColumnsShowFocus": (),
-    "PySide2.QtWidgets.QTreeView.autoExpandDelay": (),
-    "PySide2.QtWidgets.QTreeView.collapse": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.collapseAll": (),
-    "PySide2.QtWidgets.QTreeView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnMoved": (),
-    "PySide2.QtWidgets.QTreeView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTreeView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List'),
-    "PySide2.QtWidgets.QTreeView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTreeView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTreeView.drawBranches": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawRow": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawTree": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QRegion'),
-    "PySide2.QtWidgets.QTreeView.expand": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.expandAll": (),
-    "PySide2.QtWidgets.QTreeView.expandRecursively": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QTreeView.expandToDepth": ('int',),
-    "PySide2.QtWidgets.QTreeView.expandsOnDoubleClick": (),
-    "PySide2.QtWidgets.QTreeView.header": (),
-    "PySide2.QtWidgets.QTreeView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTreeView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTreeView.indentation": (),
-    "PySide2.QtWidgets.QTreeView.indexAbove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTreeView.indexBelow": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexRowSizeHint": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isAnimated": (),
-    "PySide2.QtWidgets.QTreeView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTreeView.isExpanded": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isHeaderHidden": (),
-    "PySide2.QtWidgets.QTreeView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isRowHidden": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTreeView.itemsExpandable": (),
-    "PySide2.QtWidgets.QTreeView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTreeView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QTreeView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTreeView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTreeView.reexpand": (),
-    "PySide2.QtWidgets.QTreeView.reset": (),
-    "PySide2.QtWidgets.QTreeView.resetIndentation": (),
-    "PySide2.QtWidgets.QTreeView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTreeView.rootIsDecorated": (),
-    "PySide2.QtWidgets.QTreeView.rowHeight": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeView.selectAll": (),
-    "PySide2.QtWidgets.QTreeView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTreeView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTreeView.setAllColumnsShowFocus": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAutoExpandDelay": ('int',),
-    "PySide2.QtWidgets.QTreeView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.setExpanded": ('PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setExpandsOnDoubleClick": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTreeView.setHeaderHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setIndentation": ('int',),
-    "PySide2.QtWidgets.QTreeView.setItemsExpandable": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.setRootIsDecorated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setRowHidden": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTreeView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setTreePosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.setUniformRowHeights": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTreeView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTreeView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTreeView.treePosition": (),
-    "PySide2.QtWidgets.QTreeView.uniformRowHeights": (),
-    "PySide2.QtWidgets.QTreeView.updateGeometries": (),
-    "PySide2.QtWidgets.QTreeView.verticalOffset": (),
-    "PySide2.QtWidgets.QTreeView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QTreeView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTreeView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTreeView.wordWrap": (),
-# class PySide2.QtWidgets.QTreeWidget:
-    "PySide2.QtWidgets.QTreeWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItems": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTreeWidget.clear": (),
-    "PySide2.QtWidgets.QTreeWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.collapseItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.currentItem": (),
-    "PySide2.QtWidgets.QTreeWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTreeWidget.dropMimeData": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTreeWidget.editItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeWidget.expandItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.headerItem": (),
-    "PySide2.QtWidgets.QTreeWidget.indexFromItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.indexOfTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItem": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItems": ('int', 'typing.Sequence'),
-    "PySide2.QtWidgets.QTreeWidget.invisibleRootItem": (),
-    "PySide2.QtWidgets.QTreeWidget.isFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemAbove": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemBelow": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeWidget.itemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTreeWidget.mimeData": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTreeWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTreeWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.removeItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.scrollToItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTreeWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.setCurrentItem": [('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTreeWidget.setFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabel": ('str',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabels": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTreeWidget.setItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTreeWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeWidget.sortColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTreeWidget.takeTopLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItemCount": (),
-    "PySide2.QtWidgets.QTreeWidget.visualItemRect": ('PySide2.QtWidgets.QTreeWidgetItem',),
-# class PySide2.QtWidgets.QTreeWidgetItem:
-# class PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy:
-# class PySide2.QtWidgets.QTreeWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTreeWidgetItem.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'typing.Sequence', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'typing.Sequence', 'int'), ('int',), ('typing.Sequence', 'int')],
-    "PySide2.QtWidgets.QTreeWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChildren": ('typing.Sequence',),
-    "PySide2.QtWidgets.QTreeWidgetItem.background": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.backgroundColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.checkState": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.child": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.childCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.childIndicatorPolicy": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.data": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.emitDataChanged": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.font": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.foreground": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.icon": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.indexOfChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChild": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChildren": ('int', 'typing.Sequence'),
-    "PySide2.QtWidgets.QTreeWidgetItem.isDisabled": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isExpanded": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isFirstColumnSpanned": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.parent": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.removeChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackgroundColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setCheckState": ('int', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setChildIndicatorPolicy": ('PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setData": ('int', 'int', 'typing.Any'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setExpanded": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFirstColumnSpanned": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFont": ('int', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setForeground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSizeHint": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setStatusTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setText": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextAlignment": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.sizeHint": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidgetItem.statusTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChild": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChildren": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.text": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textAlignment": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.toolTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.treeWidget": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.type": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.whatsThis": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTreeWidgetItemIterator:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlag:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags:
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItemIterator',)],
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__copy__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iadd__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__isub__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iter__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.value": (),
-# class PySide2.QtWidgets.QUndoCommand:
-    "PySide2.QtWidgets.QUndoCommand.__init__": [('PySide2.QtWidgets.QUndoCommand',), ('str', 'PySide2.QtWidgets.QUndoCommand')],
-    "PySide2.QtWidgets.QUndoCommand.actionText": (),
-    "PySide2.QtWidgets.QUndoCommand.child": ('int',),
-    "PySide2.QtWidgets.QUndoCommand.childCount": (),
-    "PySide2.QtWidgets.QUndoCommand.id": (),
-    "PySide2.QtWidgets.QUndoCommand.isObsolete": (),
-    "PySide2.QtWidgets.QUndoCommand.mergeWith": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoCommand.redo": (),
-    "PySide2.QtWidgets.QUndoCommand.setObsolete": ('bool',),
-    "PySide2.QtWidgets.QUndoCommand.setText": ('str',),
-    "PySide2.QtWidgets.QUndoCommand.text": (),
-    "PySide2.QtWidgets.QUndoCommand.undo": (),
-# class PySide2.QtWidgets.QUndoGroup:
-    "PySide2.QtWidgets.QUndoGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoGroup.activeStack": (),
-    "PySide2.QtWidgets.QUndoGroup.addStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.canRedo": (),
-    "PySide2.QtWidgets.QUndoGroup.canUndo": (),
-    "PySide2.QtWidgets.QUndoGroup.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.isClean": (),
-    "PySide2.QtWidgets.QUndoGroup.redo": (),
-    "PySide2.QtWidgets.QUndoGroup.redoText": (),
-    "PySide2.QtWidgets.QUndoGroup.removeStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.setActiveStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.stacks": (),
-    "PySide2.QtWidgets.QUndoGroup.undo": (),
-    "PySide2.QtWidgets.QUndoGroup.undoText": (),
-# class PySide2.QtWidgets.QUndoStack:
-    "PySide2.QtWidgets.QUndoStack.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoStack.beginMacro": ('str',),
-    "PySide2.QtWidgets.QUndoStack.canRedo": (),
-    "PySide2.QtWidgets.QUndoStack.canUndo": (),
-    "PySide2.QtWidgets.QUndoStack.cleanIndex": (),
-    "PySide2.QtWidgets.QUndoStack.clear": (),
-    "PySide2.QtWidgets.QUndoStack.command": ('int',),
-    "PySide2.QtWidgets.QUndoStack.count": (),
-    "PySide2.QtWidgets.QUndoStack.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.endMacro": (),
-    "PySide2.QtWidgets.QUndoStack.index": (),
-    "PySide2.QtWidgets.QUndoStack.isActive": (),
-    "PySide2.QtWidgets.QUndoStack.isClean": (),
-    "PySide2.QtWidgets.QUndoStack.push": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoStack.redo": (),
-    "PySide2.QtWidgets.QUndoStack.redoText": (),
-    "PySide2.QtWidgets.QUndoStack.resetClean": (),
-    "PySide2.QtWidgets.QUndoStack.setActive": ('bool',),
-    "PySide2.QtWidgets.QUndoStack.setClean": (),
-    "PySide2.QtWidgets.QUndoStack.setIndex": ('int',),
-    "PySide2.QtWidgets.QUndoStack.setUndoLimit": ('int',),
-    "PySide2.QtWidgets.QUndoStack.text": ('int',),
-    "PySide2.QtWidgets.QUndoStack.undo": (),
-    "PySide2.QtWidgets.QUndoStack.undoLimit": (),
-    "PySide2.QtWidgets.QUndoStack.undoText": (),
-# class PySide2.QtWidgets.QUndoView:
-    "PySide2.QtWidgets.QUndoView.__init__": [('PySide2.QtWidgets.QUndoGroup', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QUndoStack', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QUndoView.cleanIcon": (),
-    "PySide2.QtWidgets.QUndoView.emptyLabel": (),
-    "PySide2.QtWidgets.QUndoView.group": (),
-    "PySide2.QtWidgets.QUndoView.setCleanIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QUndoView.setEmptyLabel": ('str',),
-    "PySide2.QtWidgets.QUndoView.setGroup": ('PySide2.QtWidgets.QUndoGroup',),
-    "PySide2.QtWidgets.QUndoView.setStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoView.stack": (),
-# class PySide2.QtWidgets.QVBoxLayout:
-    "PySide2.QtWidgets.QVBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QWhatsThis:
-    "PySide2.QtWidgets.QWhatsThis.createAction": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWhatsThis.enterWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.hideText": (),
-    "PySide2.QtWidgets.QWhatsThis.inWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.leaveWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.showText": ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'),
-# class PySide2.QtWidgets.QWidget:
-# class PySide2.QtWidgets.QWidget.RenderFlag:
-# class PySide2.QtWidgets.QWidget.RenderFlags:
-    "PySide2.QtWidgets.QWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.acceptDrops": (),
-    "PySide2.QtWidgets.QWidget.accessibleDescription": (),
-    "PySide2.QtWidgets.QWidget.accessibleName": (),
-    "PySide2.QtWidgets.QWidget.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QWidget.actions": (),
-    "PySide2.QtWidgets.QWidget.activateWindow": (),
-    "PySide2.QtWidgets.QWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.addActions": ('typing.Sequence',),
-    "PySide2.QtWidgets.QWidget.adjustSize": (),
-    "PySide2.QtWidgets.QWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QWidget.backgroundRole": (),
-    "PySide2.QtWidgets.QWidget.backingStore": (),
-    "PySide2.QtWidgets.QWidget.baseSize": (),
-    "PySide2.QtWidgets.QWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.childAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.childrenRect": (),
-    "PySide2.QtWidgets.QWidget.childrenRegion": (),
-    "PySide2.QtWidgets.QWidget.clearFocus": (),
-    "PySide2.QtWidgets.QWidget.clearMask": (),
-    "PySide2.QtWidgets.QWidget.close": (),
-    "PySide2.QtWidgets.QWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QWidget.contentsMargins": (),
-    "PySide2.QtWidgets.QWidget.contentsRect": (),
-    "PySide2.QtWidgets.QWidget.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QWidget.contextMenuPolicy": (),
-    "PySide2.QtWidgets.QWidget.create": ('int', 'bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.createWinId": (),
-    "PySide2.QtWidgets.QWidget.createWindowContainer": ('PySide2.QtGui.QWindow', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.cursor": (),
-    "PySide2.QtWidgets.QWidget.destroy": ('bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.devType": (),
-    "PySide2.QtWidgets.QWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QWidget.effectiveWinId": (),
-    "PySide2.QtWidgets.QWidget.ensurePolished": (),
-    "PySide2.QtWidgets.QWidget.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.find": ('int',),
-    "PySide2.QtWidgets.QWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusNextChild": (),
-    "PySide2.QtWidgets.QWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QWidget.focusPreviousChild": (),
-    "PySide2.QtWidgets.QWidget.focusProxy": (),
-    "PySide2.QtWidgets.QWidget.focusWidget": (),
-    "PySide2.QtWidgets.QWidget.font": (),
-    "PySide2.QtWidgets.QWidget.fontInfo": (),
-    "PySide2.QtWidgets.QWidget.fontMetrics": (),
-    "PySide2.QtWidgets.QWidget.foregroundRole": (),
-    "PySide2.QtWidgets.QWidget.frameGeometry": (),
-    "PySide2.QtWidgets.QWidget.frameSize": (),
-    "PySide2.QtWidgets.QWidget.geometry": (),
-    "PySide2.QtWidgets.QWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QWidget.grab": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidget.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QWidget.grabKeyboard": (),
-    "PySide2.QtWidgets.QWidget.grabMouse": [(), ('PySide2.QtGui.QCursor',)],
-    "PySide2.QtWidgets.QWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QWidget.graphicsEffect": (),
-    "PySide2.QtWidgets.QWidget.graphicsProxyWidget": (),
-    "PySide2.QtWidgets.QWidget.hasFocus": (),
-    "PySide2.QtWidgets.QWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidget.hasMouseTracking": (),
-    "PySide2.QtWidgets.QWidget.hasTabletTracking": (),
-    "PySide2.QtWidgets.QWidget.height": (),
-    "PySide2.QtWidgets.QWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.hide": (),
-    "PySide2.QtWidgets.QWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QWidget.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QWidget.inputMethodHints": (),
-    "PySide2.QtWidgets.QWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence'),
-    "PySide2.QtWidgets.QWidget.internalWinId": (),
-    "PySide2.QtWidgets.QWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QWidget.isAncestorOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabled": (),
-    "PySide2.QtWidgets.QWidget.isEnabledTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabledToTLW": (),
-    "PySide2.QtWidgets.QWidget.isFullScreen": (),
-    "PySide2.QtWidgets.QWidget.isHidden": (),
-    "PySide2.QtWidgets.QWidget.isLeftToRight": (),
-    "PySide2.QtWidgets.QWidget.isMaximized": (),
-    "PySide2.QtWidgets.QWidget.isMinimized": (),
-    "PySide2.QtWidgets.QWidget.isModal": (),
-    "PySide2.QtWidgets.QWidget.isRightToLeft": (),
-    "PySide2.QtWidgets.QWidget.isTopLevel": (),
-    "PySide2.QtWidgets.QWidget.isVisible": (),
-    "PySide2.QtWidgets.QWidget.isVisibleTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isWindow": (),
-    "PySide2.QtWidgets.QWidget.isWindowModified": (),
-    "PySide2.QtWidgets.QWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyboardGrabber": (),
-    "PySide2.QtWidgets.QWidget.layout": (),
-    "PySide2.QtWidgets.QWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QWidget.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.locale": (),
-    "PySide2.QtWidgets.QWidget.lower": (),
-    "PySide2.QtWidgets.QWidget.mapFrom": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapFromParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapTo": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapToParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mask": (),
-    "PySide2.QtWidgets.QWidget.maximumHeight": (),
-    "PySide2.QtWidgets.QWidget.maximumSize": (),
-    "PySide2.QtWidgets.QWidget.maximumWidth": (),
-    "PySide2.QtWidgets.QWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QWidget.minimumHeight": (),
-    "PySide2.QtWidgets.QWidget.minimumSize": (),
-    "PySide2.QtWidgets.QWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QWidget.minimumWidth": (),
-    "PySide2.QtWidgets.QWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseGrabber": (),
-    "PySide2.QtWidgets.QWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QWidget.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QWidget.nativeParentWidget": (),
-    "PySide2.QtWidgets.QWidget.nextInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.normalGeometry": (),
-    "PySide2.QtWidgets.QWidget.overrideWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.overrideWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.paintEngine": (),
-    "PySide2.QtWidgets.QWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWidget.palette": (),
-    "PySide2.QtWidgets.QWidget.parentWidget": (),
-    "PySide2.QtWidgets.QWidget.pos": (),
-    "PySide2.QtWidgets.QWidget.previousInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.raise_": (),
-    "PySide2.QtWidgets.QWidget.rect": (),
-    "PySide2.QtWidgets.QWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.releaseKeyboard": (),
-    "PySide2.QtWidgets.QWidget.releaseMouse": (),
-    "PySide2.QtWidgets.QWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags')],
-    "PySide2.QtWidgets.QWidget.repaint": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWidget.restoreGeometry": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QWidget.saveGeometry": (),
-    "PySide2.QtWidgets.QWidget.screen": (),
-    "PySide2.QtWidgets.QWidget.scroll": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QRect')],
-    "PySide2.QtWidgets.QWidget.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QWidget.setAccessibleDescription": ('str',),
-    "PySide2.QtWidgets.QWidget.setAccessibleName": ('str',),
-    "PySide2.QtWidgets.QWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QWidget.setBackgroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setBaseSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContextMenuPolicy": ('PySide2.QtCore.Qt.ContextMenuPolicy',),
-    "PySide2.QtWidgets.QWidget.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QWidget.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setFixedHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setFixedSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setFixedWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtWidgets.QWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QWidget.setFocusProxy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QWidget.setForegroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QWidget.setHidden": ('bool',),
-    "PySide2.QtWidgets.QWidget.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QWidget.setLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QWidget.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtWidgets.QWidget.setMask": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtWidgets.QWidget.setMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMaximumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMouseTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QWidget.setParent": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setSizeIncrement": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy')],
-    "PySide2.QtWidgets.QWidget.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QWidget.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QWidget.setTabOrder": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QWidget.setTabletTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setToolTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setToolTipDuration": ('int',),
-    "PySide2.QtWidgets.QWidget.setUpdatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFilePath": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtWidgets.QWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QWidget.setWindowIconText": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QWidget.setWindowModified": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWindowOpacity": ('float',),
-    "PySide2.QtWidgets.QWidget.setWindowRole": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QWidget.sharedPainter": (),
-    "PySide2.QtWidgets.QWidget.show": (),
-    "PySide2.QtWidgets.QWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QWidget.showFullScreen": (),
-    "PySide2.QtWidgets.QWidget.showMaximized": (),
-    "PySide2.QtWidgets.QWidget.showMinimized": (),
-    "PySide2.QtWidgets.QWidget.showNormal": (),
-    "PySide2.QtWidgets.QWidget.size": (),
-    "PySide2.QtWidgets.QWidget.sizeHint": (),
-    "PySide2.QtWidgets.QWidget.sizeIncrement": (),
-    "PySide2.QtWidgets.QWidget.sizePolicy": (),
-    "PySide2.QtWidgets.QWidget.stackUnder": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.statusTip": (),
-    "PySide2.QtWidgets.QWidget.style": (),
-    "PySide2.QtWidgets.QWidget.styleSheet": (),
-    "PySide2.QtWidgets.QWidget.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtWidgets.QWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QWidget.toolTip": (),
-    "PySide2.QtWidgets.QWidget.toolTipDuration": (),
-    "PySide2.QtWidgets.QWidget.topLevelWidget": (),
-    "PySide2.QtWidgets.QWidget.underMouse": (),
-    "PySide2.QtWidgets.QWidget.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QWidget.unsetCursor": (),
-    "PySide2.QtWidgets.QWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QWidget.unsetLocale": (),
-    "PySide2.QtWidgets.QWidget.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QWidget.updateMicroFocus": (),
-    "PySide2.QtWidgets.QWidget.updatesEnabled": (),
-    "PySide2.QtWidgets.QWidget.visibleRegion": (),
-    "PySide2.QtWidgets.QWidget.whatsThis": (),
-    "PySide2.QtWidgets.QWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QWidget.width": (),
-    "PySide2.QtWidgets.QWidget.winId": (),
-    "PySide2.QtWidgets.QWidget.window": (),
-    "PySide2.QtWidgets.QWidget.windowFilePath": (),
-    "PySide2.QtWidgets.QWidget.windowFlags": (),
-    "PySide2.QtWidgets.QWidget.windowHandle": (),
-    "PySide2.QtWidgets.QWidget.windowIcon": (),
-    "PySide2.QtWidgets.QWidget.windowIconText": (),
-    "PySide2.QtWidgets.QWidget.windowModality": (),
-    "PySide2.QtWidgets.QWidget.windowOpacity": (),
-    "PySide2.QtWidgets.QWidget.windowRole": (),
-    "PySide2.QtWidgets.QWidget.windowState": (),
-    "PySide2.QtWidgets.QWidget.windowTitle": (),
-    "PySide2.QtWidgets.QWidget.windowType": (),
-    "PySide2.QtWidgets.QWidget.x": (),
-    "PySide2.QtWidgets.QWidget.y": (),
-# class PySide2.QtWidgets.QWidgetAction:
-    "PySide2.QtWidgets.QWidgetAction.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWidgetAction.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.createdWidgets": (),
-    "PySide2.QtWidgets.QWidgetAction.defaultWidget": (),
-    "PySide2.QtWidgets.QWidgetAction.deleteWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidgetAction.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QWidgetAction.releaseWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.requestWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.setDefaultWidget": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QWidgetItem:
-    "PySide2.QtWidgets.QWidgetItem.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetItem.controlTypes": (),
-    "PySide2.QtWidgets.QWidgetItem.expandingDirections": (),
-    "PySide2.QtWidgets.QWidgetItem.geometry": (),
-    "PySide2.QtWidgets.QWidgetItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidgetItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidgetItem.isEmpty": (),
-    "PySide2.QtWidgets.QWidgetItem.maximumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.minimumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QWidgetItem.widget": (),
-# class PySide2.QtWidgets.QWizard:
-# class PySide2.QtWidgets.QWizard.WizardButton:
-# class PySide2.QtWidgets.QWizard.WizardOption:
-# class PySide2.QtWidgets.QWizard.WizardOptions:
-# class PySide2.QtWidgets.QWizard.WizardPixmap:
-# class PySide2.QtWidgets.QWizard.WizardStyle:
-    "PySide2.QtWidgets.QWizard.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWizard.addPage": ('PySide2.QtWidgets.QWizardPage',),
-    "PySide2.QtWidgets.QWizard.back": (),
-    "PySide2.QtWidgets.QWizard.button": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.cleanupPage": ('int',),
-    "PySide2.QtWidgets.QWizard.currentId": (),
-    "PySide2.QtWidgets.QWizard.currentPage": (),
-    "PySide2.QtWidgets.QWizard.done": ('int',),
-    "PySide2.QtWidgets.QWizard.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWizard.field": ('str',),
-    "PySide2.QtWidgets.QWizard.hasVisitedPage": ('int',),
-    "PySide2.QtWidgets.QWizard.initializePage": ('int',),
-    "PySide2.QtWidgets.QWizard.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QWizard.nextId": (),
-    "PySide2.QtWidgets.QWizard.options": (),
-    "PySide2.QtWidgets.QWizard.page": ('int',),
-    "PySide2.QtWidgets.QWizard.pageIds": (),
-    "PySide2.QtWidgets.QWizard.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWizard.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizard.removePage": ('int',),
-    "PySide2.QtWidgets.QWizard.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWizard.restart": (),
-    "PySide2.QtWidgets.QWizard.setButton": ('PySide2.QtWidgets.QWizard.WizardButton', 'PySide2.QtWidgets.QAbstractButton'),
-    "PySide2.QtWidgets.QWizard.setButtonLayout": ('typing.Sequence',),
-    "PySide2.QtWidgets.QWizard.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizard.setDefaultProperty": ('bytes', 'bytes', 'bytes'),
-    "PySide2.QtWidgets.QWizard.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizard.setOption": ('PySide2.QtWidgets.QWizard.WizardOption', 'bool'),
-    "PySide2.QtWidgets.QWizard.setOptions": ('PySide2.QtWidgets.QWizard.WizardOptions',),
-    "PySide2.QtWidgets.QWizard.setPage": ('int', 'PySide2.QtWidgets.QWizardPage'),
-    "PySide2.QtWidgets.QWizard.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizard.setSideWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizard.setStartId": ('int',),
-    "PySide2.QtWidgets.QWizard.setSubTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWizard.setWizardStyle": ('PySide2.QtWidgets.QWizard.WizardStyle',),
-    "PySide2.QtWidgets.QWizard.sideWidget": (),
-    "PySide2.QtWidgets.QWizard.sizeHint": (),
-    "PySide2.QtWidgets.QWizard.startId": (),
-    "PySide2.QtWidgets.QWizard.subTitleFormat": (),
-    "PySide2.QtWidgets.QWizard.testOption": ('PySide2.QtWidgets.QWizard.WizardOption',),
-    "PySide2.QtWidgets.QWizard.titleFormat": (),
-    "PySide2.QtWidgets.QWizard.validateCurrentPage": (),
-    "PySide2.QtWidgets.QWizard.visitedPages": (),
-    "PySide2.QtWidgets.QWizard.wizardStyle": (),
-# class PySide2.QtWidgets.QWizardPage:
-    "PySide2.QtWidgets.QWizardPage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizardPage.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizardPage.cleanupPage": (),
-    "PySide2.QtWidgets.QWizardPage.field": ('str',),
-    "PySide2.QtWidgets.QWizardPage.initializePage": (),
-    "PySide2.QtWidgets.QWizardPage.isCommitPage": (),
-    "PySide2.QtWidgets.QWizardPage.isComplete": (),
-    "PySide2.QtWidgets.QWizardPage.isFinalPage": (),
-    "PySide2.QtWidgets.QWizardPage.nextId": (),
-    "PySide2.QtWidgets.QWizardPage.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizardPage.registerField": ('str', 'PySide2.QtWidgets.QWidget', 'bytes', 'bytes'),
-    "PySide2.QtWidgets.QWizardPage.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setCommitPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizardPage.setFinalPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizardPage.setSubTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.setTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.subTitle": (),
-    "PySide2.QtWidgets.QWizardPage.title": (),
-    "PySide2.QtWidgets.QWizardPage.validatePage": (),
-    "PySide2.QtWidgets.QWizardPage.wizard": (),
-    }) if "PySide2.QtWidgets" in sys.modules else None
-# Module PySide2.QtPrintSupport
-sig_dict.update({
-# class PySide2.QtPrintSupport.QAbstractPrintDialog:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange:
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.__init__": ('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.addEnabledOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.enabledOptions": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.fromPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.isOptionEnabled": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.maxPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.minPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printRange": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printer": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setEnabledOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setMinMax": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setOptionTabs": ('typing.Sequence',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setPrintRange": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.toPage": (),
-# class PySide2.QtPrintSupport.QPageSetupDialog:
-    "PySide2.QtPrintSupport.QPageSetupDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPageSetupDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPageSetupDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtPrintSupport.QPageSetupDialog.printer": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintDialog:
-    "PySide2.QtPrintSupport.QPrintDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPrintDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPrintDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtPrintSupport.QPrintDialog.options": (),
-    "PySide2.QtPrintSupport.QPrintDialog.setOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption', 'bool'),
-    "PySide2.QtPrintSupport.QPrintDialog.setOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QPrintDialog.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintDialog.testOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-# class PySide2.QtPrintSupport.QPrintEngine:
-# class PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey:
-    "PySide2.QtPrintSupport.QPrintEngine.__init__": (),
-    "PySide2.QtPrintSupport.QPrintEngine.abort": (),
-    "PySide2.QtPrintSupport.QPrintEngine.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrintEngine.newPage": (),
-    "PySide2.QtPrintSupport.QPrintEngine.printerState": (),
-    "PySide2.QtPrintSupport.QPrintEngine.property": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey',),
-    "PySide2.QtPrintSupport.QPrintEngine.setProperty": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey', 'typing.Any'),
-# class PySide2.QtPrintSupport.QPrintPreviewDialog:
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.open": [(), ('PySide2.QtCore.QObject', 'bytes')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.printer": (),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintPreviewWidget:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode:
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.currentPage": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitInView": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitToWidth": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.orientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.pageCount": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.print_": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setAllPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setCurrentPage": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setFacingPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setLandscapeOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setPortraitOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setSinglePageViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setViewMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomFactor": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.updatePreview": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.viewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomFactor": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomIn": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomOut": ('float',),
-# class PySide2.QtPrintSupport.QPrinter:
-# class PySide2.QtPrintSupport.QPrinter.ColorMode:
-# class PySide2.QtPrintSupport.QPrinter.DuplexMode:
-# class PySide2.QtPrintSupport.QPrinter.Orientation:
-# class PySide2.QtPrintSupport.QPrinter.OutputFormat:
-# class PySide2.QtPrintSupport.QPrinter.PageOrder:
-# class PySide2.QtPrintSupport.QPrinter.PaperSource:
-# class PySide2.QtPrintSupport.QPrinter.PrintRange:
-# class PySide2.QtPrintSupport.QPrinter.PrinterMode:
-# class PySide2.QtPrintSupport.QPrinter.PrinterState:
-# class PySide2.QtPrintSupport.QPrinter.Unit:
-    "PySide2.QtPrintSupport.QPrinter.__init__": [('PySide2.QtPrintSupport.QPrinter.PrinterMode',), ('PySide2.QtPrintSupport.QPrinterInfo', 'PySide2.QtPrintSupport.QPrinter.PrinterMode')],
-    "PySide2.QtPrintSupport.QPrinter.abort": (),
-    "PySide2.QtPrintSupport.QPrinter.actualNumCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.collateCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.colorMode": (),
-    "PySide2.QtPrintSupport.QPrinter.copyCount": (),
-    "PySide2.QtPrintSupport.QPrinter.creator": (),
-    "PySide2.QtPrintSupport.QPrinter.devType": (),
-    "PySide2.QtPrintSupport.QPrinter.docName": (),
-    "PySide2.QtPrintSupport.QPrinter.doubleSidedPrinting": (),
-    "PySide2.QtPrintSupport.QPrinter.duplex": (),
-    "PySide2.QtPrintSupport.QPrinter.fontEmbeddingEnabled": (),
-    "PySide2.QtPrintSupport.QPrinter.fromPage": (),
-    "PySide2.QtPrintSupport.QPrinter.fullPage": (),
-    "PySide2.QtPrintSupport.QPrinter.getPageMargins": ('PySide2.QtPrintSupport.QPrinter.Unit',),
-    "PySide2.QtPrintSupport.QPrinter.isValid": (),
-    "PySide2.QtPrintSupport.QPrinter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrinter.newPage": (),
-    "PySide2.QtPrintSupport.QPrinter.numCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.orientation": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFileName": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFormat": (),
-    "PySide2.QtPrintSupport.QPrinter.pageOrder": (),
-    "PySide2.QtPrintSupport.QPrinter.pageRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.pageSize": (),
-    "PySide2.QtPrintSupport.QPrinter.paintEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.paperName": (),
-    "PySide2.QtPrintSupport.QPrinter.paperRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSize": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSource": (),
-    "PySide2.QtPrintSupport.QPrinter.pdfVersion": (),
-    "PySide2.QtPrintSupport.QPrinter.printEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.printProgram": (),
-    "PySide2.QtPrintSupport.QPrinter.printRange": (),
-    "PySide2.QtPrintSupport.QPrinter.printerName": (),
-    "PySide2.QtPrintSupport.QPrinter.printerState": (),
-    "PySide2.QtPrintSupport.QPrinter.resolution": (),
-    "PySide2.QtPrintSupport.QPrinter.setCollateCopies": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setColorMode": ('PySide2.QtPrintSupport.QPrinter.ColorMode',),
-    "PySide2.QtPrintSupport.QPrinter.setCopyCount": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setCreator": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDocName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDoubleSidedPrinting": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setDuplex": ('PySide2.QtPrintSupport.QPrinter.DuplexMode',),
-    "PySide2.QtPrintSupport.QPrinter.setEngines": ('PySide2.QtPrintSupport.QPrintEngine', 'PySide2.QtGui.QPaintEngine'),
-    "PySide2.QtPrintSupport.QPrinter.setFontEmbeddingEnabled": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QPrinter.setFullPage": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtPrintSupport.QPrinter.setNumCopies": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFileName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFormat": ('PySide2.QtPrintSupport.QPrinter.OutputFormat',),
-    "PySide2.QtPrintSupport.QPrinter.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float', 'PySide2.QtPrintSupport.QPrinter.Unit')],
-    "PySide2.QtPrintSupport.QPrinter.setPageOrder": ('PySide2.QtPrintSupport.QPrinter.PageOrder',),
-    "PySide2.QtPrintSupport.QPrinter.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperSize": [('PySide2.QtCore.QSizeF', 'PySide2.QtPrintSupport.QPrinter.Unit'), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPaperSource": ('PySide2.QtPrintSupport.QPrinter.PaperSource',),
-    "PySide2.QtPrintSupport.QPrinter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintProgram": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintRange": ('PySide2.QtPrintSupport.QPrinter.PrintRange',),
-    "PySide2.QtPrintSupport.QPrinter.setPrinterName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setResolution": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setWinPageSize": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.supportedPaperSources": (),
-    "PySide2.QtPrintSupport.QPrinter.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinter.supportsMultipleCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.toPage": (),
-    "PySide2.QtPrintSupport.QPrinter.winPageSize": (),
-# class PySide2.QtPrintSupport.QPrinterInfo:
-    "PySide2.QtPrintSupport.QPrinterInfo.__init__": [(), ('PySide2.QtPrintSupport.QPrinter',), ('PySide2.QtPrintSupport.QPrinterInfo',)],
-    "PySide2.QtPrintSupport.QPrinterInfo.__copy__": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinterNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinters": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultColorMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultDuplexMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinter": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinterName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.description": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isDefault": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isNull": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isRemote": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.location": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.makeAndModel": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.maximumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.minimumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerInfo": ('str',),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.state": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedColorModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedDuplexModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPageSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPaperSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedSizesWithNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportsCustomPageSizes": (),
-    }) if "PySide2.QtPrintSupport" in sys.modules else None
-# Module PySide2.QtSql
-sig_dict.update({
-# class PySide2.QtSql.QSql:
-# class PySide2.QtSql.QSql.Location:
-# class PySide2.QtSql.QSql.NumericalPrecisionPolicy:
-# class PySide2.QtSql.QSql.ParamType:
-# class PySide2.QtSql.QSql.ParamTypeFlag:
-# class PySide2.QtSql.QSql.TableType:
-# class PySide2.QtSql.QSqlDatabase:
-    "PySide2.QtSql.QSqlDatabase.__init__": [(), ('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlDriver',), ('str',)],
-    "PySide2.QtSql.QSqlDatabase.__copy__": (),
-    "PySide2.QtSql.QSqlDatabase.addDatabase": [('PySide2.QtSql.QSqlDriver', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.cloneDatabase": [('PySide2.QtSql.QSqlDatabase', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.close": (),
-    "PySide2.QtSql.QSqlDatabase.commit": (),
-    "PySide2.QtSql.QSqlDatabase.connectOptions": (),
-    "PySide2.QtSql.QSqlDatabase.connectionName": (),
-    "PySide2.QtSql.QSqlDatabase.connectionNames": (),
-    "PySide2.QtSql.QSqlDatabase.contains": ('str',),
-    "PySide2.QtSql.QSqlDatabase.database": ('str', 'bool'),
-    "PySide2.QtSql.QSqlDatabase.databaseName": (),
-    "PySide2.QtSql.QSqlDatabase.driver": (),
-    "PySide2.QtSql.QSqlDatabase.driverName": (),
-    "PySide2.QtSql.QSqlDatabase.drivers": (),
-    "PySide2.QtSql.QSqlDatabase.exec_": ('str',),
-    "PySide2.QtSql.QSqlDatabase.hostName": (),
-    "PySide2.QtSql.QSqlDatabase.isDriverAvailable": ('str',),
-    "PySide2.QtSql.QSqlDatabase.isOpen": (),
-    "PySide2.QtSql.QSqlDatabase.isOpenError": (),
-    "PySide2.QtSql.QSqlDatabase.isValid": (),
-    "PySide2.QtSql.QSqlDatabase.lastError": (),
-    "PySide2.QtSql.QSqlDatabase.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDatabase.open": [(), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.password": (),
-    "PySide2.QtSql.QSqlDatabase.port": (),
-    "PySide2.QtSql.QSqlDatabase.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDatabase.record": ('str',),
-    "PySide2.QtSql.QSqlDatabase.registerSqlDriver": ('str', 'PySide2.QtSql.QSqlDriverCreatorBase'),
-    "PySide2.QtSql.QSqlDatabase.removeDatabase": ('str',),
-    "PySide2.QtSql.QSqlDatabase.rollback": (),
-    "PySide2.QtSql.QSqlDatabase.setConnectOptions": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setDatabaseName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setHostName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDatabase.setPassword": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setPort": ('int',),
-    "PySide2.QtSql.QSqlDatabase.setUserName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDatabase.transaction": (),
-    "PySide2.QtSql.QSqlDatabase.userName": (),
-# class PySide2.QtSql.QSqlDriver:
-# class PySide2.QtSql.QSqlDriver.DbmsType:
-# class PySide2.QtSql.QSqlDriver.DriverFeature:
-# class PySide2.QtSql.QSqlDriver.IdentifierType:
-# class PySide2.QtSql.QSqlDriver.NotificationSource:
-# class PySide2.QtSql.QSqlDriver.StatementType:
-    "PySide2.QtSql.QSqlDriver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlDriver.beginTransaction": (),
-    "PySide2.QtSql.QSqlDriver.cancelQuery": (),
-    "PySide2.QtSql.QSqlDriver.close": (),
-    "PySide2.QtSql.QSqlDriver.commitTransaction": (),
-    "PySide2.QtSql.QSqlDriver.createResult": (),
-    "PySide2.QtSql.QSqlDriver.dbmsType": (),
-    "PySide2.QtSql.QSqlDriver.escapeIdentifier": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.formatValue": ('PySide2.QtSql.QSqlField', 'bool'),
-    "PySide2.QtSql.QSqlDriver.hasFeature": ('PySide2.QtSql.QSqlDriver.DriverFeature',),
-    "PySide2.QtSql.QSqlDriver.isIdentifierEscaped": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.isOpen": (),
-    "PySide2.QtSql.QSqlDriver.isOpenError": (),
-    "PySide2.QtSql.QSqlDriver.lastError": (),
-    "PySide2.QtSql.QSqlDriver.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDriver.open": ('str', 'str', 'str', 'str', 'int', 'str'),
-    "PySide2.QtSql.QSqlDriver.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDriver.record": ('str',),
-    "PySide2.QtSql.QSqlDriver.rollbackTransaction": (),
-    "PySide2.QtSql.QSqlDriver.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlDriver.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDriver.setOpen": ('bool',),
-    "PySide2.QtSql.QSqlDriver.setOpenError": ('bool',),
-    "PySide2.QtSql.QSqlDriver.sqlStatement": ('PySide2.QtSql.QSqlDriver.StatementType', 'str', 'PySide2.QtSql.QSqlRecord', 'bool'),
-    "PySide2.QtSql.QSqlDriver.stripDelimiters": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.subscribeToNotification": ('str',),
-    "PySide2.QtSql.QSqlDriver.subscribedToNotifications": (),
-    "PySide2.QtSql.QSqlDriver.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDriver.unsubscribeFromNotification": ('str',),
-# class PySide2.QtSql.QSqlDriverCreatorBase:
-    "PySide2.QtSql.QSqlDriverCreatorBase.__init__": (),
-    "PySide2.QtSql.QSqlDriverCreatorBase.createObject": (),
-# class PySide2.QtSql.QSqlError:
-# class PySide2.QtSql.QSqlError.ErrorType:
-    "PySide2.QtSql.QSqlError.__init__": [('PySide2.QtSql.QSqlError',), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'int'), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'str')],
-    "PySide2.QtSql.QSqlError.__copy__": (),
-    "PySide2.QtSql.QSqlError.databaseText": (),
-    "PySide2.QtSql.QSqlError.driverText": (),
-    "PySide2.QtSql.QSqlError.isValid": (),
-    "PySide2.QtSql.QSqlError.nativeErrorCode": (),
-    "PySide2.QtSql.QSqlError.number": (),
-    "PySide2.QtSql.QSqlError.setDatabaseText": ('str',),
-    "PySide2.QtSql.QSqlError.setDriverText": ('str',),
-    "PySide2.QtSql.QSqlError.setNumber": ('int',),
-    "PySide2.QtSql.QSqlError.setType": ('PySide2.QtSql.QSqlError.ErrorType',),
-    "PySide2.QtSql.QSqlError.swap": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlError.text": (),
-    "PySide2.QtSql.QSqlError.type": (),
-# class PySide2.QtSql.QSqlField:
-# class PySide2.QtSql.QSqlField.RequiredStatus:
-    "PySide2.QtSql.QSqlField.__init__": [('PySide2.QtSql.QSqlField',), ('str', 'type'), ('str', 'type', 'str')],
-    "PySide2.QtSql.QSqlField.__copy__": (),
-    "PySide2.QtSql.QSqlField.clear": (),
-    "PySide2.QtSql.QSqlField.defaultValue": (),
-    "PySide2.QtSql.QSqlField.isAutoValue": (),
-    "PySide2.QtSql.QSqlField.isGenerated": (),
-    "PySide2.QtSql.QSqlField.isNull": (),
-    "PySide2.QtSql.QSqlField.isReadOnly": (),
-    "PySide2.QtSql.QSqlField.isValid": (),
-    "PySide2.QtSql.QSqlField.length": (),
-    "PySide2.QtSql.QSqlField.name": (),
-    "PySide2.QtSql.QSqlField.precision": (),
-    "PySide2.QtSql.QSqlField.requiredStatus": (),
-    "PySide2.QtSql.QSqlField.setAutoValue": ('bool',),
-    "PySide2.QtSql.QSqlField.setDefaultValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.setGenerated": ('bool',),
-    "PySide2.QtSql.QSqlField.setLength": ('int',),
-    "PySide2.QtSql.QSqlField.setName": ('str',),
-    "PySide2.QtSql.QSqlField.setPrecision": ('int',),
-    "PySide2.QtSql.QSqlField.setReadOnly": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequired": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequiredStatus": ('PySide2.QtSql.QSqlField.RequiredStatus',),
-    "PySide2.QtSql.QSqlField.setSqlType": ('int',),
-    "PySide2.QtSql.QSqlField.setTableName": ('str',),
-    "PySide2.QtSql.QSqlField.setType": ('type',),
-    "PySide2.QtSql.QSqlField.setValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.tableName": (),
-    "PySide2.QtSql.QSqlField.type": (),
-    "PySide2.QtSql.QSqlField.typeID": (),
-    "PySide2.QtSql.QSqlField.value": (),
-# class PySide2.QtSql.QSqlIndex:
-    "PySide2.QtSql.QSqlIndex.__init__": [('PySide2.QtSql.QSqlIndex',), ('str', 'str')],
-    "PySide2.QtSql.QSqlIndex.__copy__": (),
-    "PySide2.QtSql.QSqlIndex.append": [('PySide2.QtSql.QSqlField',), ('PySide2.QtSql.QSqlField', 'bool')],
-    "PySide2.QtSql.QSqlIndex.cursorName": (),
-    "PySide2.QtSql.QSqlIndex.isDescending": ('int',),
-    "PySide2.QtSql.QSqlIndex.name": (),
-    "PySide2.QtSql.QSqlIndex.setCursorName": ('str',),
-    "PySide2.QtSql.QSqlIndex.setDescending": ('int', 'bool'),
-    "PySide2.QtSql.QSqlIndex.setName": ('str',),
-# class PySide2.QtSql.QSqlQuery:
-# class PySide2.QtSql.QSqlQuery.BatchExecutionMode:
-    "PySide2.QtSql.QSqlQuery.__init__": [('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlQuery',), ('PySide2.QtSql.QSqlResult',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-    "PySide2.QtSql.QSqlQuery.__copy__": (),
-    "PySide2.QtSql.QSqlQuery.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlQuery.at": (),
-    "PySide2.QtSql.QSqlQuery.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlQuery.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.boundValues": (),
-    "PySide2.QtSql.QSqlQuery.clear": (),
-    "PySide2.QtSql.QSqlQuery.driver": (),
-    "PySide2.QtSql.QSqlQuery.execBatch": ('PySide2.QtSql.QSqlQuery.BatchExecutionMode',),
-    "PySide2.QtSql.QSqlQuery.exec_": [(), ('str',)],
-    "PySide2.QtSql.QSqlQuery.executedQuery": (),
-    "PySide2.QtSql.QSqlQuery.finish": (),
-    "PySide2.QtSql.QSqlQuery.first": (),
-    "PySide2.QtSql.QSqlQuery.isActive": (),
-    "PySide2.QtSql.QSqlQuery.isForwardOnly": (),
-    "PySide2.QtSql.QSqlQuery.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.isSelect": (),
-    "PySide2.QtSql.QSqlQuery.isValid": (),
-    "PySide2.QtSql.QSqlQuery.last": (),
-    "PySide2.QtSql.QSqlQuery.lastError": (),
-    "PySide2.QtSql.QSqlQuery.lastInsertId": (),
-    "PySide2.QtSql.QSqlQuery.lastQuery": (),
-    "PySide2.QtSql.QSqlQuery.nextResult": (),
-    "PySide2.QtSql.QSqlQuery.numRowsAffected": (),
-    "PySide2.QtSql.QSqlQuery.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlQuery.prepare": ('str',),
-    "PySide2.QtSql.QSqlQuery.previous": (),
-    "PySide2.QtSql.QSqlQuery.record": (),
-    "PySide2.QtSql.QSqlQuery.result": (),
-    "PySide2.QtSql.QSqlQuery.seek": ('int', 'bool'),
-    "PySide2.QtSql.QSqlQuery.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlQuery.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlQuery.size": (),
-    "PySide2.QtSql.QSqlQuery.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlQueryModel:
-    "PySide2.QtSql.QSqlQueryModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.clear": (),
-    "PySide2.QtSql.QSqlQueryModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.endInsertColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endInsertRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.lastError": (),
-    "PySide2.QtSql.QSqlQueryModel.query": (),
-    "PySide2.QtSql.QSqlQueryModel.queryChange": (),
-    "PySide2.QtSql.QSqlQueryModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlQueryModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.roleNames": (),
-    "PySide2.QtSql.QSqlQueryModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlQueryModel.setQuery": [('PySide2.QtSql.QSqlQuery',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-# class PySide2.QtSql.QSqlRecord:
-    "PySide2.QtSql.QSqlRecord.__init__": [(), ('PySide2.QtSql.QSqlRecord',)],
-    "PySide2.QtSql.QSqlRecord.__copy__": (),
-    "PySide2.QtSql.QSqlRecord.append": ('PySide2.QtSql.QSqlField',),
-    "PySide2.QtSql.QSqlRecord.clear": (),
-    "PySide2.QtSql.QSqlRecord.clearValues": (),
-    "PySide2.QtSql.QSqlRecord.contains": ('str',),
-    "PySide2.QtSql.QSqlRecord.count": (),
-    "PySide2.QtSql.QSqlRecord.field": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.fieldName": ('int',),
-    "PySide2.QtSql.QSqlRecord.indexOf": ('str',),
-    "PySide2.QtSql.QSqlRecord.insert": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.isEmpty": (),
-    "PySide2.QtSql.QSqlRecord.isGenerated": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.keyValues": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRecord.remove": ('int',),
-    "PySide2.QtSql.QSqlRecord.replace": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.setGenerated": [('int', 'bool'), ('str', 'bool')],
-    "PySide2.QtSql.QSqlRecord.setNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.setValue": [('int', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtSql.QSqlRecord.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlRelation:
-    "PySide2.QtSql.QSqlRelation.__init__": [(), ('PySide2.QtSql.QSqlRelation',), ('str', 'str', 'str')],
-    "PySide2.QtSql.QSqlRelation.__copy__": (),
-    "PySide2.QtSql.QSqlRelation.displayColumn": (),
-    "PySide2.QtSql.QSqlRelation.indexColumn": (),
-    "PySide2.QtSql.QSqlRelation.isValid": (),
-    "PySide2.QtSql.QSqlRelation.swap": ('PySide2.QtSql.QSqlRelation',),
-    "PySide2.QtSql.QSqlRelation.tableName": (),
-# class PySide2.QtSql.QSqlRelationalDelegate:
-    "PySide2.QtSql.QSqlRelationalDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlRelationalDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtSql.QSqlRelationalTableModel:
-# class PySide2.QtSql.QSqlRelationalTableModel.JoinMode:
-    "PySide2.QtSql.QSqlRelationalTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlRelationalTableModel.clear": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRelationalTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.relation": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.relationModel": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.select": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setJoinMode": ('PySide2.QtSql.QSqlRelationalTableModel.JoinMode',),
-    "PySide2.QtSql.QSqlRelationalTableModel.setRelation": ('int', 'PySide2.QtSql.QSqlRelation'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlRelationalTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-# class PySide2.QtSql.QSqlResult:
-# class PySide2.QtSql.QSqlResult.BindingSyntax:
-    "PySide2.QtSql.QSqlResult.__init__": ('PySide2.QtSql.QSqlDriver',),
-    "PySide2.QtSql.QSqlResult.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlResult.at": (),
-    "PySide2.QtSql.QSqlResult.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlResult.bindValueType": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.bindingSyntax": (),
-    "PySide2.QtSql.QSqlResult.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.boundValueCount": (),
-    "PySide2.QtSql.QSqlResult.boundValueName": ('int',),
-    "PySide2.QtSql.QSqlResult.boundValues": (),
-    "PySide2.QtSql.QSqlResult.clear": (),
-    "PySide2.QtSql.QSqlResult.data": ('int',),
-    "PySide2.QtSql.QSqlResult.detachFromResultSet": (),
-    "PySide2.QtSql.QSqlResult.driver": (),
-    "PySide2.QtSql.QSqlResult.execBatch": ('bool',),
-    "PySide2.QtSql.QSqlResult.exec_": (),
-    "PySide2.QtSql.QSqlResult.executedQuery": (),
-    "PySide2.QtSql.QSqlResult.fetch": ('int',),
-    "PySide2.QtSql.QSqlResult.fetchFirst": (),
-    "PySide2.QtSql.QSqlResult.fetchLast": (),
-    "PySide2.QtSql.QSqlResult.fetchNext": (),
-    "PySide2.QtSql.QSqlResult.fetchPrevious": (),
-    "PySide2.QtSql.QSqlResult.handle": (),
-    "PySide2.QtSql.QSqlResult.hasOutValues": (),
-    "PySide2.QtSql.QSqlResult.isActive": (),
-    "PySide2.QtSql.QSqlResult.isForwardOnly": (),
-    "PySide2.QtSql.QSqlResult.isNull": ('int',),
-    "PySide2.QtSql.QSqlResult.isSelect": (),
-    "PySide2.QtSql.QSqlResult.isValid": (),
-    "PySide2.QtSql.QSqlResult.lastError": (),
-    "PySide2.QtSql.QSqlResult.lastInsertId": (),
-    "PySide2.QtSql.QSqlResult.lastQuery": (),
-    "PySide2.QtSql.QSqlResult.nextResult": (),
-    "PySide2.QtSql.QSqlResult.numRowsAffected": (),
-    "PySide2.QtSql.QSqlResult.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlResult.prepare": ('str',),
-    "PySide2.QtSql.QSqlResult.record": (),
-    "PySide2.QtSql.QSqlResult.reset": ('str',),
-    "PySide2.QtSql.QSqlResult.resetBindCount": (),
-    "PySide2.QtSql.QSqlResult.savePrepare": ('str',),
-    "PySide2.QtSql.QSqlResult.setActive": ('bool',),
-    "PySide2.QtSql.QSqlResult.setAt": ('int',),
-    "PySide2.QtSql.QSqlResult.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlResult.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlResult.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlResult.setQuery": ('str',),
-    "PySide2.QtSql.QSqlResult.setSelect": ('bool',),
-    "PySide2.QtSql.QSqlResult.size": (),
-# class PySide2.QtSql.QSqlTableModel:
-# class PySide2.QtSql.QSqlTableModel.EditStrategy:
-    "PySide2.QtSql.QSqlTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlTableModel.clear": (),
-    "PySide2.QtSql.QSqlTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlTableModel.database": (),
-    "PySide2.QtSql.QSqlTableModel.deleteRowFromTable": ('int',),
-    "PySide2.QtSql.QSqlTableModel.editStrategy": (),
-    "PySide2.QtSql.QSqlTableModel.fieldIndex": ('str',),
-    "PySide2.QtSql.QSqlTableModel.filter": (),
-    "PySide2.QtSql.QSqlTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlTableModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.insertRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlTableModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.isDirty": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtSql.QSqlTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlTableModel.primaryKey": (),
-    "PySide2.QtSql.QSqlTableModel.primaryValues": ('int',),
-    "PySide2.QtSql.QSqlTableModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.revert": (),
-    "PySide2.QtSql.QSqlTableModel.revertAll": (),
-    "PySide2.QtSql.QSqlTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.select": (),
-    "PySide2.QtSql.QSqlTableModel.selectRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlTableModel.setEditStrategy": ('PySide2.QtSql.QSqlTableModel.EditStrategy',),
-    "PySide2.QtSql.QSqlTableModel.setFilter": ('str',),
-    "PySide2.QtSql.QSqlTableModel.setPrimaryKey": ('PySide2.QtSql.QSqlIndex',),
-    "PySide2.QtSql.QSqlTableModel.setQuery": ('PySide2.QtSql.QSqlQuery',),
-    "PySide2.QtSql.QSqlTableModel.setRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.setSort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlTableModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.submit": (),
-    "PySide2.QtSql.QSqlTableModel.submitAll": (),
-    "PySide2.QtSql.QSqlTableModel.tableName": (),
-    "PySide2.QtSql.QSqlTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-    }) if "PySide2.QtSql" in sys.modules else None
-# Module PySide2.QtNetwork
-sig_dict.update({
-# class PySide2.QtNetwork.QAbstractNetworkCache:
-    "PySide2.QtNetwork.QAbstractNetworkCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.cacheSize": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.clear": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QAbstractSocket:
-# class PySide2.QtNetwork.QAbstractSocket.BindFlag:
-# class PySide2.QtNetwork.QAbstractSocket.BindMode:
-# class PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol:
-# class PySide2.QtNetwork.QAbstractSocket.PauseMode:
-# class PySide2.QtNetwork.QAbstractSocket.PauseModes:
-# class PySide2.QtNetwork.QAbstractSocket.SocketError:
-# class PySide2.QtNetwork.QAbstractSocket.SocketOption:
-# class PySide2.QtNetwork.QAbstractSocket.SocketState:
-# class PySide2.QtNetwork.QAbstractSocket.SocketType:
-    "PySide2.QtNetwork.QAbstractSocket.__init__": ('PySide2.QtNetwork.QAbstractSocket.SocketType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QAbstractSocket.abort": (),
-    "PySide2.QtNetwork.QAbstractSocket.atEnd": (),
-    "PySide2.QtNetwork.QAbstractSocket.bind": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtNetwork.QAbstractSocket.BindMode'), ('int', 'PySide2.QtNetwork.QAbstractSocket.BindMode')],
-    "PySide2.QtNetwork.QAbstractSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QAbstractSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QAbstractSocket.canReadLine": (),
-    "PySide2.QtNetwork.QAbstractSocket.close": (),
-    "PySide2.QtNetwork.QAbstractSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QAbstractSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QAbstractSocket.error": (),
-    "PySide2.QtNetwork.QAbstractSocket.flush": (),
-    "PySide2.QtNetwork.QAbstractSocket.isSequential": (),
-    "PySide2.QtNetwork.QAbstractSocket.isValid": (),
-    "PySide2.QtNetwork.QAbstractSocket.localAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.localPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.pauseMode": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerName": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.protocolTag": (),
-    "PySide2.QtNetwork.QAbstractSocket.proxy": (),
-    "PySide2.QtNetwork.QAbstractSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QAbstractSocket.readData": ('bytes', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.readLineData": ('bytes', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.resume": (),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerName": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QAbstractSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketError": ('PySide2.QtNetwork.QAbstractSocket.SocketError',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketState": ('PySide2.QtNetwork.QAbstractSocket.SocketState',),
-    "PySide2.QtNetwork.QAbstractSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QAbstractSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QAbstractSocket.socketType": (),
-    "PySide2.QtNetwork.QAbstractSocket.state": (),
-    "PySide2.QtNetwork.QAbstractSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.writeData": ('bytes', 'int'),
-# class PySide2.QtNetwork.QAuthenticator:
-    "PySide2.QtNetwork.QAuthenticator.__init__": [(), ('PySide2.QtNetwork.QAuthenticator',)],
-    "PySide2.QtNetwork.QAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QAuthenticator.isNull": (),
-    "PySide2.QtNetwork.QAuthenticator.option": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.options": (),
-    "PySide2.QtNetwork.QAuthenticator.password": (),
-    "PySide2.QtNetwork.QAuthenticator.realm": (),
-    "PySide2.QtNetwork.QAuthenticator.setOption": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QAuthenticator.setPassword": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setRealm": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setUser": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.user": (),
-# class PySide2.QtNetwork.QDnsDomainNameRecord:
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__init__": [(), ('PySide2.QtNetwork.QDnsDomainNameRecord',)],
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.name": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.swap": ('PySide2.QtNetwork.QDnsDomainNameRecord',),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.value": (),
-# class PySide2.QtNetwork.QDnsHostAddressRecord:
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__init__": [(), ('PySide2.QtNetwork.QDnsHostAddressRecord',)],
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.name": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.swap": ('PySide2.QtNetwork.QDnsHostAddressRecord',),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.value": (),
-# class PySide2.QtNetwork.QDnsLookup:
-# class PySide2.QtNetwork.QDnsLookup.Error:
-# class PySide2.QtNetwork.QDnsLookup.Type:
-    "PySide2.QtNetwork.QDnsLookup.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtNetwork.QHostAddress', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QDnsLookup.abort": (),
-    "PySide2.QtNetwork.QDnsLookup.canonicalNameRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.error": (),
-    "PySide2.QtNetwork.QDnsLookup.errorString": (),
-    "PySide2.QtNetwork.QDnsLookup.hostAddressRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.isFinished": (),
-    "PySide2.QtNetwork.QDnsLookup.lookup": (),
-    "PySide2.QtNetwork.QDnsLookup.mailExchangeRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.name": (),
-    "PySide2.QtNetwork.QDnsLookup.nameServerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.nameserver": (),
-    "PySide2.QtNetwork.QDnsLookup.pointerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.serviceRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.setName": ('str',),
-    "PySide2.QtNetwork.QDnsLookup.setNameserver": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QDnsLookup.setType": ('PySide2.QtNetwork.QDnsLookup.Type',),
-    "PySide2.QtNetwork.QDnsLookup.textRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.type": (),
-# class PySide2.QtNetwork.QDnsMailExchangeRecord:
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__init__": [(), ('PySide2.QtNetwork.QDnsMailExchangeRecord',)],
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.exchange": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.name": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.preference": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.swap": ('PySide2.QtNetwork.QDnsMailExchangeRecord',),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.timeToLive": (),
-# class PySide2.QtNetwork.QDnsServiceRecord:
-    "PySide2.QtNetwork.QDnsServiceRecord.__init__": [(), ('PySide2.QtNetwork.QDnsServiceRecord',)],
-    "PySide2.QtNetwork.QDnsServiceRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.name": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.port": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.priority": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.swap": ('PySide2.QtNetwork.QDnsServiceRecord',),
-    "PySide2.QtNetwork.QDnsServiceRecord.target": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.weight": (),
-# class PySide2.QtNetwork.QDnsTextRecord:
-    "PySide2.QtNetwork.QDnsTextRecord.__init__": [(), ('PySide2.QtNetwork.QDnsTextRecord',)],
-    "PySide2.QtNetwork.QDnsTextRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsTextRecord.name": (),
-    "PySide2.QtNetwork.QDnsTextRecord.swap": ('PySide2.QtNetwork.QDnsTextRecord',),
-    "PySide2.QtNetwork.QDnsTextRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsTextRecord.values": (),
-# class PySide2.QtNetwork.QDtls:
-# class PySide2.QtNetwork.QDtls.HandshakeState:
-    "PySide2.QtNetwork.QDtls.__init__": ('PySide2.QtNetwork.QSslSocket.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QDtls.abortHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.decryptDatagram": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.doHandshake": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.dtlsConfiguration": (),
-    "PySide2.QtNetwork.QDtls.dtlsError": (),
-    "PySide2.QtNetwork.QDtls.dtlsErrorString": (),
-    "PySide2.QtNetwork.QDtls.handleTimeout": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.handshakeState": (),
-    "PySide2.QtNetwork.QDtls.ignoreVerificationErrors": ('typing.List',),
-    "PySide2.QtNetwork.QDtls.isConnectionEncrypted": (),
-    "PySide2.QtNetwork.QDtls.mtuHint": (),
-    "PySide2.QtNetwork.QDtls.peerAddress": (),
-    "PySide2.QtNetwork.QDtls.peerPort": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationErrors": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationName": (),
-    "PySide2.QtNetwork.QDtls.resumeHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sessionCipher": (),
-    "PySide2.QtNetwork.QDtls.sessionProtocol": (),
-    "PySide2.QtNetwork.QDtls.setDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QDtls.setMtuHint": ('int',),
-    "PySide2.QtNetwork.QDtls.setPeer": ('PySide2.QtNetwork.QHostAddress', 'int', 'str'),
-    "PySide2.QtNetwork.QDtls.setPeerVerificationName": ('str',),
-    "PySide2.QtNetwork.QDtls.shutdown": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sslMode": (),
-    "PySide2.QtNetwork.QDtls.writeDatagramEncrypted": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtNetwork.QDtlsError:
-# class PySide2.QtNetwork.QHostAddress:
-# class PySide2.QtNetwork.QHostAddress.ConversionMode:
-# class PySide2.QtNetwork.QHostAddress.ConversionModeFlag:
-# class PySide2.QtNetwork.QHostAddress.SpecialAddress:
-    "PySide2.QtNetwork.QHostAddress.__init__": [(), ('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.__copy__": (),
-    "PySide2.QtNetwork.QHostAddress.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.clear": (),
-    "PySide2.QtNetwork.QHostAddress.isBroadcast": (),
-    "PySide2.QtNetwork.QHostAddress.isEqual": ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QHostAddress.ConversionMode'),
-    "PySide2.QtNetwork.QHostAddress.isGlobal": (),
-    "PySide2.QtNetwork.QHostAddress.isInSubnet": [('PySide2.QtNetwork.QHostAddress', 'int'), ('typing.Tuple',)],
-    "PySide2.QtNetwork.QHostAddress.isLinkLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isLoopback": (),
-    "PySide2.QtNetwork.QHostAddress.isMulticast": (),
-    "PySide2.QtNetwork.QHostAddress.isNull": (),
-    "PySide2.QtNetwork.QHostAddress.isSiteLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isUniqueLocalUnicast": (),
-    "PySide2.QtNetwork.QHostAddress.parseSubnet": ('str',),
-    "PySide2.QtNetwork.QHostAddress.protocol": (),
-    "PySide2.QtNetwork.QHostAddress.scopeId": (),
-    "PySide2.QtNetwork.QHostAddress.setAddress": [('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.setScopeId": ('str',),
-    "PySide2.QtNetwork.QHostAddress.swap": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QHostAddress.toIPv4Address": (),
-    "PySide2.QtNetwork.QHostAddress.toIPv6Address": (),
-    "PySide2.QtNetwork.QHostAddress.toString": (),
-# class PySide2.QtNetwork.QHostInfo:
-# class PySide2.QtNetwork.QHostInfo.HostInfoError:
-    "PySide2.QtNetwork.QHostInfo.__init__": [('PySide2.QtNetwork.QHostInfo',), ('int',)],
-    "PySide2.QtNetwork.QHostInfo.__copy__": (),
-    "PySide2.QtNetwork.QHostInfo.abortHostLookup": ('int',),
-    "PySide2.QtNetwork.QHostInfo.addresses": (),
-    "PySide2.QtNetwork.QHostInfo.error": (),
-    "PySide2.QtNetwork.QHostInfo.errorString": (),
-    "PySide2.QtNetwork.QHostInfo.fromName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.hostName": (),
-    "PySide2.QtNetwork.QHostInfo.localDomainName": (),
-    "PySide2.QtNetwork.QHostInfo.localHostName": (),
-    "PySide2.QtNetwork.QHostInfo.lookupId": (),
-    "PySide2.QtNetwork.QHostInfo.setAddresses": ('typing.Sequence',),
-    "PySide2.QtNetwork.QHostInfo.setError": ('PySide2.QtNetwork.QHostInfo.HostInfoError',),
-    "PySide2.QtNetwork.QHostInfo.setErrorString": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setHostName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setLookupId": ('int',),
-    "PySide2.QtNetwork.QHostInfo.swap": ('PySide2.QtNetwork.QHostInfo',),
-# class PySide2.QtNetwork.QHstsPolicy:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlag:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlags:
-    "PySide2.QtNetwork.QHstsPolicy.__init__": [(), ('PySide2.QtCore.QDateTime', 'PySide2.QtNetwork.QHstsPolicy.PolicyFlags', 'str', 'PySide2.QtCore.QUrl.ParsingMode'), ('PySide2.QtNetwork.QHstsPolicy',)],
-    "PySide2.QtNetwork.QHstsPolicy.__copy__": (),
-    "PySide2.QtNetwork.QHstsPolicy.expiry": (),
-    "PySide2.QtNetwork.QHstsPolicy.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtNetwork.QHstsPolicy.includesSubDomains": (),
-    "PySide2.QtNetwork.QHstsPolicy.isExpired": (),
-    "PySide2.QtNetwork.QHstsPolicy.setExpiry": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QHstsPolicy.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtNetwork.QHstsPolicy.setIncludesSubDomains": ('bool',),
-    "PySide2.QtNetwork.QHstsPolicy.swap": ('PySide2.QtNetwork.QHstsPolicy',),
-# class PySide2.QtNetwork.QHttpMultiPart:
-# class PySide2.QtNetwork.QHttpMultiPart.ContentType:
-    "PySide2.QtNetwork.QHttpMultiPart.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QHttpMultiPart.ContentType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QHttpMultiPart.append": ('PySide2.QtNetwork.QHttpPart',),
-    "PySide2.QtNetwork.QHttpMultiPart.boundary": (),
-    "PySide2.QtNetwork.QHttpMultiPart.setBoundary": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpMultiPart.setContentType": ('PySide2.QtNetwork.QHttpMultiPart.ContentType',),
-# class PySide2.QtNetwork.QHttpPart:
-    "PySide2.QtNetwork.QHttpPart.__init__": [(), ('PySide2.QtNetwork.QHttpPart',)],
-    "PySide2.QtNetwork.QHttpPart.__copy__": (),
-    "PySide2.QtNetwork.QHttpPart.setBody": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpPart.setBodyDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QHttpPart.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QHttpPart.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QHttpPart.swap": ('PySide2.QtNetwork.QHttpPart',),
-# class PySide2.QtNetwork.QIPv6Address:
-    "PySide2.QtNetwork.QIPv6Address.__init__": [(), ('PySide2.QtNetwork.QIPv6Address',)],
-    "PySide2.QtNetwork.QIPv6Address.__copy__": (),
-# class PySide2.QtNetwork.QLocalServer:
-# class PySide2.QtNetwork.QLocalServer.SocketOption:
-# class PySide2.QtNetwork.QLocalServer.SocketOptions:
-    "PySide2.QtNetwork.QLocalServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalServer.close": (),
-    "PySide2.QtNetwork.QLocalServer.errorString": (),
-    "PySide2.QtNetwork.QLocalServer.fullServerName": (),
-    "PySide2.QtNetwork.QLocalServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QLocalServer.isListening": (),
-    "PySide2.QtNetwork.QLocalServer.listen": [('int',), ('str',)],
-    "PySide2.QtNetwork.QLocalServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QLocalServer.removeServer": ('str',),
-    "PySide2.QtNetwork.QLocalServer.serverError": (),
-    "PySide2.QtNetwork.QLocalServer.serverName": (),
-    "PySide2.QtNetwork.QLocalServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QLocalServer.setSocketOptions": ('PySide2.QtNetwork.QLocalServer.SocketOptions',),
-    "PySide2.QtNetwork.QLocalServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalServer.socketOptions": (),
-    "PySide2.QtNetwork.QLocalServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QLocalSocket:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketError:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketState:
-    "PySide2.QtNetwork.QLocalSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalSocket.abort": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QLocalSocket.canReadLine": (),
-    "PySide2.QtNetwork.QLocalSocket.close": (),
-    "PySide2.QtNetwork.QLocalSocket.connectToServer": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtNetwork.QLocalSocket.disconnectFromServer": (),
-    "PySide2.QtNetwork.QLocalSocket.error": (),
-    "PySide2.QtNetwork.QLocalSocket.flush": (),
-    "PySide2.QtNetwork.QLocalSocket.fullServerName": (),
-    "PySide2.QtNetwork.QLocalSocket.isSequential": (),
-    "PySide2.QtNetwork.QLocalSocket.isValid": (),
-    "PySide2.QtNetwork.QLocalSocket.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtNetwork.QLocalSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QLocalSocket.readData": ('bytes', 'int'),
-    "PySide2.QtNetwork.QLocalSocket.serverName": (),
-    "PySide2.QtNetwork.QLocalSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.setServerName": ('str',),
-    "PySide2.QtNetwork.QLocalSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QLocalSocket.LocalSocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QLocalSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalSocket.state": (),
-    "PySide2.QtNetwork.QLocalSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.writeData": ('bytes', 'int'),
-# class PySide2.QtNetwork.QNetworkAccessManager:
-# class PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility:
-# class PySide2.QtNetwork.QNetworkAccessManager.Operation:
-    "PySide2.QtNetwork.QNetworkAccessManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkAccessManager.activeConfiguration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.addStrictTransportSecurityHosts": ('typing.List',),
-    "PySide2.QtNetwork.QNetworkAccessManager.autoDeleteReplies": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.cache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearAccessCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearConnectionCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.configuration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHost": ('str', 'int'),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHostEncrypted": [('str', 'int', 'PySide2.QtNetwork.QSslConfiguration'), ('str', 'int', 'PySide2.QtNetwork.QSslConfiguration', 'str')],
-    "PySide2.QtNetwork.QNetworkAccessManager.cookieJar": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.createRequest": ('PySide2.QtNetwork.QNetworkAccessManager.Operation', 'PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtNetwork.QNetworkAccessManager.deleteResource": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.enableStrictTransportSecurityStore": ('bool', 'str'),
-    "PySide2.QtNetwork.QNetworkAccessManager.get": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.head": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityStoreEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.networkAccessible": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.post": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.proxy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.proxyFactory": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.put": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.redirectPolicy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.sendCustomRequest": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.setAutoDeleteReplies": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCache": ('PySide2.QtNetwork.QAbstractNetworkCache',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCookieJar": ('PySide2.QtNetwork.QNetworkCookieJar',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setNetworkAccessible": ('PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setRedirectPolicy": ('PySide2.QtNetwork.QNetworkRequest.RedirectPolicy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setStrictTransportSecurityEnabled": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.strictTransportSecurityHosts": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemes": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemesImplementation": (),
-# class PySide2.QtNetwork.QNetworkAddressEntry:
-# class PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus:
-    "PySide2.QtNetwork.QNetworkAddressEntry.__init__": [(), ('PySide2.QtNetwork.QNetworkAddressEntry',)],
-    "PySide2.QtNetwork.QNetworkAddressEntry.__copy__": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.broadcast": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.clearAddressLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.dnsEligibility": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.ip": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isLifetimeKnown": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isPermanent": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isTemporary": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.netmask": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.preferredLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.prefixLength": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setAddressLifetime": ('PySide2.QtCore.QDeadlineTimer', 'PySide2.QtCore.QDeadlineTimer'),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setBroadcast": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setDnsEligibility": ('PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setIp": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setNetmask": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setPrefixLength": ('int',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.swap": ('PySide2.QtNetwork.QNetworkAddressEntry',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.validityLifetime": (),
-# class PySide2.QtNetwork.QNetworkCacheMetaData:
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__init__": [(), ('PySide2.QtNetwork.QNetworkCacheMetaData',)],
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.attributes": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.isValid": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.lastModified": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.rawHeaders": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.saveToDisk": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setAttributes": ('typing.Dict',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setLastModified": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setRawHeaders": ('typing.Sequence',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setSaveToDisk": ('bool',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.swap": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.url": (),
-# class PySide2.QtNetwork.QNetworkConfiguration:
-# class PySide2.QtNetwork.QNetworkConfiguration.BearerType:
-# class PySide2.QtNetwork.QNetworkConfiguration.Purpose:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlag:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlags:
-# class PySide2.QtNetwork.QNetworkConfiguration.Type:
-    "PySide2.QtNetwork.QNetworkConfiguration.__init__": [(), ('PySide2.QtNetwork.QNetworkConfiguration',)],
-    "PySide2.QtNetwork.QNetworkConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerType": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeFamily": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeName": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.children": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.connectTimeout": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.identifier": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isRoamingAvailable": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isValid": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.name": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.purpose": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.setConnectTimeout": ('int',),
-    "PySide2.QtNetwork.QNetworkConfiguration.state": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.swap": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkConfiguration.type": (),
-# class PySide2.QtNetwork.QNetworkConfigurationManager:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capabilities:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capability:
-    "PySide2.QtNetwork.QNetworkConfigurationManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.allConfigurations": ('PySide2.QtNetwork.QNetworkConfiguration.StateFlags',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.capabilities": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.configurationFromIdentifier": ('str',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.defaultConfiguration": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.isOnline": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.updateConfigurations": (),
-# class PySide2.QtNetwork.QNetworkCookie:
-# class PySide2.QtNetwork.QNetworkCookie.RawForm:
-    "PySide2.QtNetwork.QNetworkCookie.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkCookie',)],
-    "PySide2.QtNetwork.QNetworkCookie.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCookie.domain": (),
-    "PySide2.QtNetwork.QNetworkCookie.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCookie.hasSameIdentifier": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.isHttpOnly": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSecure": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSessionCookie": (),
-    "PySide2.QtNetwork.QNetworkCookie.name": (),
-    "PySide2.QtNetwork.QNetworkCookie.normalize": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookie.parseCookies": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.path": (),
-    "PySide2.QtNetwork.QNetworkCookie.setDomain": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCookie.setHttpOnly": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.setPath": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setSecure": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setValue": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.swap": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.toRawForm": ('PySide2.QtNetwork.QNetworkCookie.RawForm',),
-    "PySide2.QtNetwork.QNetworkCookie.value": (),
-# class PySide2.QtNetwork.QNetworkCookieJar:
-    "PySide2.QtNetwork.QNetworkCookieJar.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkCookieJar.allCookies": (),
-    "PySide2.QtNetwork.QNetworkCookieJar.cookiesForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookieJar.deleteCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.insertCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setAllCookies": ('typing.Sequence',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setCookiesFromUrl": ('typing.Sequence', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtNetwork.QNetworkCookieJar.updateCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.validateCookie": ('PySide2.QtNetwork.QNetworkCookie', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtNetwork.QNetworkDatagram:
-    "PySide2.QtNetwork.QNetworkDatagram.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    "PySide2.QtNetwork.QNetworkDatagram.__copy__": (),
-    "PySide2.QtNetwork.QNetworkDatagram.clear": (),
-    "PySide2.QtNetwork.QNetworkDatagram.data": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.hopLimit": (),
-    "PySide2.QtNetwork.QNetworkDatagram.interfaceIndex": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isNull": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isValid": (),
-    "PySide2.QtNetwork.QNetworkDatagram.makeReply": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.senderAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.senderPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.setDestination": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.setHopLimit": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setInterfaceIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setSender": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.swap": ('PySide2.QtNetwork.QNetworkDatagram',),
-# class PySide2.QtNetwork.QNetworkDiskCache:
-    "PySide2.QtNetwork.QNetworkDiskCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheDirectory": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.clear": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.expire": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.fileMetaData": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QNetworkDiskCache.maximumCacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkDiskCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setCacheDirectory": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setMaximumCacheSize": ('int',),
-    "PySide2.QtNetwork.QNetworkDiskCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QNetworkInterface:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlag:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlags:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceType:
-    "PySide2.QtNetwork.QNetworkInterface.__init__": [(), ('PySide2.QtNetwork.QNetworkInterface',)],
-    "PySide2.QtNetwork.QNetworkInterface.__copy__": (),
-    "PySide2.QtNetwork.QNetworkInterface.addressEntries": (),
-    "PySide2.QtNetwork.QNetworkInterface.allAddresses": (),
-    "PySide2.QtNetwork.QNetworkInterface.allInterfaces": (),
-    "PySide2.QtNetwork.QNetworkInterface.flags": (),
-    "PySide2.QtNetwork.QNetworkInterface.hardwareAddress": (),
-    "PySide2.QtNetwork.QNetworkInterface.humanReadableName": (),
-    "PySide2.QtNetwork.QNetworkInterface.index": (),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceIndexFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceNameFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.isValid": (),
-    "PySide2.QtNetwork.QNetworkInterface.maximumTransmissionUnit": (),
-    "PySide2.QtNetwork.QNetworkInterface.name": (),
-    "PySide2.QtNetwork.QNetworkInterface.swap": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QNetworkInterface.type": (),
-# class PySide2.QtNetwork.QNetworkProxy:
-# class PySide2.QtNetwork.QNetworkProxy.Capabilities:
-# class PySide2.QtNetwork.QNetworkProxy.Capability:
-# class PySide2.QtNetwork.QNetworkProxy.ProxyType:
-    "PySide2.QtNetwork.QNetworkProxy.__init__": [(), ('PySide2.QtNetwork.QNetworkProxy',), ('PySide2.QtNetwork.QNetworkProxy.ProxyType', 'str', 'int', 'str', 'str')],
-    "PySide2.QtNetwork.QNetworkProxy.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxy.applicationProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.capabilities": (),
-    "PySide2.QtNetwork.QNetworkProxy.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkProxy.hostName": (),
-    "PySide2.QtNetwork.QNetworkProxy.isCachingProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.isTransparentProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.password": (),
-    "PySide2.QtNetwork.QNetworkProxy.port": (),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkProxy.setApplicationProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.setCapabilities": ('PySide2.QtNetwork.QNetworkProxy.Capabilities',),
-    "PySide2.QtNetwork.QNetworkProxy.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkProxy.setHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPassword": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxy.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkProxy.setType": ('PySide2.QtNetwork.QNetworkProxy.ProxyType',),
-    "PySide2.QtNetwork.QNetworkProxy.setUser": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.swap": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.type": (),
-    "PySide2.QtNetwork.QNetworkProxy.user": (),
-# class PySide2.QtNetwork.QNetworkProxyFactory:
-    "PySide2.QtNetwork.QNetworkProxyFactory.__init__": (),
-    "PySide2.QtNetwork.QNetworkProxyFactory.proxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.queryProxy": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setApplicationProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration": ('bool',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.systemProxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.usesSystemConfiguration": (),
-# class PySide2.QtNetwork.QNetworkProxyQuery:
-# class PySide2.QtNetwork.QNetworkProxyQuery.QueryType:
-    "PySide2.QtNetwork.QNetworkProxyQuery.__init__": [(), ('PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkProxyQuery',), ('int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType')],
-    "PySide2.QtNetwork.QNetworkProxyQuery.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.localPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.networkConfiguration": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerHostName": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.protocolTag": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.queryType": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setNetworkConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setQueryType": ('PySide2.QtNetwork.QNetworkProxyQuery.QueryType',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.swap": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.url": (),
-# class PySide2.QtNetwork.QNetworkReply:
-# class PySide2.QtNetwork.QNetworkReply.NetworkError:
-    "PySide2.QtNetwork.QNetworkReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkReply.abort": (),
-    "PySide2.QtNetwork.QNetworkReply.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute',),
-    "PySide2.QtNetwork.QNetworkReply.close": (),
-    "PySide2.QtNetwork.QNetworkReply.error": (),
-    "PySide2.QtNetwork.QNetworkReply.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrors": [(), ('typing.Sequence',)],
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrorsImplementation": ('typing.Sequence',),
-    "PySide2.QtNetwork.QNetworkReply.isFinished": (),
-    "PySide2.QtNetwork.QNetworkReply.isRunning": (),
-    "PySide2.QtNetwork.QNetworkReply.isSequential": (),
-    "PySide2.QtNetwork.QNetworkReply.manager": (),
-    "PySide2.QtNetwork.QNetworkReply.operation": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderPairs": (),
-    "PySide2.QtNetwork.QNetworkReply.readBufferSize": (),
-    "PySide2.QtNetwork.QNetworkReply.request": (),
-    "PySide2.QtNetwork.QNetworkReply.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setError": ('PySide2.QtNetwork.QNetworkReply.NetworkError', 'str'),
-    "PySide2.QtNetwork.QNetworkReply.setFinished": ('bool',),
-    "PySide2.QtNetwork.QNetworkReply.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setOperation": ('PySide2.QtNetwork.QNetworkAccessManager.Operation',),
-    "PySide2.QtNetwork.QNetworkReply.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkReply.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QNetworkReply.setRequest": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkReply.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkReply.sslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.url": (),
-    "PySide2.QtNetwork.QNetworkReply.writeData": ('bytes', 'int'),
-# class PySide2.QtNetwork.QNetworkRequest:
-# class PySide2.QtNetwork.QNetworkRequest.Attribute:
-# class PySide2.QtNetwork.QNetworkRequest.CacheLoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.KnownHeaders:
-# class PySide2.QtNetwork.QNetworkRequest.LoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.Priority:
-# class PySide2.QtNetwork.QNetworkRequest.RedirectPolicy:
-    "PySide2.QtNetwork.QNetworkRequest.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtNetwork.QNetworkRequest.__copy__": (),
-    "PySide2.QtNetwork.QNetworkRequest.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkRequest.maximumRedirectsAllowed": (),
-    "PySide2.QtNetwork.QNetworkRequest.originatingObject": (),
-    "PySide2.QtNetwork.QNetworkRequest.peerVerifyName": (),
-    "PySide2.QtNetwork.QNetworkRequest.priority": (),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkRequest.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setMaximumRedirectsAllowed": ('int',),
-    "PySide2.QtNetwork.QNetworkRequest.setOriginatingObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkRequest.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QNetworkRequest.setPriority": ('PySide2.QtNetwork.QNetworkRequest.Priority',),
-    "PySide2.QtNetwork.QNetworkRequest.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkRequest.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkRequest.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkRequest.swap": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkRequest.url": (),
-# class PySide2.QtNetwork.QNetworkSession:
-# class PySide2.QtNetwork.QNetworkSession.SessionError:
-# class PySide2.QtNetwork.QNetworkSession.State:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicies:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicy:
-    "PySide2.QtNetwork.QNetworkSession.__init__": ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QNetworkSession.accept": (),
-    "PySide2.QtNetwork.QNetworkSession.activeTime": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesReceived": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesWritten": (),
-    "PySide2.QtNetwork.QNetworkSession.close": (),
-    "PySide2.QtNetwork.QNetworkSession.configuration": (),
-    "PySide2.QtNetwork.QNetworkSession.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.error": (),
-    "PySide2.QtNetwork.QNetworkSession.errorString": (),
-    "PySide2.QtNetwork.QNetworkSession.ignore": (),
-    "PySide2.QtNetwork.QNetworkSession.interface": (),
-    "PySide2.QtNetwork.QNetworkSession.isOpen": (),
-    "PySide2.QtNetwork.QNetworkSession.migrate": (),
-    "PySide2.QtNetwork.QNetworkSession.open": (),
-    "PySide2.QtNetwork.QNetworkSession.reject": (),
-    "PySide2.QtNetwork.QNetworkSession.sessionProperty": ('str',),
-    "PySide2.QtNetwork.QNetworkSession.setSessionProperty": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkSession.state": (),
-    "PySide2.QtNetwork.QNetworkSession.stop": (),
-    "PySide2.QtNetwork.QNetworkSession.usagePolicies": (),
-    "PySide2.QtNetwork.QNetworkSession.waitForOpened": ('int',),
-# class PySide2.QtNetwork.QOcspCertificateStatus:
-# class PySide2.QtNetwork.QOcspResponse:
-    "PySide2.QtNetwork.QOcspResponse.__init__": [(), ('PySide2.QtNetwork.QOcspResponse',)],
-    "PySide2.QtNetwork.QOcspResponse.__copy__": (),
-    "PySide2.QtNetwork.QOcspResponse.certificateStatus": (),
-    "PySide2.QtNetwork.QOcspResponse.revocationReason": (),
-    "PySide2.QtNetwork.QOcspResponse.subject": (),
-    "PySide2.QtNetwork.QOcspResponse.swap": ('PySide2.QtNetwork.QOcspResponse',),
-# class PySide2.QtNetwork.QOcspRevocationReason:
-# class PySide2.QtNetwork.QPasswordDigestor:
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf1": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf2": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-# class PySide2.QtNetwork.QSsl:
-# class PySide2.QtNetwork.QSsl.AlternativeNameEntryType:
-# class PySide2.QtNetwork.QSsl.EncodingFormat:
-# class PySide2.QtNetwork.QSsl.KeyAlgorithm:
-# class PySide2.QtNetwork.QSsl.KeyType:
-# class PySide2.QtNetwork.QSsl.SslOption:
-# class PySide2.QtNetwork.QSsl.SslOptions:
-# class PySide2.QtNetwork.QSsl.SslProtocol:
-# class PySide2.QtNetwork.QSslCertificate:
-# class PySide2.QtNetwork.QSslCertificate.SubjectInfo:
-    "PySide2.QtNetwork.QSslCertificate.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtNetwork.QSslCertificate',)],
-    "PySide2.QtNetwork.QSslCertificate.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificate.clear": (),
-    "PySide2.QtNetwork.QSslCertificate.digest": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtNetwork.QSslCertificate.effectiveDate": (),
-    "PySide2.QtNetwork.QSslCertificate.expiryDate": (),
-    "PySide2.QtNetwork.QSslCertificate.extensions": (),
-    "PySide2.QtNetwork.QSslCertificate.fromData": ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromDevice": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromPath": ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'),
-    "PySide2.QtNetwork.QSslCertificate.handle": (),
-    "PySide2.QtNetwork.QSslCertificate.importPkcs12": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSslKey', 'PySide2.QtNetwork.QSslCertificate', 'typing.Sequence', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QSslCertificate.isBlacklisted": (),
-    "PySide2.QtNetwork.QSslCertificate.isNull": (),
-    "PySide2.QtNetwork.QSslCertificate.isSelfSigned": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.issuerInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.publicKey": (),
-    "PySide2.QtNetwork.QSslCertificate.serialNumber": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectAlternativeNames": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.subjectInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.swap": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslCertificate.toDer": (),
-    "PySide2.QtNetwork.QSslCertificate.toPem": (),
-    "PySide2.QtNetwork.QSslCertificate.toText": (),
-    "PySide2.QtNetwork.QSslCertificate.verify": ('typing.Sequence', 'str'),
-    "PySide2.QtNetwork.QSslCertificate.version": (),
-# class PySide2.QtNetwork.QSslCertificateExtension:
-    "PySide2.QtNetwork.QSslCertificateExtension.__init__": [(), ('PySide2.QtNetwork.QSslCertificateExtension',)],
-    "PySide2.QtNetwork.QSslCertificateExtension.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isCritical": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isSupported": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.name": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.oid": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.swap": ('PySide2.QtNetwork.QSslCertificateExtension',),
-    "PySide2.QtNetwork.QSslCertificateExtension.value": (),
-# class PySide2.QtNetwork.QSslCipher:
-    "PySide2.QtNetwork.QSslCipher.__init__": [(), ('PySide2.QtNetwork.QSslCipher',), ('str',), ('str', 'PySide2.QtNetwork.QSsl.SslProtocol')],
-    "PySide2.QtNetwork.QSslCipher.__copy__": (),
-    "PySide2.QtNetwork.QSslCipher.authenticationMethod": (),
-    "PySide2.QtNetwork.QSslCipher.encryptionMethod": (),
-    "PySide2.QtNetwork.QSslCipher.isNull": (),
-    "PySide2.QtNetwork.QSslCipher.keyExchangeMethod": (),
-    "PySide2.QtNetwork.QSslCipher.name": (),
-    "PySide2.QtNetwork.QSslCipher.protocol": (),
-    "PySide2.QtNetwork.QSslCipher.protocolString": (),
-    "PySide2.QtNetwork.QSslCipher.supportedBits": (),
-    "PySide2.QtNetwork.QSslCipher.swap": ('PySide2.QtNetwork.QSslCipher',),
-    "PySide2.QtNetwork.QSslCipher.usedBits": (),
-# class PySide2.QtNetwork.QSslConfiguration:
-# class PySide2.QtNetwork.QSslConfiguration.NextProtocolNegotiationStatus:
-    "PySide2.QtNetwork.QSslConfiguration.__init__": [(), ('PySide2.QtNetwork.QSslConfiguration',)],
-    "PySide2.QtNetwork.QSslConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QSslConfiguration.allowedNextProtocols": (),
-    "PySide2.QtNetwork.QSslConfiguration.backendConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.caCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.ciphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultDtlsConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.diffieHellmanParameters": (),
-    "PySide2.QtNetwork.QSslConfiguration.dtlsCookieVerificationEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.ephemeralServerKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.isNull": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextNegotiatedProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextProtocolNegotiationStatus": (),
-    "PySide2.QtNetwork.QSslConfiguration.ocspStaplingEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslConfiguration.preSharedKeyIdentityHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.privateKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.protocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionCipher": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicket": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicketLifeTimeHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.setAllowedNextProtocols": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfiguration": ('typing.Dict',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfigurationOption": ('PySide2.QtCore.QByteArray', 'typing.Any'),
-    "PySide2.QtNetwork.QSslConfiguration.setCaCertificates": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslConfiguration.setCiphers": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDiffieHellmanParameters": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-    "PySide2.QtNetwork.QSslConfiguration.setDtlsCookieVerificationEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificateChain": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslConfiguration.setOcspStaplingEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslConfiguration.setPreSharedKeyIdentityHint": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setPrivateKey": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslConfiguration.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslConfiguration.setSessionTicket": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setSslOption": ('PySide2.QtNetwork.QSsl.SslOption', 'bool'),
-    "PySide2.QtNetwork.QSslConfiguration.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.swap": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.testSslOption": ('PySide2.QtNetwork.QSsl.SslOption',),
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters:
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters.Error:
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__init__": [(), ('PySide2.QtNetwork.QSslDiffieHellmanParameters',)],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__copy__": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.defaultParameters": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.error": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.errorString": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.fromEncoded": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isEmpty": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isValid": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.swap": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-# class PySide2.QtNetwork.QSslError:
-# class PySide2.QtNetwork.QSslError.SslError:
-    "PySide2.QtNetwork.QSslError.__init__": [(), ('PySide2.QtNetwork.QSslError',), ('PySide2.QtNetwork.QSslError.SslError',), ('PySide2.QtNetwork.QSslError.SslError', 'PySide2.QtNetwork.QSslCertificate')],
-    "PySide2.QtNetwork.QSslError.__copy__": (),
-    "PySide2.QtNetwork.QSslError.certificate": (),
-    "PySide2.QtNetwork.QSslError.error": (),
-    "PySide2.QtNetwork.QSslError.errorString": (),
-    "PySide2.QtNetwork.QSslError.swap": ('PySide2.QtNetwork.QSslError',),
-# class PySide2.QtNetwork.QSslKey:
-    "PySide2.QtNetwork.QSslKey.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QSslKey',), ('int', 'PySide2.QtNetwork.QSsl.KeyType')],
-    "PySide2.QtNetwork.QSslKey.__copy__": (),
-    "PySide2.QtNetwork.QSslKey.algorithm": (),
-    "PySide2.QtNetwork.QSslKey.clear": (),
-    "PySide2.QtNetwork.QSslKey.handle": (),
-    "PySide2.QtNetwork.QSslKey.isNull": (),
-    "PySide2.QtNetwork.QSslKey.length": (),
-    "PySide2.QtNetwork.QSslKey.swap": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslKey.toDer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.toPem": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.type": (),
-# class PySide2.QtNetwork.QSslPreSharedKeyAuthenticator:
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__init__": [(), ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',)],
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identity": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identityHint": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumIdentityLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumPreSharedKeyLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.preSharedKey": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setIdentity": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setPreSharedKey": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.swap": ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',),
-# class PySide2.QtNetwork.QSslSocket:
-# class PySide2.QtNetwork.QSslSocket.PeerVerifyMode:
-# class PySide2.QtNetwork.QSslSocket.SslMode:
-    "PySide2.QtNetwork.QSslSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QSslSocket.abort": (),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence',)],
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence',)],
-    "PySide2.QtNetwork.QSslSocket.atEnd": (),
-    "PySide2.QtNetwork.QSslSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.caCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.canReadLine": (),
-    "PySide2.QtNetwork.QSslSocket.ciphers": (),
-    "PySide2.QtNetwork.QSslSocket.close": (),
-    "PySide2.QtNetwork.QSslSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.connectToHostEncrypted": [('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol'), ('str', 'int', 'str', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.defaultCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.defaultCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.flush": (),
-    "PySide2.QtNetwork.QSslSocket.ignoreSslErrors": [(), ('typing.Sequence',)],
-    "PySide2.QtNetwork.QSslSocket.isEncrypted": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.mode": (),
-    "PySide2.QtNetwork.QSslSocket.ocspResponses": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyName": (),
-    "PySide2.QtNetwork.QSslSocket.privateKey": (),
-    "PySide2.QtNetwork.QSslSocket.protocol": (),
-    "PySide2.QtNetwork.QSslSocket.readData": ('bytes', 'int'),
-    "PySide2.QtNetwork.QSslSocket.resume": (),
-    "PySide2.QtNetwork.QSslSocket.sessionCipher": (),
-    "PySide2.QtNetwork.QSslSocket.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslSocket.setCaCertificates": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslSocket.setCiphers": [('str',), ('typing.Sequence',)],
-    "PySide2.QtNetwork.QSslSocket.setDefaultCaCertificates": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslSocket.setDefaultCiphers": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificate": [('PySide2.QtNetwork.QSslCertificate',), ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificateChain": ('typing.Sequence',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QSslSocket.setPrivateKey": [('PySide2.QtNetwork.QSslKey',), ('str', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtNetwork.QSslSocket.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QSslSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QSslSocket.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QSslSocket.sslConfiguration": (),
-    "PySide2.QtNetwork.QSslSocket.sslErrors": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.startClientEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.startServerEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.supportsSsl": (),
-    "PySide2.QtNetwork.QSslSocket.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForEncrypted": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QSslSocket.writeData": ('bytes', 'int'),
-# class PySide2.QtNetwork.QTcpServer:
-    "PySide2.QtNetwork.QTcpServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QTcpServer.addPendingConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtNetwork.QTcpServer.close": (),
-    "PySide2.QtNetwork.QTcpServer.errorString": (),
-    "PySide2.QtNetwork.QTcpServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QTcpServer.isListening": (),
-    "PySide2.QtNetwork.QTcpServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QTcpServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QTcpServer.pauseAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.proxy": (),
-    "PySide2.QtNetwork.QTcpServer.resumeAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.serverAddress": (),
-    "PySide2.QtNetwork.QTcpServer.serverError": (),
-    "PySide2.QtNetwork.QTcpServer.serverPort": (),
-    "PySide2.QtNetwork.QTcpServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QTcpServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QTcpServer.setSocketDescriptor": ('int',),
-    "PySide2.QtNetwork.QTcpServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QTcpServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QTcpSocket:
-    "PySide2.QtNetwork.QTcpSocket.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtNetwork.QUdpSocket:
-    "PySide2.QtNetwork.QUdpSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QUdpSocket.hasPendingDatagrams": (),
-    "PySide2.QtNetwork.QUdpSocket.joinMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.leaveMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.multicastInterface": (),
-    "PySide2.QtNetwork.QUdpSocket.pendingDatagramSize": (),
-    "PySide2.QtNetwork.QUdpSocket.readDatagram": ('bytes', 'int', 'PySide2.QtNetwork.QHostAddress'),
-    "PySide2.QtNetwork.QUdpSocket.receiveDatagram": ('int',),
-    "PySide2.QtNetwork.QUdpSocket.setMulticastInterface": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QUdpSocket.writeDatagram": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    }) if "PySide2.QtNetwork" in sys.modules else None
-# Module PySide2.QtTest
-sig_dict.update({
-# class PySide2.QtTest.QTest:
-# class PySide2.QtTest.QTest.KeyAction:
-# class PySide2.QtTest.QTest.MouseAction:
-# class PySide2.QtTest.QTest.QBenchmarkMetric:
-# class PySide2.QtTest.QTest.QTouchEventSequence:
-    "PySide2.QtTest.QTest.QTouchEventSequence.commit": ('bool',),
-    "PySide2.QtTest.QTest.QTouchEventSequence.move": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.press": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.release": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.stationary": ('int',),
-# class PySide2.QtTest.QTest.TestFailMode:
-    "PySide2.QtTest.QTest.addColumnInternal": ('int', 'bytes'),
-    "PySide2.QtTest.QTest.asciiToKey": ('int',),
-    "PySide2.QtTest.QTest.compare_ptr_helper": ('int', 'int', 'bytes', 'bytes', 'bytes', 'int'),
-    "PySide2.QtTest.QTest.compare_string_helper": ('bytes', 'bytes', 'bytes', 'bytes', 'bytes', 'int'),
-    "PySide2.QtTest.QTest.createTouchDevice": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtTest.QTest.currentAppName": (),
-    "PySide2.QtTest.QTest.currentDataTag": (),
-    "PySide2.QtTest.QTest.currentTestFailed": (),
-    "PySide2.QtTest.QTest.currentTestFunction": (),
-    "PySide2.QtTest.QTest.ignoreMessage": [('PySide2.QtCore.QtMsgType', 'PySide2.QtCore.QRegularExpression'), ('PySide2.QtCore.QtMsgType', 'bytes')],
-    "PySide2.QtTest.QTest.keyClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyClicks": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'),
-    "PySide2.QtTest.QTest.keyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyPress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keySequence": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtTest.QTest.keyToAscii": ('PySide2.QtCore.Qt.Key',),
-    "PySide2.QtTest.QTest.mouseClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseDClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseEvent": [('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseMove": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mousePress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.qCleanup": (),
-    "PySide2.QtTest.QTest.qElementData": ('bytes', 'int'),
-    "PySide2.QtTest.QTest.qExpectFail": ('bytes', 'bytes', 'PySide2.QtTest.QTest.TestFailMode', 'bytes', 'int'),
-    "PySide2.QtTest.QTest.qFindTestData": [('bytes', 'bytes', 'int', 'bytes'), ('str', 'bytes', 'int', 'bytes')],
-    "PySide2.QtTest.QTest.qGlobalData": ('bytes', 'int'),
-    "PySide2.QtTest.QTest.qRun": (),
-    "PySide2.QtTest.QTest.qSkip": ('bytes', 'bytes', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowActive": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowExposed": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.sendKeyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.setBenchmarkResult": ('float', 'PySide2.QtTest.QTest.QBenchmarkMetric'),
-    "PySide2.QtTest.QTest.setMainSourcePath": ('bytes', 'bytes'),
-    "PySide2.QtTest.QTest.simulateEvent": [('PySide2.QtGui.QWindow', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'), ('PySide2.QtWidgets.QWidget', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtTest.QTest.testObject": (),
-    "PySide2.QtTest.QTest.toPrettyCString": ('bytes', 'int'),
-    "PySide2.QtTest.QTest.touchEvent": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QTouchDevice', 'bool'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QTouchDevice', 'bool')],
-    }) if "PySide2.QtTest" in sys.modules else None
-# Module PySide2.QtConcurrent
-sig_dict.update({
-# class PySide2.QtConcurrent.QtConcurrent:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOption:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOptions:
-# class PySide2.QtConcurrent.QtConcurrent.ThreadFunctionResult:
-    }) if "PySide2.QtConcurrent" in sys.modules else None
-# Module PySide2.QtWinExtras
-sig_dict.update({
-# class PySide2.QtWinExtras.QWinColorizationChangeEvent:
-    "PySide2.QtWinExtras.QWinColorizationChangeEvent.__init__": ('int', 'bool'),
-    "PySide2.QtWinExtras.QWinColorizationChangeEvent.color": (),
-    "PySide2.QtWinExtras.QWinColorizationChangeEvent.opaqueBlend": (),
-# class PySide2.QtWinExtras.QWinCompositionChangeEvent:
-    "PySide2.QtWinExtras.QWinCompositionChangeEvent.__init__": ('bool',),
-    "PySide2.QtWinExtras.QWinCompositionChangeEvent.isCompositionEnabled": (),
-# class PySide2.QtWinExtras.QWinEvent:
-    "PySide2.QtWinExtras.QWinEvent.__init__": ('int',),
-# class PySide2.QtWinExtras.QWinJumpList:
-    "PySide2.QtWinExtras.QWinJumpList.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWinExtras.QWinJumpList.addCategory": [('PySide2.QtWinExtras.QWinJumpListCategory',), ('str', 'typing.Sequence')],
-    "PySide2.QtWinExtras.QWinJumpList.categories": (),
-    "PySide2.QtWinExtras.QWinJumpList.clear": (),
-    "PySide2.QtWinExtras.QWinJumpList.frequent": (),
-    "PySide2.QtWinExtras.QWinJumpList.identifier": (),
-    "PySide2.QtWinExtras.QWinJumpList.recent": (),
-    "PySide2.QtWinExtras.QWinJumpList.setIdentifier": ('str',),
-    "PySide2.QtWinExtras.QWinJumpList.tasks": (),
-# class PySide2.QtWinExtras.QWinJumpListCategory:
-# class PySide2.QtWinExtras.QWinJumpListCategory.Type:
-    "PySide2.QtWinExtras.QWinJumpListCategory.__init__": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListCategory.addDestination": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListCategory.addItem": ('PySide2.QtWinExtras.QWinJumpListItem',),
-    "PySide2.QtWinExtras.QWinJumpListCategory.addLink": [('PySide2.QtGui.QIcon', 'str', 'str', 'typing.Sequence'), ('str', 'str', 'typing.Sequence')],
-    "PySide2.QtWinExtras.QWinJumpListCategory.addSeparator": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.clear": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.count": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.isEmpty": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.isVisible": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.items": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.setTitle": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListCategory.setVisible": ('bool',),
-    "PySide2.QtWinExtras.QWinJumpListCategory.title": (),
-    "PySide2.QtWinExtras.QWinJumpListCategory.type": (),
-# class PySide2.QtWinExtras.QWinJumpListItem:
-# class PySide2.QtWinExtras.QWinJumpListItem.Type:
-    "PySide2.QtWinExtras.QWinJumpListItem.__init__": ('PySide2.QtWinExtras.QWinJumpListItem.Type',),
-    "PySide2.QtWinExtras.QWinJumpListItem.arguments": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.description": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.filePath": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.icon": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.setArguments": ('typing.Sequence',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setDescription": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setFilePath": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setTitle": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setType": ('PySide2.QtWinExtras.QWinJumpListItem.Type',),
-    "PySide2.QtWinExtras.QWinJumpListItem.setWorkingDirectory": ('str',),
-    "PySide2.QtWinExtras.QWinJumpListItem.title": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.type": (),
-    "PySide2.QtWinExtras.QWinJumpListItem.workingDirectory": (),
-# class PySide2.QtWinExtras.QWinTaskbarButton:
-    "PySide2.QtWinExtras.QWinTaskbarButton.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWinExtras.QWinTaskbarButton.clearOverlayIcon": (),
-    "PySide2.QtWinExtras.QWinTaskbarButton.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWinExtras.QWinTaskbarButton.overlayAccessibleDescription": (),
-    "PySide2.QtWinExtras.QWinTaskbarButton.overlayIcon": (),
-    "PySide2.QtWinExtras.QWinTaskbarButton.progress": (),
-    "PySide2.QtWinExtras.QWinTaskbarButton.setOverlayAccessibleDescription": ('str',),
-    "PySide2.QtWinExtras.QWinTaskbarButton.setOverlayIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWinExtras.QWinTaskbarButton.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QWinTaskbarButton.window": (),
-# class PySide2.QtWinExtras.QWinTaskbarProgress:
-    "PySide2.QtWinExtras.QWinTaskbarProgress.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.hide": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.isPaused": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.isStopped": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.isVisible": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.maximum": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.minimum": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.pause": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.reset": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.resume": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setMaximum": ('int',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setMinimum": ('int',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setPaused": ('bool',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setRange": ('int', 'int'),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setValue": ('int',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.setVisible": ('bool',),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.show": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.stop": (),
-    "PySide2.QtWinExtras.QWinTaskbarProgress.value": (),
-# class PySide2.QtWinExtras.QWinThumbnailToolBar:
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.addButton": ('PySide2.QtWinExtras.QWinThumbnailToolButton',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.buttons": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.clear": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.count": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.iconicLivePreviewPixmap": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.iconicPixmapNotificationsEnabled": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.iconicThumbnailPixmap": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.removeButton": ('PySide2.QtWinExtras.QWinThumbnailToolButton',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.setButtons": ('typing.Sequence',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.setIconicLivePreviewPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.setIconicPixmapNotificationsEnabled": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.setIconicThumbnailPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QWinThumbnailToolBar.window": (),
-# class PySide2.QtWinExtras.QWinThumbnailToolButton:
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.click": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.dismissOnClick": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.icon": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.isEnabled": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.isFlat": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.isInteractive": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.isVisible": (),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setDismissOnClick": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setEnabled": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setFlat": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setInteractive": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setToolTip": ('str',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.setVisible": ('bool',),
-    "PySide2.QtWinExtras.QWinThumbnailToolButton.toolTip": (),
-# class PySide2.QtWinExtras.QtWin:
-# class PySide2.QtWinExtras.QtWin.HBitmapFormat:
-# class PySide2.QtWinExtras.QtWin.WindowFlip3DPolicy:
-    "PySide2.QtWinExtras.QtWin.colorizationColor": (),
-    "PySide2.QtWinExtras.QtWin.disableBlurBehindWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.enableBlurBehindWindow": [('PySide2.QtGui.QWindow',), ('PySide2.QtGui.QWindow', 'PySide2.QtGui.QRegion')],
-    "PySide2.QtWinExtras.QtWin.errorStringFromHresult": ('int',),
-    "PySide2.QtWinExtras.QtWin.extendFrameIntoClientArea": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.QMargins'), ('PySide2.QtGui.QWindow', 'int', 'int', 'int', 'int')],
-    "PySide2.QtWinExtras.QtWin.isCompositionEnabled": (),
-    "PySide2.QtWinExtras.QtWin.isCompositionOpaque": (),
-    "PySide2.QtWinExtras.QtWin.isWindowExcludedFromPeek": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.isWindowPeekDisallowed": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.markFullscreenWindow": ('PySide2.QtGui.QWindow', 'bool'),
-    "PySide2.QtWinExtras.QtWin.realColorizationColor": (),
-    "PySide2.QtWinExtras.QtWin.resetExtendedFrame": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.setCompositionEnabled": ('bool',),
-    "PySide2.QtWinExtras.QtWin.setCurrentProcessExplicitAppUserModelID": ('str',),
-    "PySide2.QtWinExtras.QtWin.setWindowDisallowPeek": ('PySide2.QtGui.QWindow', 'bool'),
-    "PySide2.QtWinExtras.QtWin.setWindowExcludedFromPeek": ('PySide2.QtGui.QWindow', 'bool'),
-    "PySide2.QtWinExtras.QtWin.setWindowFlip3DPolicy": ('PySide2.QtGui.QWindow', 'PySide2.QtWinExtras.QtWin.WindowFlip3DPolicy'),
-    "PySide2.QtWinExtras.QtWin.stringFromHresult": ('int',),
-    "PySide2.QtWinExtras.QtWin.taskbarActivateTab": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.taskbarActivateTabAlt": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.taskbarAddTab": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.taskbarDeleteTab": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtWinExtras.QtWin.windowFlip3DPolicy": ('PySide2.QtGui.QWindow',),
-    }) if "PySide2.QtWinExtras" in sys.modules else None
-# Module PySide2.QtXml
-sig_dict.update({
-# class PySide2.QtXml.QDomAttr:
-    "PySide2.QtXml.QDomAttr.__init__": [(), ('PySide2.QtXml.QDomAttr',)],
-    "PySide2.QtXml.QDomAttr.__copy__": (),
-    "PySide2.QtXml.QDomAttr.name": (),
-    "PySide2.QtXml.QDomAttr.nodeType": (),
-    "PySide2.QtXml.QDomAttr.ownerElement": (),
-    "PySide2.QtXml.QDomAttr.setValue": ('str',),
-    "PySide2.QtXml.QDomAttr.specified": (),
-    "PySide2.QtXml.QDomAttr.value": (),
-# class PySide2.QtXml.QDomCDATASection:
-    "PySide2.QtXml.QDomCDATASection.__init__": [(), ('PySide2.QtXml.QDomCDATASection',)],
-    "PySide2.QtXml.QDomCDATASection.__copy__": (),
-    "PySide2.QtXml.QDomCDATASection.nodeType": (),
-# class PySide2.QtXml.QDomCharacterData:
-    "PySide2.QtXml.QDomCharacterData.__init__": [(), ('PySide2.QtXml.QDomCharacterData',)],
-    "PySide2.QtXml.QDomCharacterData.__copy__": (),
-    "PySide2.QtXml.QDomCharacterData.appendData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.data": (),
-    "PySide2.QtXml.QDomCharacterData.deleteData": ('int', 'int'),
-    "PySide2.QtXml.QDomCharacterData.insertData": ('int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.length": (),
-    "PySide2.QtXml.QDomCharacterData.nodeType": (),
-    "PySide2.QtXml.QDomCharacterData.replaceData": ('int', 'int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.setData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.substringData": ('int', 'int'),
-# class PySide2.QtXml.QDomComment:
-    "PySide2.QtXml.QDomComment.__init__": [(), ('PySide2.QtXml.QDomComment',)],
-    "PySide2.QtXml.QDomComment.__copy__": (),
-    "PySide2.QtXml.QDomComment.nodeType": (),
-# class PySide2.QtXml.QDomDocument:
-    "PySide2.QtXml.QDomDocument.__init__": [(), ('PySide2.QtXml.QDomDocument',), ('PySide2.QtXml.QDomDocumentType',), ('str',)],
-    "PySide2.QtXml.QDomDocument.__copy__": (),
-    "PySide2.QtXml.QDomDocument.createAttribute": ('str',),
-    "PySide2.QtXml.QDomDocument.createAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createCDATASection": ('str',),
-    "PySide2.QtXml.QDomDocument.createComment": ('str',),
-    "PySide2.QtXml.QDomDocument.createDocumentFragment": (),
-    "PySide2.QtXml.QDomDocument.createElement": ('str',),
-    "PySide2.QtXml.QDomDocument.createElementNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createEntityReference": ('str',),
-    "PySide2.QtXml.QDomDocument.createProcessingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createTextNode": ('str',),
-    "PySide2.QtXml.QDomDocument.doctype": (),
-    "PySide2.QtXml.QDomDocument.documentElement": (),
-    "PySide2.QtXml.QDomDocument.elementById": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.implementation": (),
-    "PySide2.QtXml.QDomDocument.importNode": ('PySide2.QtXml.QDomNode', 'bool'),
-    "PySide2.QtXml.QDomDocument.nodeType": (),
-    "PySide2.QtXml.QDomDocument.setContent": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'bool'), ('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QIODevice', 'bool'), ('PySide2.QtXml.QXmlInputSource', 'PySide2.QtXml.QXmlReader'), ('PySide2.QtXml.QXmlInputSource', 'bool'), ('str',), ('str', 'bool')],
-    "PySide2.QtXml.QDomDocument.toByteArray": ('int',),
-    "PySide2.QtXml.QDomDocument.toString": ('int',),
-# class PySide2.QtXml.QDomDocumentFragment:
-    "PySide2.QtXml.QDomDocumentFragment.__init__": [(), ('PySide2.QtXml.QDomDocumentFragment',)],
-    "PySide2.QtXml.QDomDocumentFragment.__copy__": (),
-    "PySide2.QtXml.QDomDocumentFragment.nodeType": (),
-# class PySide2.QtXml.QDomDocumentType:
-    "PySide2.QtXml.QDomDocumentType.__init__": [(), ('PySide2.QtXml.QDomDocumentType',)],
-    "PySide2.QtXml.QDomDocumentType.__copy__": (),
-    "PySide2.QtXml.QDomDocumentType.entities": (),
-    "PySide2.QtXml.QDomDocumentType.internalSubset": (),
-    "PySide2.QtXml.QDomDocumentType.name": (),
-    "PySide2.QtXml.QDomDocumentType.nodeType": (),
-    "PySide2.QtXml.QDomDocumentType.notations": (),
-    "PySide2.QtXml.QDomDocumentType.publicId": (),
-    "PySide2.QtXml.QDomDocumentType.systemId": (),
-# class PySide2.QtXml.QDomElement:
-    "PySide2.QtXml.QDomElement.__init__": [(), ('PySide2.QtXml.QDomElement',)],
-    "PySide2.QtXml.QDomElement.__copy__": (),
-    "PySide2.QtXml.QDomElement.attribute": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNS": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNode": ('str',),
-    "PySide2.QtXml.QDomElement.attributeNodeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributes": (),
-    "PySide2.QtXml.QDomElement.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomElement.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.hasAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.hasAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.nodeType": (),
-    "PySide2.QtXml.QDomElement.removeAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.removeAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.removeAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttribute": [('str', 'float'), ('str', 'int'), ('str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNS": [('str', 'str', 'float'), ('str', 'str', 'int'), ('str', 'str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttributeNodeNS": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setTagName": ('str',),
-    "PySide2.QtXml.QDomElement.tagName": (),
-    "PySide2.QtXml.QDomElement.text": (),
-# class PySide2.QtXml.QDomEntity:
-    "PySide2.QtXml.QDomEntity.__init__": [(), ('PySide2.QtXml.QDomEntity',)],
-    "PySide2.QtXml.QDomEntity.__copy__": (),
-    "PySide2.QtXml.QDomEntity.nodeType": (),
-    "PySide2.QtXml.QDomEntity.notationName": (),
-    "PySide2.QtXml.QDomEntity.publicId": (),
-    "PySide2.QtXml.QDomEntity.systemId": (),
-# class PySide2.QtXml.QDomEntityReference:
-    "PySide2.QtXml.QDomEntityReference.__init__": [(), ('PySide2.QtXml.QDomEntityReference',)],
-    "PySide2.QtXml.QDomEntityReference.__copy__": (),
-    "PySide2.QtXml.QDomEntityReference.nodeType": (),
-# class PySide2.QtXml.QDomImplementation:
-# class PySide2.QtXml.QDomImplementation.InvalidDataPolicy:
-    "PySide2.QtXml.QDomImplementation.__init__": [(), ('PySide2.QtXml.QDomImplementation',)],
-    "PySide2.QtXml.QDomImplementation.__copy__": (),
-    "PySide2.QtXml.QDomImplementation.createDocument": ('str', 'str', 'PySide2.QtXml.QDomDocumentType'),
-    "PySide2.QtXml.QDomImplementation.createDocumentType": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomImplementation.hasFeature": ('str', 'str'),
-    "PySide2.QtXml.QDomImplementation.invalidDataPolicy": (),
-    "PySide2.QtXml.QDomImplementation.isNull": (),
-    "PySide2.QtXml.QDomImplementation.setInvalidDataPolicy": ('PySide2.QtXml.QDomImplementation.InvalidDataPolicy',),
-# class PySide2.QtXml.QDomNamedNodeMap:
-    "PySide2.QtXml.QDomNamedNodeMap.__init__": [(), ('PySide2.QtXml.QDomNamedNodeMap',)],
-    "PySide2.QtXml.QDomNamedNodeMap.__copy__": (),
-    "PySide2.QtXml.QDomNamedNodeMap.contains": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.count": (),
-    "PySide2.QtXml.QDomNamedNodeMap.isEmpty": (),
-    "PySide2.QtXml.QDomNamedNodeMap.item": ('int',),
-    "PySide2.QtXml.QDomNamedNodeMap.length": (),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItem": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItemNS": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.size": (),
-# class PySide2.QtXml.QDomNode:
-# class PySide2.QtXml.QDomNode.EncodingPolicy:
-# class PySide2.QtXml.QDomNode.NodeType:
-    "PySide2.QtXml.QDomNode.__init__": [(), ('PySide2.QtXml.QDomNode',)],
-    "PySide2.QtXml.QDomNode.__copy__": (),
-    "PySide2.QtXml.QDomNode.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtXml.QDomNode.appendChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.attributes": (),
-    "PySide2.QtXml.QDomNode.childNodes": (),
-    "PySide2.QtXml.QDomNode.clear": (),
-    "PySide2.QtXml.QDomNode.cloneNode": ('bool',),
-    "PySide2.QtXml.QDomNode.columnNumber": (),
-    "PySide2.QtXml.QDomNode.firstChild": (),
-    "PySide2.QtXml.QDomNode.firstChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.hasAttributes": (),
-    "PySide2.QtXml.QDomNode.hasChildNodes": (),
-    "PySide2.QtXml.QDomNode.insertAfter": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.insertBefore": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.isAttr": (),
-    "PySide2.QtXml.QDomNode.isCDATASection": (),
-    "PySide2.QtXml.QDomNode.isCharacterData": (),
-    "PySide2.QtXml.QDomNode.isComment": (),
-    "PySide2.QtXml.QDomNode.isDocument": (),
-    "PySide2.QtXml.QDomNode.isDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.isDocumentType": (),
-    "PySide2.QtXml.QDomNode.isElement": (),
-    "PySide2.QtXml.QDomNode.isEntity": (),
-    "PySide2.QtXml.QDomNode.isEntityReference": (),
-    "PySide2.QtXml.QDomNode.isNotation": (),
-    "PySide2.QtXml.QDomNode.isNull": (),
-    "PySide2.QtXml.QDomNode.isProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.isSupported": ('str', 'str'),
-    "PySide2.QtXml.QDomNode.isText": (),
-    "PySide2.QtXml.QDomNode.lastChild": (),
-    "PySide2.QtXml.QDomNode.lastChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.lineNumber": (),
-    "PySide2.QtXml.QDomNode.localName": (),
-    "PySide2.QtXml.QDomNode.namedItem": ('str',),
-    "PySide2.QtXml.QDomNode.namespaceURI": (),
-    "PySide2.QtXml.QDomNode.nextSibling": (),
-    "PySide2.QtXml.QDomNode.nextSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.nodeName": (),
-    "PySide2.QtXml.QDomNode.nodeType": (),
-    "PySide2.QtXml.QDomNode.nodeValue": (),
-    "PySide2.QtXml.QDomNode.normalize": (),
-    "PySide2.QtXml.QDomNode.ownerDocument": (),
-    "PySide2.QtXml.QDomNode.parentNode": (),
-    "PySide2.QtXml.QDomNode.prefix": (),
-    "PySide2.QtXml.QDomNode.previousSibling": (),
-    "PySide2.QtXml.QDomNode.previousSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.removeChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.replaceChild": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.save": ('PySide2.QtCore.QTextStream', 'int', 'PySide2.QtXml.QDomNode.EncodingPolicy'),
-    "PySide2.QtXml.QDomNode.setNodeValue": ('str',),
-    "PySide2.QtXml.QDomNode.setPrefix": ('str',),
-    "PySide2.QtXml.QDomNode.toAttr": (),
-    "PySide2.QtXml.QDomNode.toCDATASection": (),
-    "PySide2.QtXml.QDomNode.toCharacterData": (),
-    "PySide2.QtXml.QDomNode.toComment": (),
-    "PySide2.QtXml.QDomNode.toDocument": (),
-    "PySide2.QtXml.QDomNode.toDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.toDocumentType": (),
-    "PySide2.QtXml.QDomNode.toElement": (),
-    "PySide2.QtXml.QDomNode.toEntity": (),
-    "PySide2.QtXml.QDomNode.toEntityReference": (),
-    "PySide2.QtXml.QDomNode.toNotation": (),
-    "PySide2.QtXml.QDomNode.toProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.toText": (),
-# class PySide2.QtXml.QDomNodeList:
-    "PySide2.QtXml.QDomNodeList.__init__": [(), ('PySide2.QtXml.QDomNodeList',)],
-    "PySide2.QtXml.QDomNodeList.__copy__": (),
-    "PySide2.QtXml.QDomNodeList.at": ('int',),
-    "PySide2.QtXml.QDomNodeList.count": (),
-    "PySide2.QtXml.QDomNodeList.isEmpty": (),
-    "PySide2.QtXml.QDomNodeList.item": ('int',),
-    "PySide2.QtXml.QDomNodeList.length": (),
-    "PySide2.QtXml.QDomNodeList.size": (),
-# class PySide2.QtXml.QDomNotation:
-    "PySide2.QtXml.QDomNotation.__init__": [(), ('PySide2.QtXml.QDomNotation',)],
-    "PySide2.QtXml.QDomNotation.__copy__": (),
-    "PySide2.QtXml.QDomNotation.nodeType": (),
-    "PySide2.QtXml.QDomNotation.publicId": (),
-    "PySide2.QtXml.QDomNotation.systemId": (),
-# class PySide2.QtXml.QDomProcessingInstruction:
-    "PySide2.QtXml.QDomProcessingInstruction.__init__": [(), ('PySide2.QtXml.QDomProcessingInstruction',)],
-    "PySide2.QtXml.QDomProcessingInstruction.__copy__": (),
-    "PySide2.QtXml.QDomProcessingInstruction.data": (),
-    "PySide2.QtXml.QDomProcessingInstruction.nodeType": (),
-    "PySide2.QtXml.QDomProcessingInstruction.setData": ('str',),
-    "PySide2.QtXml.QDomProcessingInstruction.target": (),
-# class PySide2.QtXml.QDomText:
-    "PySide2.QtXml.QDomText.__init__": [(), ('PySide2.QtXml.QDomText',)],
-    "PySide2.QtXml.QDomText.__copy__": (),
-    "PySide2.QtXml.QDomText.nodeType": (),
-    "PySide2.QtXml.QDomText.splitText": ('int',),
-# class PySide2.QtXml.QXmlAttributes:
-    "PySide2.QtXml.QXmlAttributes.__init__": [(), ('PySide2.QtXml.QXmlAttributes',)],
-    "PySide2.QtXml.QXmlAttributes.__copy__": (),
-    "PySide2.QtXml.QXmlAttributes.append": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlAttributes.clear": (),
-    "PySide2.QtXml.QXmlAttributes.count": (),
-    "PySide2.QtXml.QXmlAttributes.index": [('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.length": (),
-    "PySide2.QtXml.QXmlAttributes.localName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.qName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.swap": ('PySide2.QtXml.QXmlAttributes',),
-    "PySide2.QtXml.QXmlAttributes.type": [('int',), ('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.uri": ('int',),
-    "PySide2.QtXml.QXmlAttributes.value": [('int',), ('str',), ('str', 'str')],
-# class PySide2.QtXml.QXmlContentHandler:
-    "PySide2.QtXml.QXmlContentHandler.__init__": (),
-    "PySide2.QtXml.QXmlContentHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.endDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.errorString": (),
-    "PySide2.QtXml.QXmlContentHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlContentHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.startDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlContentHandler.startPrefixMapping": ('str', 'str'),
-# class PySide2.QtXml.QXmlDTDHandler:
-    "PySide2.QtXml.QXmlDTDHandler.__init__": (),
-    "PySide2.QtXml.QXmlDTDHandler.errorString": (),
-    "PySide2.QtXml.QXmlDTDHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDTDHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-# class PySide2.QtXml.QXmlDeclHandler:
-    "PySide2.QtXml.QXmlDeclHandler.__init__": (),
-    "PySide2.QtXml.QXmlDeclHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.errorString": (),
-    "PySide2.QtXml.QXmlDeclHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.internalEntityDecl": ('str', 'str'),
-# class PySide2.QtXml.QXmlDefaultHandler:
-    "PySide2.QtXml.QXmlDefaultHandler.__init__": (),
-    "PySide2.QtXml.QXmlDefaultHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDTD": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.errorString": (),
-    "PySide2.QtXml.QXmlDefaultHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.internalEntityDecl": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-    "PySide2.QtXml.QXmlDefaultHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlDefaultHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.startDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlDefaultHandler.startEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startPrefixMapping": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlEntityResolver:
-    "PySide2.QtXml.QXmlEntityResolver.__init__": (),
-    "PySide2.QtXml.QXmlEntityResolver.errorString": (),
-    "PySide2.QtXml.QXmlEntityResolver.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-# class PySide2.QtXml.QXmlErrorHandler:
-    "PySide2.QtXml.QXmlErrorHandler.__init__": (),
-    "PySide2.QtXml.QXmlErrorHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.errorString": (),
-    "PySide2.QtXml.QXmlErrorHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlInputSource:
-    "PySide2.QtXml.QXmlInputSource.__init__": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtXml.QXmlInputSource.data": (),
-    "PySide2.QtXml.QXmlInputSource.fetchData": (),
-    "PySide2.QtXml.QXmlInputSource.fromRawData": ('PySide2.QtCore.QByteArray', 'bool'),
-    "PySide2.QtXml.QXmlInputSource.reset": (),
-    "PySide2.QtXml.QXmlInputSource.setData": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtXml.QXmlLexicalHandler:
-    "PySide2.QtXml.QXmlLexicalHandler.__init__": (),
-    "PySide2.QtXml.QXmlLexicalHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endDTD": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.errorString": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlLexicalHandler.startEntity": ('str',),
-# class PySide2.QtXml.QXmlLocator:
-    "PySide2.QtXml.QXmlLocator.__init__": (),
-    "PySide2.QtXml.QXmlLocator.columnNumber": (),
-    "PySide2.QtXml.QXmlLocator.lineNumber": (),
-# class PySide2.QtXml.QXmlNamespaceSupport:
-    "PySide2.QtXml.QXmlNamespaceSupport.__init__": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.popContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefix": ('str',),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefixes": [(), ('str',)],
-    "PySide2.QtXml.QXmlNamespaceSupport.processName": ('str', 'bool', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.pushContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.reset": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.setPrefix": ('str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.splitName": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.uri": ('str',),
-# class PySide2.QtXml.QXmlParseException:
-    "PySide2.QtXml.QXmlParseException.__init__": [('PySide2.QtXml.QXmlParseException',), ('str', 'int', 'int', 'str', 'str')],
-    "PySide2.QtXml.QXmlParseException.columnNumber": (),
-    "PySide2.QtXml.QXmlParseException.lineNumber": (),
-    "PySide2.QtXml.QXmlParseException.message": (),
-    "PySide2.QtXml.QXmlParseException.publicId": (),
-    "PySide2.QtXml.QXmlParseException.systemId": (),
-# class PySide2.QtXml.QXmlReader:
-    "PySide2.QtXml.QXmlReader.__init__": (),
-    "PySide2.QtXml.QXmlReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlReader.contentHandler": (),
-    "PySide2.QtXml.QXmlReader.declHandler": (),
-    "PySide2.QtXml.QXmlReader.entityResolver": (),
-    "PySide2.QtXml.QXmlReader.errorHandler": (),
-    "PySide2.QtXml.QXmlReader.feature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlReader.parse": ('PySide2.QtXml.QXmlInputSource',),
-    "PySide2.QtXml.QXmlReader.property": ('str',),
-    "PySide2.QtXml.QXmlReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlReader.setProperty": ('str', 'int'),
-# class PySide2.QtXml.QXmlSimpleReader:
-    "PySide2.QtXml.QXmlSimpleReader.__init__": (),
-    "PySide2.QtXml.QXmlSimpleReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.contentHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.declHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.entityResolver": (),
-    "PySide2.QtXml.QXmlSimpleReader.errorHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.feature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.parse": [('PySide2.QtXml.QXmlInputSource',), ('PySide2.QtXml.QXmlInputSource', 'bool')],
-    "PySide2.QtXml.QXmlSimpleReader.parseContinue": (),
-    "PySide2.QtXml.QXmlSimpleReader.property": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlSimpleReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlSimpleReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setProperty": ('str', 'int'),
-    }) if "PySide2.QtXml" in sys.modules else None
-# Module PySide2.QtXmlPatterns
-sig_dict.update({
-# class PySide2.QtXmlPatterns.QAbstractMessageHandler:
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.handleMessage": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.message": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-# class PySide2.QtXmlPatterns.QAbstractUriResolver:
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.resolve": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.NodeCopySetting:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis:
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.attributes": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.baseUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.compareOrder": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.createIndex": [('int',), ('int', 'int')],
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.documentUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.elementById": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.isDeepEqual": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.kind": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.name": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceBindings": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceForPrefix": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode")'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nextFromSimpleAxis": ('PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nodesByIdref": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.root": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sendNamespaces": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QAbstractXmlReceiver'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sourceLocation": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.stringValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.typedValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-# class PySide2.QtXmlPatterns.QAbstractXmlReceiver:
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.characters": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.comment": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endElement": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.whitespaceOnly": ('str',),
-# class PySide2.QtXmlPatterns.QSourceLocation:
-    "PySide2.QtXmlPatterns.QSourceLocation.__init__": [(), ('PySide2.QtCore.QUrl', 'int', 'int'), ('PySide2.QtXmlPatterns.QSourceLocation',)],
-    "PySide2.QtXmlPatterns.QSourceLocation.__copy__": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.column": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.isNull": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.line": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.setColumn": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setLine": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setUri": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtXmlPatterns.QSourceLocation.uri": (),
-# class PySide2.QtXmlPatterns.QXmlFormatter:
-    "PySide2.QtXmlPatterns.QXmlFormatter.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.indentationDepth": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.setIndentationDepth": ('int',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startOfSequence": (),
-# class PySide2.QtXmlPatterns.QXmlItem:
-    "PySide2.QtXmlPatterns.QXmlItem.__init__": [(), ('PySide2.QtXmlPatterns.QXmlItem',), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',), ('typing.Any',)],
-    "PySide2.QtXmlPatterns.QXmlItem.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNode": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toNodeModelIndex": (),
-# class PySide2.QtXmlPatterns.QXmlName:
-    "PySide2.QtXmlPatterns.QXmlName.__init__": [(), ('PySide2.QtXmlPatterns.QXmlName',), ('PySide2.QtXmlPatterns.QXmlNamePool', 'str', 'str', 'str')],
-    "PySide2.QtXmlPatterns.QXmlName.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlName.fromClarkName": ('str', 'PySide2.QtXmlPatterns.QXmlNamePool'),
-    "PySide2.QtXmlPatterns.QXmlName.isNCName": ('str',),
-    "PySide2.QtXmlPatterns.QXmlName.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlName.localName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.namespaceUri": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.prefix": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.toClarkName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-# class PySide2.QtXmlPatterns.QXmlNamePool:
-    "PySide2.QtXmlPatterns.QXmlNamePool.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',)],
-    "PySide2.QtXmlPatterns.QXmlNamePool.__copy__": (),
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.DocumentOrder:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.NodeKind:
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',)],
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.additionalData": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.data": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.internalPointer": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.model": (),
-# class PySide2.QtXmlPatterns.QXmlQuery:
-# class PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage:
-    "PySide2.QtXmlPatterns.QXmlQuery.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',), ('PySide2.QtXmlPatterns.QXmlQuery',), ('PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage', 'PySide2.QtXmlPatterns.QXmlNamePool')],
-    "PySide2.QtXmlPatterns.QXmlQuery.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.bindVariable": [('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtCore.QIODevice'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlItem'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlQuery'), ('str', 'PySide2.QtCore.QIODevice'), ('str', 'PySide2.QtXmlPatterns.QXmlItem'), ('str', 'PySide2.QtXmlPatterns.QXmlQuery')],
-    "PySide2.QtXmlPatterns.QXmlQuery.evaluateTo": [('PySide2.QtCore.QIODevice',), ('PySide2.QtXmlPatterns.QAbstractXmlReceiver',), ('PySide2.QtXmlPatterns.QXmlResultItems',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.initialTemplateName": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.queryLanguage": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.setFocus": [('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QUrl',), ('PySide2.QtXmlPatterns.QXmlItem',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setInitialTemplateName": [('PySide2.QtXmlPatterns.QXmlName',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlQuery.setQuery": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'), ('str', 'PySide2.QtCore.QUrl')],
-    "PySide2.QtXmlPatterns.QXmlQuery.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlQuery.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlResultItems:
-    "PySide2.QtXmlPatterns.QXmlResultItems.__init__": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.current": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.hasError": (),
-# class PySide2.QtXmlPatterns.QXmlSchema:
-    "PySide2.QtXmlPatterns.QXmlSchema.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.documentUri": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.load": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchema.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchema.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlSchemaValidator:
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.schema": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setSchema": ('PySide2.QtXmlPatterns.QXmlSchema',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.uriResolver": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.validate": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-# class PySide2.QtXmlPatterns.QXmlSerializer:
-    "PySide2.QtXmlPatterns.QXmlSerializer.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.codec": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.outputDevice": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startOfSequence": (),
-    }) if "PySide2.QtXmlPatterns" in sys.modules else None
-# Module PySide2.QtHelp
-sig_dict.update({
-# class PySide2.QtHelp.QCompressedHelpInfo:
-    "PySide2.QtHelp.QCompressedHelpInfo.__init__": [(), ('PySide2.QtHelp.QCompressedHelpInfo',)],
-    "PySide2.QtHelp.QCompressedHelpInfo.__copy__": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.component": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.fromCompressedHelpFile": ('str',),
-    "PySide2.QtHelp.QCompressedHelpInfo.namespaceName": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.swap": ('PySide2.QtHelp.QCompressedHelpInfo',),
-    "PySide2.QtHelp.QCompressedHelpInfo.version": (),
-# class PySide2.QtHelp.QHelpContentItem:
-    "PySide2.QtHelp.QHelpContentItem.__copy__": (),
-    "PySide2.QtHelp.QHelpContentItem.child": ('int',),
-    "PySide2.QtHelp.QHelpContentItem.childCount": (),
-    "PySide2.QtHelp.QHelpContentItem.childPosition": ('PySide2.QtHelp.QHelpContentItem',),
-    "PySide2.QtHelp.QHelpContentItem.parent": (),
-    "PySide2.QtHelp.QHelpContentItem.row": (),
-    "PySide2.QtHelp.QHelpContentItem.title": (),
-    "PySide2.QtHelp.QHelpContentItem.url": (),
-# class PySide2.QtHelp.QHelpContentModel:
-    "PySide2.QtHelp.QHelpContentModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.contentItemAt": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.createContents": ('str',),
-    "PySide2.QtHelp.QHelpContentModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtHelp.QHelpContentModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtHelp.QHelpContentModel.isCreatingContents": (),
-    "PySide2.QtHelp.QHelpContentModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtHelp.QHelpContentModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtHelp.QHelpContentWidget:
-    "PySide2.QtHelp.QHelpContentWidget.indexOf": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtHelp.QHelpEngine:
-    "PySide2.QtHelp.QHelpEngine.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngine.contentModel": (),
-    "PySide2.QtHelp.QHelpEngine.contentWidget": (),
-    "PySide2.QtHelp.QHelpEngine.indexModel": (),
-    "PySide2.QtHelp.QHelpEngine.indexWidget": (),
-    "PySide2.QtHelp.QHelpEngine.searchEngine": (),
-# class PySide2.QtHelp.QHelpEngineCore:
-    "PySide2.QtHelp.QHelpEngineCore.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngineCore.addCustomFilter": ('str', 'typing.Sequence'),
-    "PySide2.QtHelp.QHelpEngineCore.autoSaveFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.collectionFile": (),
-    "PySide2.QtHelp.QHelpEngineCore.copyCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.currentFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.customFilters": (),
-    "PySide2.QtHelp.QHelpEngineCore.customValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.documentationFileName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.error": (),
-    "PySide2.QtHelp.QHelpEngineCore.fileData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.files": [('str', 'str', 'str'), ('str', 'typing.Sequence', 'str')],
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributeSets": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributes": [(), ('str',)],
-    "PySide2.QtHelp.QHelpEngineCore.filterEngine": (),
-    "PySide2.QtHelp.QHelpEngineCore.findFile": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForIdentifier": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForKeyword": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.metaData": ('str', 'str'),
-    "PySide2.QtHelp.QHelpEngineCore.namespaceName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registerDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registeredDocumentations": (),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomValue": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setAutoSaveFilter": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCurrentFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCustomValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.setUsesFilterEngine": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setupData": (),
-    "PySide2.QtHelp.QHelpEngineCore.unregisterDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.usesFilterEngine": (),
-# class PySide2.QtHelp.QHelpFilterData:
-    "PySide2.QtHelp.QHelpFilterData.__init__": [(), ('PySide2.QtHelp.QHelpFilterData',)],
-    "PySide2.QtHelp.QHelpFilterData.__copy__": (),
-    "PySide2.QtHelp.QHelpFilterData.components": (),
-    "PySide2.QtHelp.QHelpFilterData.setComponents": ('typing.Sequence',),
-    "PySide2.QtHelp.QHelpFilterData.setVersions": ('typing.Sequence',),
-    "PySide2.QtHelp.QHelpFilterData.swap": ('PySide2.QtHelp.QHelpFilterData',),
-    "PySide2.QtHelp.QHelpFilterData.versions": (),
-# class PySide2.QtHelp.QHelpFilterEngine:
-    "PySide2.QtHelp.QHelpFilterEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore',),
-    "PySide2.QtHelp.QHelpFilterEngine.activeFilter": (),
-    "PySide2.QtHelp.QHelpFilterEngine.availableComponents": (),
-    "PySide2.QtHelp.QHelpFilterEngine.filterData": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.filters": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToComponent": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToVersion": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespacesForFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.removeFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setActiveFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setFilterData": ('str', 'PySide2.QtHelp.QHelpFilterData'),
-# class PySide2.QtHelp.QHelpIndexModel:
-    "PySide2.QtHelp.QHelpIndexModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object'), ('str',)],
-    "PySide2.QtHelp.QHelpIndexModel.filter": ('str', 'str'),
-    "PySide2.QtHelp.QHelpIndexModel.isCreatingIndex": (),
-    "PySide2.QtHelp.QHelpIndexModel.linksForKeyword": ('str',),
-# class PySide2.QtHelp.QHelpIndexWidget:
-    "PySide2.QtHelp.QHelpIndexWidget.activateCurrentItem": (),
-    "PySide2.QtHelp.QHelpIndexWidget.filterIndices": ('str', 'str'),
-# class PySide2.QtHelp.QHelpSearchEngine:
-    "PySide2.QtHelp.QHelpSearchEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelIndexing": (),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelSearching": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hitCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hits": ('int', 'int'),
-    "PySide2.QtHelp.QHelpSearchEngine.hitsCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.query": (),
-    "PySide2.QtHelp.QHelpSearchEngine.queryWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.reindexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.resultWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.scheduleIndexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.search": [('str',), ('typing.Sequence',)],
-    "PySide2.QtHelp.QHelpSearchEngine.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResultCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResults": ('int', 'int'),
-# class PySide2.QtHelp.QHelpSearchQuery:
-# class PySide2.QtHelp.QHelpSearchQuery.FieldName:
-    "PySide2.QtHelp.QHelpSearchQuery.__init__": [(), ('PySide2.QtHelp.QHelpSearchQuery',), ('PySide2.QtHelp.QHelpSearchQuery.FieldName', 'typing.Sequence')],
-    "PySide2.QtHelp.QHelpSearchQuery.__copy__": (),
-# class PySide2.QtHelp.QHelpSearchQueryWidget:
-    "PySide2.QtHelp.QHelpSearchQueryWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.collapseExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.expandExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.isCompactMode": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.query": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setCompactMode": ('bool',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setQuery": ('typing.Sequence',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setSearchInput": ('str',),
-# class PySide2.QtHelp.QHelpSearchResult:
-    "PySide2.QtHelp.QHelpSearchResult.__init__": [(), ('PySide2.QtCore.QUrl', 'str', 'str'), ('PySide2.QtHelp.QHelpSearchResult',)],
-    "PySide2.QtHelp.QHelpSearchResult.snippet": (),
-    "PySide2.QtHelp.QHelpSearchResult.title": (),
-    "PySide2.QtHelp.QHelpSearchResult.url": (),
-# class PySide2.QtHelp.QHelpSearchResultWidget:
-    "PySide2.QtHelp.QHelpSearchResultWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchResultWidget.linkAt": ('PySide2.QtCore.QPoint',),
-    }) if "PySide2.QtHelp" in sys.modules else None
-# Module PySide2.QtMultimedia
-sig_dict.update({
-# class PySide2.QtMultimedia.QAbstractAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAbstractAudioInput:
-    "PySide2.QtMultimedia.QAbstractAudioInput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioInput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAbstractAudioOutput:
-    "PySide2.QtMultimedia.QAbstractAudioOutput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAbstractVideoBuffer:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode:
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.__init__": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handle": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handleType": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.mapMode": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.release": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.unmap": (),
-# class PySide2.QtMultimedia.QAbstractVideoFilter:
-    "PySide2.QtMultimedia.QAbstractVideoFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.createFilterRunnable": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.setActive": ('bool',),
-# class PySide2.QtMultimedia.QAbstractVideoSurface:
-# class PySide2.QtMultimedia.QAbstractVideoSurface.Error:
-    "PySide2.QtMultimedia.QAbstractVideoSurface.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.error": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isFormatSupported": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nativeResolution": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nearestFormat": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.present": ('PySide2.QtMultimedia.QVideoFrame',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setError": ('PySide2.QtMultimedia.QAbstractVideoSurface.Error',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setNativeResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.start": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.stop": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.supportedPixelFormats": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.surfaceFormat": (),
-# class PySide2.QtMultimedia.QAudio:
-# class PySide2.QtMultimedia.QAudio.Error:
-# class PySide2.QtMultimedia.QAudio.Mode:
-# class PySide2.QtMultimedia.QAudio.Role:
-# class PySide2.QtMultimedia.QAudio.State:
-# class PySide2.QtMultimedia.QAudio.VolumeScale:
-    "PySide2.QtMultimedia.QAudio.convertVolume": ('float', 'PySide2.QtMultimedia.QAudio.VolumeScale', 'PySide2.QtMultimedia.QAudio.VolumeScale'),
-# class PySide2.QtMultimedia.QAudioBuffer:
-    "PySide2.QtMultimedia.QAudioBuffer.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtMultimedia.QAudioFormat', 'int'), ('PySide2.QtMultimedia.QAudioBuffer',), ('int', 'PySide2.QtMultimedia.QAudioFormat', 'int')],
-    "PySide2.QtMultimedia.QAudioBuffer.__copy__": (),
-    "PySide2.QtMultimedia.QAudioBuffer.byteCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.constData": (),
-    "PySide2.QtMultimedia.QAudioBuffer.data": (),
-    "PySide2.QtMultimedia.QAudioBuffer.duration": (),
-    "PySide2.QtMultimedia.QAudioBuffer.format": (),
-    "PySide2.QtMultimedia.QAudioBuffer.frameCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.isValid": (),
-    "PySide2.QtMultimedia.QAudioBuffer.sampleCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.startTime": (),
-# class PySide2.QtMultimedia.QAudioDecoder:
-# class PySide2.QtMultimedia.QAudioDecoder.Error:
-# class PySide2.QtMultimedia.QAudioDecoder.State:
-    "PySide2.QtMultimedia.QAudioDecoder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoder.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoder.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoder.error": (),
-    "PySide2.QtMultimedia.QAudioDecoder.errorString": (),
-    "PySide2.QtMultimedia.QAudioDecoder.hasSupport": ('str', 'typing.Sequence'),
-    "PySide2.QtMultimedia.QAudioDecoder.position": (),
-    "PySide2.QtMultimedia.QAudioDecoder.read": (),
-    "PySide2.QtMultimedia.QAudioDecoder.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoder.start": (),
-    "PySide2.QtMultimedia.QAudioDecoder.state": (),
-    "PySide2.QtMultimedia.QAudioDecoder.stop": (),
-    "PySide2.QtMultimedia.QAudioDecoder.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QAudioDecoderControl:
-    "PySide2.QtMultimedia.QAudioDecoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.position": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.read": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.start": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.state": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.stop": (),
-# class PySide2.QtMultimedia.QAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__init__": [(), ('PySide2.QtMultimedia.QAudioDeviceInfo',)],
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__copy__": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.availableDevices": ('PySide2.QtMultimedia.QAudio.Mode',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultInputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultOutputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isNull": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.nearestFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.realm": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAudioEncoderSettings:
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QAudioEncoderSettings',)],
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.channelCount": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOptions": ('typing.Dict',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setSampleRate": ('int',),
-# class PySide2.QtMultimedia.QAudioEncoderSettingsControl:
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.audioSettings": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.codecDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.supportedAudioCodecs": (),
-# class PySide2.QtMultimedia.QAudioFormat:
-# class PySide2.QtMultimedia.QAudioFormat.Endian:
-# class PySide2.QtMultimedia.QAudioFormat.SampleType:
-    "PySide2.QtMultimedia.QAudioFormat.__init__": [(), ('PySide2.QtMultimedia.QAudioFormat',)],
-    "PySide2.QtMultimedia.QAudioFormat.__copy__": (),
-    "PySide2.QtMultimedia.QAudioFormat.byteOrder": (),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesPerFrame": (),
-    "PySide2.QtMultimedia.QAudioFormat.channelCount": (),
-    "PySide2.QtMultimedia.QAudioFormat.codec": (),
-    "PySide2.QtMultimedia.QAudioFormat.durationForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.durationForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.isValid": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleSize": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleType": (),
-    "PySide2.QtMultimedia.QAudioFormat.setByteOrder": ('PySide2.QtMultimedia.QAudioFormat.Endian',),
-    "PySide2.QtMultimedia.QAudioFormat.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleSize": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleType": ('PySide2.QtMultimedia.QAudioFormat.SampleType',),
-# class PySide2.QtMultimedia.QAudioInput:
-    "PySide2.QtMultimedia.QAudioInput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.error": (),
-    "PySide2.QtMultimedia.QAudioInput.format": (),
-    "PySide2.QtMultimedia.QAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioInput.state": (),
-    "PySide2.QtMultimedia.QAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAudioInputSelectorControl:
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.activeInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.availableInputs": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.defaultInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.inputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.setActiveInput": ('str',),
-# class PySide2.QtMultimedia.QAudioOutput:
-    "PySide2.QtMultimedia.QAudioOutput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAudioOutputSelectorControl:
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.activeOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.availableOutputs": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.defaultOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.outputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.setActiveOutput": ('str',),
-# class PySide2.QtMultimedia.QAudioProbe:
-    "PySide2.QtMultimedia.QAudioProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioProbe.isActive": (),
-    "PySide2.QtMultimedia.QAudioProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QAudioRecorder:
-    "PySide2.QtMultimedia.QAudioRecorder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputs": (),
-    "PySide2.QtMultimedia.QAudioRecorder.defaultAudioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.setAudioInput": ('str',),
-# class PySide2.QtMultimedia.QAudioRoleControl:
-    "PySide2.QtMultimedia.QAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRoleControl.audioRole": (),
-    "PySide2.QtMultimedia.QAudioRoleControl.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QAudioRoleControl.supportedAudioRoles": (),
-# class PySide2.QtMultimedia.QCamera:
-# class PySide2.QtMultimedia.QCamera.CaptureMode:
-# class PySide2.QtMultimedia.QCamera.CaptureModes:
-# class PySide2.QtMultimedia.QCamera.Error:
-# class PySide2.QtMultimedia.QCamera.FrameRateRange:
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__init__": [(), ('PySide2.QtMultimedia.QCamera.FrameRateRange',), ('float', 'float')],
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__copy__": (),
-# class PySide2.QtMultimedia.QCamera.LockChangeReason:
-# class PySide2.QtMultimedia.QCamera.LockStatus:
-# class PySide2.QtMultimedia.QCamera.LockType:
-# class PySide2.QtMultimedia.QCamera.LockTypes:
-# class PySide2.QtMultimedia.QCamera.Position:
-# class PySide2.QtMultimedia.QCamera.State:
-# class PySide2.QtMultimedia.QCamera.Status:
-    "PySide2.QtMultimedia.QCamera.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QCamera.Position', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QCameraInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QCamera.availability": (),
-    "PySide2.QtMultimedia.QCamera.availableDevices": (),
-    "PySide2.QtMultimedia.QCamera.captureMode": (),
-    "PySide2.QtMultimedia.QCamera.deviceDescription": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QCamera.error": (),
-    "PySide2.QtMultimedia.QCamera.errorString": (),
-    "PySide2.QtMultimedia.QCamera.exposure": (),
-    "PySide2.QtMultimedia.QCamera.focus": (),
-    "PySide2.QtMultimedia.QCamera.imageProcessing": (),
-    "PySide2.QtMultimedia.QCamera.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.load": (),
-    "PySide2.QtMultimedia.QCamera.lockStatus": [(), ('PySide2.QtMultimedia.QCamera.LockType',)],
-    "PySide2.QtMultimedia.QCamera.requestedLocks": (),
-    "PySide2.QtMultimedia.QCamera.searchAndLock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.setViewfinder": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QCamera.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.start": (),
-    "PySide2.QtMultimedia.QCamera.state": (),
-    "PySide2.QtMultimedia.QCamera.status": (),
-    "PySide2.QtMultimedia.QCamera.stop": (),
-    "PySide2.QtMultimedia.QCamera.supportedLocks": (),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderFrameRateRanges": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderPixelFormats": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderResolutions": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.unload": (),
-    "PySide2.QtMultimedia.QCamera.unlock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraCaptureBufferFormatControl:
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.supportedBufferFormats": (),
-# class PySide2.QtMultimedia.QCameraCaptureDestinationControl:
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-# class PySide2.QtMultimedia.QCameraControl:
-# class PySide2.QtMultimedia.QCameraControl.PropertyChangeType:
-    "PySide2.QtMultimedia.QCameraControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraControl.canChangeProperty": ('PySide2.QtMultimedia.QCameraControl.PropertyChangeType', 'PySide2.QtMultimedia.QCamera.Status'),
-    "PySide2.QtMultimedia.QCameraControl.captureMode": (),
-    "PySide2.QtMultimedia.QCameraControl.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setState": ('PySide2.QtMultimedia.QCamera.State',),
-    "PySide2.QtMultimedia.QCameraControl.state": (),
-    "PySide2.QtMultimedia.QCameraControl.status": (),
-# class PySide2.QtMultimedia.QCameraExposure:
-# class PySide2.QtMultimedia.QCameraExposure.ExposureMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashModes:
-# class PySide2.QtMultimedia.QCameraExposure.MeteringMode:
-    "PySide2.QtMultimedia.QCameraExposure.aperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureCompensation": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.flashMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraExposure.isExposureModeSupported": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraExposure.isMeteringModeSupported": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.meteringMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureCompensation": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureMode": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualAperture": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualIsoSensitivity": ('int',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualShutterSpeed": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setMeteringMode": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setSpotMeteringPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraExposure.shutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.spotMeteringPoint": (),
-# class PySide2.QtMultimedia.QCameraExposureControl:
-# class PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter:
-    "PySide2.QtMultimedia.QCameraExposureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraExposureControl.actualValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.requestedValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.setValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraFeedbackControl:
-# class PySide2.QtMultimedia.QCameraFeedbackControl.EventType:
-    "PySide2.QtMultimedia.QCameraFeedbackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackLocked": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.resetEventFeedback": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'bool'),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackSound": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'str'),
-# class PySide2.QtMultimedia.QCameraFlashControl:
-    "PySide2.QtMultimedia.QCameraFlashControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFlashControl.flashMode": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-# class PySide2.QtMultimedia.QCameraFocus:
-# class PySide2.QtMultimedia.QCameraFocus.FocusMode:
-# class PySide2.QtMultimedia.QCameraFocus.FocusModes:
-# class PySide2.QtMultimedia.QCameraFocus.FocusPointMode:
-    "PySide2.QtMultimedia.QCameraFocus.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocus.digitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocus.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.opticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCameraFocusControl:
-    "PySide2.QtMultimedia.QCameraFocusControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFocusControl.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-# class PySide2.QtMultimedia.QCameraFocusZone:
-# class PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus:
-    "PySide2.QtMultimedia.QCameraFocusZone.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus'), ('PySide2.QtMultimedia.QCameraFocusZone',)],
-    "PySide2.QtMultimedia.QCameraFocusZone.__copy__": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.area": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.isValid": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.setStatus": ('PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus',),
-    "PySide2.QtMultimedia.QCameraFocusZone.status": (),
-# class PySide2.QtMultimedia.QCameraImageCapture:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestination:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations:
-# class PySide2.QtMultimedia.QCameraImageCapture.DriveMode:
-# class PySide2.QtMultimedia.QCameraImageCapture.Error:
-    "PySide2.QtMultimedia.QCameraImageCapture.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QCameraImageCapture.availability": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.encodingSettings": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.error": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.errorString": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.mediaObject": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setEncodingSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedBufferFormats": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QCameraImageCaptureControl:
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.driveMode": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.setDriveMode": ('PySide2.QtMultimedia.QCameraImageCapture.DriveMode',),
-# class PySide2.QtMultimedia.QCameraImageProcessing:
-# class PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter:
-# class PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode:
-    "PySide2.QtMultimedia.QCameraImageProcessing.brightness": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.colorFilter": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.contrast": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.denoisingLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isColorFilterSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isWhiteBalanceModeSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.manualWhiteBalance": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.saturation": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setBrightness": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setColorFilter": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setContrast": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setDenoisingLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setManualWhiteBalance": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSaturation": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSharpeningLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setWhiteBalanceMode": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.sharpeningLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.whiteBalanceMode": (),
-# class PySide2.QtMultimedia.QCameraImageProcessingControl:
-# class PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter:
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterValueSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.parameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.setParameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraInfo:
-    "PySide2.QtMultimedia.QCameraInfo.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera',), ('PySide2.QtMultimedia.QCameraInfo',)],
-    "PySide2.QtMultimedia.QCameraInfo.__copy__": (),
-    "PySide2.QtMultimedia.QCameraInfo.availableCameras": ('PySide2.QtMultimedia.QCamera.Position',),
-    "PySide2.QtMultimedia.QCameraInfo.defaultCamera": (),
-    "PySide2.QtMultimedia.QCameraInfo.description": (),
-    "PySide2.QtMultimedia.QCameraInfo.deviceName": (),
-    "PySide2.QtMultimedia.QCameraInfo.isNull": (),
-    "PySide2.QtMultimedia.QCameraInfo.orientation": (),
-    "PySide2.QtMultimedia.QCameraInfo.position": (),
-# class PySide2.QtMultimedia.QCameraInfoControl:
-    "PySide2.QtMultimedia.QCameraInfoControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraOrientation": ('str',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraPosition": ('str',),
-# class PySide2.QtMultimedia.QCameraLocksControl:
-    "PySide2.QtMultimedia.QCameraLocksControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraLocksControl.lockStatus": ('PySide2.QtMultimedia.QCamera.LockType',),
-    "PySide2.QtMultimedia.QCameraLocksControl.searchAndLock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-    "PySide2.QtMultimedia.QCameraLocksControl.supportedLocks": (),
-    "PySide2.QtMultimedia.QCameraLocksControl.unlock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettings:
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__init__": [(), ('PySide2.QtMultimedia.QCameraViewfinderSettings',)],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.isNull": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.maximumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.minimumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelFormat": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.resolution": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMaximumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMinimumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.swap": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl:
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.isViewfinderParameterSupported": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.setViewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.viewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl2:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.supportedViewfinderSettings": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraZoomControl:
-    "PySide2.QtMultimedia.QCameraZoomControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCustomAudioRoleControl:
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.customAudioRole": (),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.supportedCustomAudioRoles": (),
-# class PySide2.QtMultimedia.QImageEncoderControl:
-    "PySide2.QtMultimedia.QImageEncoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageSettings": (),
-    "PySide2.QtMultimedia.QImageEncoderControl.setImageSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QImageEncoderControl.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QImageEncoderSettings:
-    "PySide2.QtMultimedia.QImageEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QImageEncoderSettings',)],
-    "PySide2.QtMultimedia.QImageEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOptions": ('typing.Dict',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QMediaAudioProbeControl:
-    "PySide2.QtMultimedia.QMediaAudioProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaAvailabilityControl:
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.availability": (),
-# class PySide2.QtMultimedia.QMediaBindableInterface:
-    "PySide2.QtMultimedia.QMediaBindableInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimedia.QMediaContainerControl:
-    "PySide2.QtMultimedia.QMediaContainerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaContainerControl.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.supportedContainers": (),
-# class PySide2.QtMultimedia.QMediaContent:
-    "PySide2.QtMultimedia.QMediaContent.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtMultimedia.QMediaContent',), ('PySide2.QtMultimedia.QMediaPlaylist', 'PySide2.QtCore.QUrl', 'bool'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest',), ('typing.Sequence',)],
-    "PySide2.QtMultimedia.QMediaContent.__copy__": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalRequest": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalResource": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalUrl": (),
-    "PySide2.QtMultimedia.QMediaContent.isNull": (),
-    "PySide2.QtMultimedia.QMediaContent.playlist": (),
-    "PySide2.QtMultimedia.QMediaContent.request": (),
-    "PySide2.QtMultimedia.QMediaContent.resources": (),
-# class PySide2.QtMultimedia.QMediaControl:
-    "PySide2.QtMultimedia.QMediaControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaGaplessPlaybackControl:
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.crossfadeTime": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.isCrossfadeSupported": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.nextMedia": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setCrossfadeTime": ('float',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setNextMedia": ('PySide2.QtMultimedia.QMediaContent',),
-# class PySide2.QtMultimedia.QMediaNetworkAccessControl:
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.currentConfiguration": (),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.setConfigurations": ('typing.Sequence',),
-# class PySide2.QtMultimedia.QMediaObject:
-    "PySide2.QtMultimedia.QMediaObject.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaService'),
-    "PySide2.QtMultimedia.QMediaObject.addPropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.availability": (),
-    "PySide2.QtMultimedia.QMediaObject.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaObject.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaObject.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaObject.notifyInterval": (),
-    "PySide2.QtMultimedia.QMediaObject.removePropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.service": (),
-    "PySide2.QtMultimedia.QMediaObject.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QMediaObject.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaPlayer:
-# class PySide2.QtMultimedia.QMediaPlayer.Error:
-# class PySide2.QtMultimedia.QMediaPlayer.Flag:
-# class PySide2.QtMultimedia.QMediaPlayer.Flags:
-# class PySide2.QtMultimedia.QMediaPlayer.MediaStatus:
-# class PySide2.QtMultimedia.QMediaPlayer.State:
-    "PySide2.QtMultimedia.QMediaPlayer.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.audioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.availability": (),
-    "PySide2.QtMultimedia.QMediaPlayer.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentNetworkConfiguration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.customAudioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.error": (),
-    "PySide2.QtMultimedia.QMediaPlayer.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlayer.hasSupport": ('str', 'typing.Sequence', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.media": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayer.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayer.play": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playlist": (),
-    "PySide2.QtMultimedia.QMediaPlayer.position": (),
-    "PySide2.QtMultimedia.QMediaPlayer.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QMediaPlayer.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QMediaPlayer.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayer.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayer.setNetworkConfigurations": ('typing.Sequence',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaylist": ('PySide2.QtMultimedia.QMediaPlaylist',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.setVideoOutput": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QMediaPlayer.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.state": (),
-    "PySide2.QtMultimedia.QMediaPlayer.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedCustomAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedMimeTypes": ('PySide2.QtMultimedia.QMediaPlayer.Flags',),
-    "PySide2.QtMultimedia.QMediaPlayer.unbind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.volume": (),
-# class PySide2.QtMultimedia.QMediaPlayerControl:
-    "PySide2.QtMultimedia.QMediaPlayerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.availablePlaybackRanges": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.media": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.play": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.position": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.state": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.volume": (),
-# class PySide2.QtMultimedia.QMediaPlaylist:
-# class PySide2.QtMultimedia.QMediaPlaylist.Error:
-# class PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode:
-    "PySide2.QtMultimedia.QMediaPlaylist.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.addMedia": [('PySide2.QtMultimedia.QMediaContent',), ('typing.Sequence',)],
-    "PySide2.QtMultimedia.QMediaPlaylist.clear": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentIndex": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.error": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.insertMedia": [('int', 'PySide2.QtMultimedia.QMediaContent'), ('int', 'typing.Sequence')],
-    "PySide2.QtMultimedia.QMediaPlaylist.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.isReadOnly": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.load": [('PySide2.QtCore.QIODevice', 'bytes'), ('PySide2.QtCore.QUrl', 'bytes'), ('PySide2.QtNetwork.QNetworkRequest', 'bytes')],
-    "PySide2.QtMultimedia.QMediaPlaylist.media": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaCount": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.moveMedia": ('int', 'int'),
-    "PySide2.QtMultimedia.QMediaPlaylist.nextIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.playbackMode": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previous": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previousIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.removeMedia": [('int',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaPlaylist.save": [('PySide2.QtCore.QIODevice', 'bytes'), ('PySide2.QtCore.QUrl', 'bytes')],
-    "PySide2.QtMultimedia.QMediaPlaylist.setCurrentIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setPlaybackMode": ('PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode',),
-    "PySide2.QtMultimedia.QMediaPlaylist.shuffle": (),
-# class PySide2.QtMultimedia.QMediaRecorder:
-# class PySide2.QtMultimedia.QMediaRecorder.Error:
-# class PySide2.QtMultimedia.QMediaRecorder.State:
-# class PySide2.QtMultimedia.QMediaRecorder.Status:
-    "PySide2.QtMultimedia.QMediaRecorder.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QMediaRecorder.actualLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.audioCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.audioSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availability": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaRecorder.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaRecorder.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorder.error": (),
-    "PySide2.QtMultimedia.QMediaRecorder.errorString": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataWritable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorder.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaRecorder.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.pause": (),
-    "PySide2.QtMultimedia.QMediaRecorder.record": (),
-    "PySide2.QtMultimedia.QMediaRecorder.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.setEncodingSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings', 'PySide2.QtMultimedia.QVideoEncoderSettings', 'str'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaRecorder.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorder.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorder.state": (),
-    "PySide2.QtMultimedia.QMediaRecorder.status": (),
-    "PySide2.QtMultimedia.QMediaRecorder.stop": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedAudioCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedContainers": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.videoSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.volume": (),
-# class PySide2.QtMultimedia.QMediaRecorderControl:
-    "PySide2.QtMultimedia.QMediaRecorderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.applySettings": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setState": ('PySide2.QtMultimedia.QMediaRecorder.State',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.state": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.status": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.volume": (),
-# class PySide2.QtMultimedia.QMediaResource:
-    "PySide2.QtMultimedia.QMediaResource.__init__": [(), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaResource.__copy__": (),
-    "PySide2.QtMultimedia.QMediaResource.audioBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.audioCodec": (),
-    "PySide2.QtMultimedia.QMediaResource.channelCount": (),
-    "PySide2.QtMultimedia.QMediaResource.dataSize": (),
-    "PySide2.QtMultimedia.QMediaResource.isNull": (),
-    "PySide2.QtMultimedia.QMediaResource.language": (),
-    "PySide2.QtMultimedia.QMediaResource.mimeType": (),
-    "PySide2.QtMultimedia.QMediaResource.request": (),
-    "PySide2.QtMultimedia.QMediaResource.resolution": (),
-    "PySide2.QtMultimedia.QMediaResource.sampleRate": (),
-    "PySide2.QtMultimedia.QMediaResource.setAudioBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setAudioCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setDataSize": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setLanguage": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaResource.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.url": (),
-    "PySide2.QtMultimedia.QMediaResource.videoBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.videoCodec": (),
-# class PySide2.QtMultimedia.QMediaService:
-    "PySide2.QtMultimedia.QMediaService.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaService.releaseControl": ('PySide2.QtMultimedia.QMediaControl',),
-    "PySide2.QtMultimedia.QMediaService.requestControl": ('bytes',),
-# class PySide2.QtMultimedia.QMediaServiceCameraInfoInterface:
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraOrientation": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraPosition": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface:
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.defaultDevice": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceFeaturesInterface:
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.supportedFeatures": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceProviderHint:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Feature:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Features:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Type:
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera.Position',), ('PySide2.QtMultimedia.QMediaServiceProviderHint',), ('PySide2.QtMultimedia.QMediaServiceProviderHint.Features',), ('str', 'typing.Sequence')],
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__copy__": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.cameraPosition": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.codecs": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.device": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.features": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.isNull": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.mimeType": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.type": (),
-# class PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.deviceDescription": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.devices": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.hasSupport": ('str', 'typing.Sequence'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.supportedMimeTypes": (),
-# class PySide2.QtMultimedia.QMediaStreamsControl:
-# class PySide2.QtMultimedia.QMediaStreamsControl.StreamType:
-    "PySide2.QtMultimedia.QMediaStreamsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.isActive": ('int',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.metaData": ('int', 'str'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.setActive": ('int', 'bool'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamCount": (),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamType": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeInterval:
-    "PySide2.QtMultimedia.QMediaTimeInterval.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeInterval.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeInterval.end": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.isNormal": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.normalized": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.start": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.translated": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeRange:
-    "PySide2.QtMultimedia.QMediaTimeRange.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.__add__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.__iadd__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__isub__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__sub__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.addInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.addTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.clear": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeRange.earliestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.intervals": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isContinuous": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.latestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.removeInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.removeTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-# class PySide2.QtMultimedia.QMediaVideoProbeControl:
-    "PySide2.QtMultimedia.QMediaVideoProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMetaDataReaderControl:
-    "PySide2.QtMultimedia.QMetaDataReaderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.metaData": ('str',),
-# class PySide2.QtMultimedia.QMetaDataWriterControl:
-    "PySide2.QtMultimedia.QMetaDataWriterControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isWritable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.metaData": ('str',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.setMetaData": ('str', 'typing.Any'),
-# class PySide2.QtMultimedia.QMultimedia:
-# class PySide2.QtMultimedia.QMultimedia.AvailabilityStatus:
-# class PySide2.QtMultimedia.QMultimedia.EncodingMode:
-# class PySide2.QtMultimedia.QMultimedia.EncodingQuality:
-# class PySide2.QtMultimedia.QMultimedia.SupportEstimate:
-# class PySide2.QtMultimedia.QRadioData:
-# class PySide2.QtMultimedia.QRadioData.Error:
-# class PySide2.QtMultimedia.QRadioData.ProgramType:
-    "PySide2.QtMultimedia.QRadioData.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QRadioData.availability": (),
-    "PySide2.QtMultimedia.QRadioData.error": (),
-    "PySide2.QtMultimedia.QRadioData.errorString": (),
-    "PySide2.QtMultimedia.QRadioData.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioData.mediaObject": (),
-    "PySide2.QtMultimedia.QRadioData.programType": (),
-    "PySide2.QtMultimedia.QRadioData.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioData.radioText": (),
-    "PySide2.QtMultimedia.QRadioData.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioData.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QRadioData.stationId": (),
-    "PySide2.QtMultimedia.QRadioData.stationName": (),
-# class PySide2.QtMultimedia.QRadioDataControl:
-    "PySide2.QtMultimedia.QRadioDataControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioDataControl.error": (),
-    "PySide2.QtMultimedia.QRadioDataControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioDataControl.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programType": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioDataControl.radioText": (),
-    "PySide2.QtMultimedia.QRadioDataControl.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioDataControl.stationId": (),
-    "PySide2.QtMultimedia.QRadioDataControl.stationName": (),
-# class PySide2.QtMultimedia.QRadioTuner:
-# class PySide2.QtMultimedia.QRadioTuner.Band:
-# class PySide2.QtMultimedia.QRadioTuner.Error:
-# class PySide2.QtMultimedia.QRadioTuner.SearchMode:
-# class PySide2.QtMultimedia.QRadioTuner.State:
-# class PySide2.QtMultimedia.QRadioTuner.StereoMode:
-    "PySide2.QtMultimedia.QRadioTuner.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTuner.availability": (),
-    "PySide2.QtMultimedia.QRadioTuner.band": (),
-    "PySide2.QtMultimedia.QRadioTuner.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTuner.error": (),
-    "PySide2.QtMultimedia.QRadioTuner.errorString": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequency": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTuner.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTuner.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTuner.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTuner.radioData": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTuner.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTuner.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTuner.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTuner.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTuner.start": (),
-    "PySide2.QtMultimedia.QRadioTuner.state": (),
-    "PySide2.QtMultimedia.QRadioTuner.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTuner.stop": (),
-    "PySide2.QtMultimedia.QRadioTuner.volume": (),
-# class PySide2.QtMultimedia.QRadioTunerControl:
-    "PySide2.QtMultimedia.QRadioTunerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTunerControl.band": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.error": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequency": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.start": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.state": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stop": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.volume": (),
-# class PySide2.QtMultimedia.QSound:
-# class PySide2.QtMultimedia.QSound.Loop:
-    "PySide2.QtMultimedia.QSound.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QSound.fileName": (),
-    "PySide2.QtMultimedia.QSound.isFinished": (),
-    "PySide2.QtMultimedia.QSound.loops": (),
-    "PySide2.QtMultimedia.QSound.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSound.play": [(), ('str',)],
-    "PySide2.QtMultimedia.QSound.setLoops": ('int',),
-    "PySide2.QtMultimedia.QSound.stop": (),
-# class PySide2.QtMultimedia.QSoundEffect:
-# class PySide2.QtMultimedia.QSoundEffect.Loop:
-# class PySide2.QtMultimedia.QSoundEffect.Status:
-    "PySide2.QtMultimedia.QSoundEffect.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QSoundEffect.category": (),
-    "PySide2.QtMultimedia.QSoundEffect.isLoaded": (),
-    "PySide2.QtMultimedia.QSoundEffect.isMuted": (),
-    "PySide2.QtMultimedia.QSoundEffect.isPlaying": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopCount": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSoundEffect.play": (),
-    "PySide2.QtMultimedia.QSoundEffect.setCategory": ('str',),
-    "PySide2.QtMultimedia.QSoundEffect.setLoopCount": ('int',),
-    "PySide2.QtMultimedia.QSoundEffect.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QSoundEffect.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QSoundEffect.setVolume": ('float',),
-    "PySide2.QtMultimedia.QSoundEffect.source": (),
-    "PySide2.QtMultimedia.QSoundEffect.status": (),
-    "PySide2.QtMultimedia.QSoundEffect.stop": (),
-    "PySide2.QtMultimedia.QSoundEffect.supportedMimeTypes": (),
-    "PySide2.QtMultimedia.QSoundEffect.volume": (),
-# class PySide2.QtMultimedia.QVideoDeviceSelectorControl:
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.defaultDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceCount": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceDescription": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceName": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.selectedDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.setSelectedDevice": ('int',),
-# class PySide2.QtMultimedia.QVideoEncoderSettings:
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QVideoEncoderSettings',)],
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.frameRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOptions": ('typing.Dict',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QVideoEncoderSettingsControl:
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoSettings": (),
-# class PySide2.QtMultimedia.QVideoFilterRunnable:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlag:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags:
-    "PySide2.QtMultimedia.QVideoFilterRunnable.__init__": (),
-    "PySide2.QtMultimedia.QVideoFilterRunnable.run": ('PySide2.QtMultimedia.QVideoFrame', 'PySide2.QtMultimedia.QVideoSurfaceFormat', 'PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags'),
-# class PySide2.QtMultimedia.QVideoFrame:
-# class PySide2.QtMultimedia.QVideoFrame.FieldType:
-# class PySide2.QtMultimedia.QVideoFrame.PixelFormat:
-    "PySide2.QtMultimedia.QVideoFrame.__init__": [(), ('PySide2.QtGui.QImage',), ('PySide2.QtMultimedia.QAbstractVideoBuffer', 'PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat'), ('PySide2.QtMultimedia.QVideoFrame',), ('int', 'PySide2.QtCore.QSize', 'int', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat')],
-    "PySide2.QtMultimedia.QVideoFrame.__copy__": (),
-    "PySide2.QtMultimedia.QVideoFrame.availableMetaData": (),
-    "PySide2.QtMultimedia.QVideoFrame.bits": (),
-    "PySide2.QtMultimedia.QVideoFrame.buffer": (),
-    "PySide2.QtMultimedia.QVideoFrame.bytesPerLine": [(), ('int',)],
-    "PySide2.QtMultimedia.QVideoFrame.endTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.fieldType": (),
-    "PySide2.QtMultimedia.QVideoFrame.handle": (),
-    "PySide2.QtMultimedia.QVideoFrame.handleType": (),
-    "PySide2.QtMultimedia.QVideoFrame.height": (),
-    "PySide2.QtMultimedia.QVideoFrame.imageFormatFromPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QVideoFrame.isMapped": (),
-    "PySide2.QtMultimedia.QVideoFrame.isReadable": (),
-    "PySide2.QtMultimedia.QVideoFrame.isValid": (),
-    "PySide2.QtMultimedia.QVideoFrame.isWritable": (),
-    "PySide2.QtMultimedia.QVideoFrame.map": ('PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode',),
-    "PySide2.QtMultimedia.QVideoFrame.mapMode": (),
-    "PySide2.QtMultimedia.QVideoFrame.mappedBytes": (),
-    "PySide2.QtMultimedia.QVideoFrame.metaData": ('str',),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormatFromImageFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtMultimedia.QVideoFrame.planeCount": (),
-    "PySide2.QtMultimedia.QVideoFrame.setEndTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.setFieldType": ('PySide2.QtMultimedia.QVideoFrame.FieldType',),
-    "PySide2.QtMultimedia.QVideoFrame.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoFrame.setStartTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.size": (),
-    "PySide2.QtMultimedia.QVideoFrame.startTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.unmap": (),
-    "PySide2.QtMultimedia.QVideoFrame.width": (),
-# class PySide2.QtMultimedia.QVideoProbe:
-    "PySide2.QtMultimedia.QVideoProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoProbe.isActive": (),
-    "PySide2.QtMultimedia.QVideoProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QVideoRendererControl:
-    "PySide2.QtMultimedia.QVideoRendererControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoRendererControl.setSurface": ('PySide2.QtMultimedia.QAbstractVideoSurface',),
-    "PySide2.QtMultimedia.QVideoRendererControl.surface": (),
-# class PySide2.QtMultimedia.QVideoSurfaceFormat:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.Direction:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace:
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat', 'PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType'), ('PySide2.QtMultimedia.QVideoSurfaceFormat',)],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__copy__": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameHeight": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameRate": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameSize": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameWidth": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.handleType": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isMirrored": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isValid": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.property": ('bytes',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.propertyNames": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.scanLineDirection": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setMirrored": ('bool',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setProperty": ('bytes', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setScanLineDirection": ('PySide2.QtMultimedia.QVideoSurfaceFormat.Direction',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setYCbCrColorSpace": ('PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.sizeHint": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.viewport": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.yCbCrColorSpace": (),
-# class PySide2.QtMultimedia.QVideoWindowControl:
-    "PySide2.QtMultimedia.QVideoWindowControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoWindowControl.aspectRatioMode": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.brightness": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.contrast": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.displayRect": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.hue": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.isFullScreen": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.nativeSize": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.repaint": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.saturation": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setBrightness": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setContrast": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setDisplayRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setHue": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setSaturation": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setWinId": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.winId": (),
-    }) if "PySide2.QtMultimedia" in sys.modules else None
-# Module PySide2.QtMultimediaWidgets
-sig_dict.update({
-# class PySide2.QtMultimediaWidgets.QCameraViewfinder:
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimediaWidgets.QGraphicsVideoItem:
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.boundingRect": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.nativeSize": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.offset": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.size": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtMultimediaWidgets.QVideoWidget:
-    "PySide2.QtMultimediaWidgets.QVideoWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.sizeHint": (),
-# class PySide2.QtMultimediaWidgets.QVideoWidgetControl:
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.isFullScreen": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.videoWidget": (),
-    }) if "PySide2.QtMultimediaWidgets" in sys.modules else None
-# Module PySide2.QtOpenGL
-sig_dict.update({
-# class PySide2.QtOpenGL.QGL:
-# class PySide2.QtOpenGL.QGL.FormatOption:
-# class PySide2.QtOpenGL.QGL.FormatOptions:
-# class PySide2.QtOpenGL.QGLBuffer:
-# class PySide2.QtOpenGL.QGLBuffer.Access:
-# class PySide2.QtOpenGL.QGLBuffer.Type:
-# class PySide2.QtOpenGL.QGLBuffer.UsagePattern:
-    "PySide2.QtOpenGL.QGLBuffer.__init__": [(), ('PySide2.QtOpenGL.QGLBuffer',), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLBuffer.bind": (),
-    "PySide2.QtOpenGL.QGLBuffer.bufferId": (),
-    "PySide2.QtOpenGL.QGLBuffer.create": (),
-    "PySide2.QtOpenGL.QGLBuffer.destroy": (),
-    "PySide2.QtOpenGL.QGLBuffer.isCreated": (),
-    "PySide2.QtOpenGL.QGLBuffer.map": ('PySide2.QtOpenGL.QGLBuffer.Access',),
-    "PySide2.QtOpenGL.QGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLBuffer.release": [(), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.setUsagePattern": ('PySide2.QtOpenGL.QGLBuffer.UsagePattern',),
-    "PySide2.QtOpenGL.QGLBuffer.size": (),
-    "PySide2.QtOpenGL.QGLBuffer.type": (),
-    "PySide2.QtOpenGL.QGLBuffer.unmap": (),
-    "PySide2.QtOpenGL.QGLBuffer.usagePattern": (),
-    "PySide2.QtOpenGL.QGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtOpenGL.QGLColormap:
-    "PySide2.QtOpenGL.QGLColormap.__init__": [(), ('PySide2.QtOpenGL.QGLColormap',)],
-    "PySide2.QtOpenGL.QGLColormap.__copy__": (),
-    "PySide2.QtOpenGL.QGLColormap.entryColor": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.entryRgb": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.find": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.findNearest": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.handle": (),
-    "PySide2.QtOpenGL.QGLColormap.isEmpty": (),
-    "PySide2.QtOpenGL.QGLColormap.setEntry": [('int', 'PySide2.QtGui.QColor'), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLColormap.setHandle": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.size": (),
-# class PySide2.QtOpenGL.QGLContext:
-# class PySide2.QtOpenGL.QGLContext.BindOption:
-# class PySide2.QtOpenGL.QGLContext.BindOptions:
-    "PySide2.QtOpenGL.QGLContext.__init__": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.areSharing": ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLContext.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLContext.chooseContext": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.colorIndex": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLContext.contextHandle": (),
-    "PySide2.QtOpenGL.QGLContext.create": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.currentContext": (),
-    "PySide2.QtOpenGL.QGLContext.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLContext.device": (),
-    "PySide2.QtOpenGL.QGLContext.deviceIsPixmap": (),
-    "PySide2.QtOpenGL.QGLContext.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLContext.format": (),
-    "PySide2.QtOpenGL.QGLContext.fromOpenGLContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtOpenGL.QGLContext.initialized": (),
-    "PySide2.QtOpenGL.QGLContext.isSharing": (),
-    "PySide2.QtOpenGL.QGLContext.isValid": (),
-    "PySide2.QtOpenGL.QGLContext.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtOpenGL.QGLContext.overlayTransparentColor": (),
-    "PySide2.QtOpenGL.QGLContext.requestedFormat": (),
-    "PySide2.QtOpenGL.QGLContext.reset": (),
-    "PySide2.QtOpenGL.QGLContext.setDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtOpenGL.QGLContext.setFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.setInitialized": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setTextureCacheLimit": ('int',),
-    "PySide2.QtOpenGL.QGLContext.setValid": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setWindowCreated": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLContext.textureCacheLimit": (),
-    "PySide2.QtOpenGL.QGLContext.windowCreated": (),
-# class PySide2.QtOpenGL.QGLFormat:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlag:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlags:
-    "PySide2.QtOpenGL.QGLFormat.__init__": [(), ('PySide2.QtOpenGL.QGL.FormatOptions', 'int'), ('PySide2.QtOpenGL.QGLFormat',)],
-    "PySide2.QtOpenGL.QGLFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFormat.accum": (),
-    "PySide2.QtOpenGL.QGLFormat.accumBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.alpha": (),
-    "PySide2.QtOpenGL.QGLFormat.alphaBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.blueBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultOverlayFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.depth": (),
-    "PySide2.QtOpenGL.QGLFormat.depthBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.directRendering": (),
-    "PySide2.QtOpenGL.QGLFormat.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLFormat.fromSurfaceFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtOpenGL.QGLFormat.greenBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGL": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGLOverlays": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOverlay": (),
-    "PySide2.QtOpenGL.QGLFormat.majorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.minorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.openGLVersionFlags": (),
-    "PySide2.QtOpenGL.QGLFormat.plane": (),
-    "PySide2.QtOpenGL.QGLFormat.profile": (),
-    "PySide2.QtOpenGL.QGLFormat.redBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.rgba": (),
-    "PySide2.QtOpenGL.QGLFormat.sampleBuffers": (),
-    "PySide2.QtOpenGL.QGLFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFormat.setAccum": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAccumBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setAlpha": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultOverlayFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDepth": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDirectRendering": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDoubleBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.setOverlay": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setPlane": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setProfile": ('PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile',),
-    "PySide2.QtOpenGL.QGLFormat.setRedBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setRgba": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSampleBuffers": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStencil": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStereo": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSwapInterval": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setVersion": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLFormat.stencil": (),
-    "PySide2.QtOpenGL.QGLFormat.stencilBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.stereo": (),
-    "PySide2.QtOpenGL.QGLFormat.swapInterval": (),
-    "PySide2.QtOpenGL.QGLFormat.testOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.toSurfaceFormat": ('PySide2.QtOpenGL.QGLFormat',),
-# class PySide2.QtOpenGL.QGLFramebufferObject:
-# class PySide2.QtOpenGL.QGLFramebufferObject.Attachment:
-    "PySide2.QtOpenGL.QGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bind": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bindDefault": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.blitFramebuffer": ('PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLFramebufferObject.devType": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.format": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.handle": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isBound": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isValid": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLFramebufferObject.paintEngine": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.release": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.size": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.texture": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.toImage": (),
-# class PySide2.QtOpenGL.QGLFramebufferObjectFormat:
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtOpenGL.QGLFramebufferObjectFormat',)],
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setAttachment": ('PySide2.QtOpenGL.QGLFramebufferObject.Attachment',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtOpenGL.QGLPixelBuffer:
-    "PySide2.QtOpenGL.QGLPixelBuffer.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget'), ('int', 'int', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindTexture": [('PySide2.QtGui.QImage', 'int'), ('PySide2.QtGui.QPixmap', 'int'), ('str',)],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindToDynamicTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.context": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.devType": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.format": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.generateDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.handle": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.hasOpenGLPbuffers": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.isValid": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.paintEngine": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.releaseFromDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.size": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.toImage": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.updateDynamicTexture": ('int',),
-# class PySide2.QtOpenGL.QGLShader:
-# class PySide2.QtOpenGL.QGLShader.ShaderType:
-# class PySide2.QtOpenGL.QGLShader.ShaderTypeBit:
-    "PySide2.QtOpenGL.QGLShader.__init__": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QObject'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-    "PySide2.QtOpenGL.QGLShader.compileSourceFile": ('str',),
-    "PySide2.QtOpenGL.QGLShader.hasOpenGLShaders": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLShader.isCompiled": (),
-    "PySide2.QtOpenGL.QGLShader.log": (),
-    "PySide2.QtOpenGL.QGLShader.shaderId": (),
-    "PySide2.QtOpenGL.QGLShader.shaderType": (),
-    "PySide2.QtOpenGL.QGLShader.sourceCode": (),
-# class PySide2.QtOpenGL.QGLShaderProgram:
-    "PySide2.QtOpenGL.QGLShaderProgram.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'bytes'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str'),
-    "PySide2.QtOpenGL.QGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.bind": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('bytes', 'int'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.disableAttributeArray": [('bytes',), ('int',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.enableAttributeArray": [('bytes',), ('int',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryInputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputVertexCount": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLShaderProgram.isLinked": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.link": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.log": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.programId": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.release": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray2D": [('bytes', 'PySide2.QtGui.QVector2D', 'int'), ('int', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray3D": [('bytes', 'PySide2.QtGui.QVector3D', 'int'), ('int', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray4D": [('bytes', 'PySide2.QtGui.QVector4D', 'int'), ('int', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeBuffer": [('bytes', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeValue": [('bytes', 'PySide2.QtGui.QColor'), ('bytes', 'PySide2.QtGui.QVector2D'), ('bytes', 'PySide2.QtGui.QVector3D'), ('bytes', 'PySide2.QtGui.QVector4D'), ('bytes', 'float'), ('bytes', 'float', 'float'), ('bytes', 'float', 'float', 'float'), ('bytes', 'float', 'float', 'float', 'float'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryInputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputVertexCount": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValue": [('bytes', 'PySide2.QtCore.QPoint'), ('bytes', 'PySide2.QtCore.QPointF'), ('bytes', 'PySide2.QtCore.QSize'), ('bytes', 'PySide2.QtCore.QSizeF'), ('bytes', 'PySide2.QtGui.QColor'), ('bytes', 'PySide2.QtGui.QMatrix2x2'), ('bytes', 'PySide2.QtGui.QMatrix2x3'), ('bytes', 'PySide2.QtGui.QMatrix2x4'), ('bytes', 'PySide2.QtGui.QMatrix3x2'), ('bytes', 'PySide2.QtGui.QMatrix3x3'), ('bytes', 'PySide2.QtGui.QMatrix3x4'), ('bytes', 'PySide2.QtGui.QMatrix4x2'), ('bytes', 'PySide2.QtGui.QMatrix4x3'), ('bytes', 'PySide2.QtGui.QMatrix4x4'), ('bytes', 'PySide2.QtGui.QTransform'), ('bytes', 'PySide2.QtGui.QVector2D'), ('bytes', 'PySide2.QtGui.QVector3D'), ('bytes', 'PySide2.QtGui.QVector4D'), ('bytes', 'float'), ('bytes', 'float', 'float'), ('bytes', 'float', 'float', 'float'), ('bytes', 'float', 'float', 'float', 'float'), ('bytes', 'int'), ('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2D": [('bytes', 'PySide2.QtGui.QVector2D', 'int'), ('int', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x2": [('bytes', 'PySide2.QtGui.QMatrix2x2', 'int'), ('int', 'PySide2.QtGui.QMatrix2x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x3": [('bytes', 'PySide2.QtGui.QMatrix2x3', 'int'), ('int', 'PySide2.QtGui.QMatrix2x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x4": [('bytes', 'PySide2.QtGui.QMatrix2x4', 'int'), ('int', 'PySide2.QtGui.QMatrix2x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3D": [('bytes', 'PySide2.QtGui.QVector3D', 'int'), ('int', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x2": [('bytes', 'PySide2.QtGui.QMatrix3x2', 'int'), ('int', 'PySide2.QtGui.QMatrix3x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x3": [('bytes', 'PySide2.QtGui.QMatrix3x3', 'int'), ('int', 'PySide2.QtGui.QMatrix3x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x4": [('bytes', 'PySide2.QtGui.QMatrix3x4', 'int'), ('int', 'PySide2.QtGui.QMatrix3x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4D": [('bytes', 'PySide2.QtGui.QVector4D', 'int'), ('int', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x2": [('bytes', 'PySide2.QtGui.QMatrix4x2', 'int'), ('int', 'PySide2.QtGui.QMatrix4x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x3": [('bytes', 'PySide2.QtGui.QMatrix4x3', 'int'), ('int', 'PySide2.QtGui.QMatrix4x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x4": [('bytes', 'PySide2.QtGui.QMatrix4x4', 'int'), ('int', 'PySide2.QtGui.QMatrix4x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayInt": [('bytes', 'typing.Sequence', 'int'), ('int', 'typing.Sequence', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayUint": [('bytes', 'typing.Sequence', 'int'), ('int', 'typing.Sequence', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.shaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('bytes',), ('str',)],
-# class PySide2.QtOpenGL.QGLWidget:
-    "PySide2.QtOpenGL.QGLWidget.__init__": [('PySide2.QtOpenGL.QGLContext', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtOpenGL.QGLFormat', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtOpenGL.QGLWidget.autoBufferSwap": (),
-    "PySide2.QtOpenGL.QGLWidget.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLWidget.colormap": (),
-    "PySide2.QtOpenGL.QGLWidget.context": (),
-    "PySide2.QtOpenGL.QGLWidget.convertToGLFormat": ('PySide2.QtGui.QImage',),
-    "PySide2.QtOpenGL.QGLWidget.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLWidget.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLWidget.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtOpenGL.QGLWidget.format": (),
-    "PySide2.QtOpenGL.QGLWidget.glDraw": (),
-    "PySide2.QtOpenGL.QGLWidget.glInit": (),
-    "PySide2.QtOpenGL.QGLWidget.grabFrameBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.initializeGL": (),
-    "PySide2.QtOpenGL.QGLWidget.initializeOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.isSharing": (),
-    "PySide2.QtOpenGL.QGLWidget.isValid": (),
-    "PySide2.QtOpenGL.QGLWidget.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.makeOverlayCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.overlayContext": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEngine": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtOpenGL.QGLWidget.paintGL": (),
-    "PySide2.QtOpenGL.QGLWidget.paintOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.qglClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.qglColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.renderPixmap": ('int', 'int', 'bool'),
-    "PySide2.QtOpenGL.QGLWidget.renderText": [('float', 'float', 'float', 'str', 'PySide2.QtGui.QFont'), ('int', 'int', 'str', 'PySide2.QtGui.QFont')],
-    "PySide2.QtOpenGL.QGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtOpenGL.QGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.resizeOverlayGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.setAutoBufferSwap": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.setColormap": ('PySide2.QtOpenGL.QGLColormap',),
-    "PySide2.QtOpenGL.QGLWidget.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLWidget.updateGL": (),
-    "PySide2.QtOpenGL.QGLWidget.updateOverlayGL": (),
-    }) if "PySide2.QtOpenGL" in sys.modules else None
-# Module PySide2.QtOpenGLFunctions
-sig_dict.update({
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersRange": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexBuffers": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectLabel": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectPtrLabel": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersRange": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSamplers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexBuffers": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectLabel": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectPtrLabel": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPushDebugGroup": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersRange": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexBuffers": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipPlane": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoorddv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnConvolutionFilter": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnHistogram": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnMinmax": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexdv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexfv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexsv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeliv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixd": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixf": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectLabel": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectPtrLabel": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectdv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectfv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectiv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectsv": ('typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3bv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ubv": ('bytes',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3uiv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3usv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayVertexBuffers": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3dv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3fv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3iv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3sv": ('typing.Sequence',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindAttribLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersRange": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSamplers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextures": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexBuffers": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteFramebuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteQueries": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteSamplers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTextures": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteVertexArrays": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffers": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetAttribLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineIndex": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineUniformLocation": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformBlockIndex": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformLocation": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArrays": ('int', 'typing.Sequence', 'typing.Sequence', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectLabel": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectPtrLabel": ('int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteriv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPushDebugGroup": ('int', 'int', 'int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexedv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderBinary": ('int', 'typing.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterfv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteriv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4dv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4fv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4iv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayVertexBuffers": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nbv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4fv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4bv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4iv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4sv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ubv": ('int', 'bytes'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4usv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4dv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedfv": ('int', 'typing.Sequence'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.initializeOpenGLFunctions": (),
-    }) if "PySide2.QtOpenGLFunctions" in sys.modules else None
-# Module PySide2.QtPositioning
-sig_dict.update({
-# class PySide2.QtPositioning.QGeoAddress:
-    "PySide2.QtPositioning.QGeoAddress.__init__": [(), ('PySide2.QtPositioning.QGeoAddress',)],
-    "PySide2.QtPositioning.QGeoAddress.__copy__": (),
-    "PySide2.QtPositioning.QGeoAddress.city": (),
-    "PySide2.QtPositioning.QGeoAddress.clear": (),
-    "PySide2.QtPositioning.QGeoAddress.country": (),
-    "PySide2.QtPositioning.QGeoAddress.countryCode": (),
-    "PySide2.QtPositioning.QGeoAddress.county": (),
-    "PySide2.QtPositioning.QGeoAddress.district": (),
-    "PySide2.QtPositioning.QGeoAddress.isEmpty": (),
-    "PySide2.QtPositioning.QGeoAddress.isTextGenerated": (),
-    "PySide2.QtPositioning.QGeoAddress.postalCode": (),
-    "PySide2.QtPositioning.QGeoAddress.setCity": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountry": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountryCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCounty": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setDistrict": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setPostalCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setState": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setStreet": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setText": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.state": (),
-    "PySide2.QtPositioning.QGeoAddress.street": (),
-    "PySide2.QtPositioning.QGeoAddress.text": (),
-# class PySide2.QtPositioning.QGeoAreaMonitorInfo:
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__init__": [('PySide2.QtPositioning.QGeoAreaMonitorInfo',), ('str',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.area": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.expiration": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.identifier": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isPersistent": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.name": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.notificationParameters": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setExpiration": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setName": ('str',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setNotificationParameters": ('typing.Dict',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setPersistent": ('bool',),
-# class PySide2.QtPositioning.QGeoAreaMonitorSource:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeature:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeatures:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.Error:
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.activeMonitors": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createDefaultSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createSource": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.error": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.positionInfoSource": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.requestUpdate": ('PySide2.QtPositioning.QGeoAreaMonitorInfo', 'bytes'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.setPositionInfoSource": ('PySide2.QtPositioning.QGeoPositionInfoSource',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.startMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.stopMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.supportedAreaMonitorFeatures": (),
-# class PySide2.QtPositioning.QGeoCircle:
-    "PySide2.QtPositioning.QGeoCircle.__init__": [(), ('PySide2.QtPositioning.QGeoCircle',), ('PySide2.QtPositioning.QGeoCoordinate', 'float'), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoCircle.__copy__": (),
-    "PySide2.QtPositioning.QGeoCircle.center": (),
-    "PySide2.QtPositioning.QGeoCircle.extendCircle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.radius": (),
-    "PySide2.QtPositioning.QGeoCircle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.setRadius": ('float',),
-    "PySide2.QtPositioning.QGeoCircle.toString": (),
-    "PySide2.QtPositioning.QGeoCircle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoCircle.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoCoordinate:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateType:
-    "PySide2.QtPositioning.QGeoCoordinate.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtPositioning.QGeoCoordinate.__copy__": (),
-    "PySide2.QtPositioning.QGeoCoordinate.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.altitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.atDistanceAndAzimuth": ('float', 'float', 'float'),
-    "PySide2.QtPositioning.QGeoCoordinate.azimuthTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.distanceTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.isValid": (),
-    "PySide2.QtPositioning.QGeoCoordinate.latitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.longitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.setAltitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLatitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLongitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.toString": ('PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat',),
-    "PySide2.QtPositioning.QGeoCoordinate.type": (),
-# class PySide2.QtPositioning.QGeoLocation:
-    "PySide2.QtPositioning.QGeoLocation.__init__": [(), ('PySide2.QtPositioning.QGeoLocation',)],
-    "PySide2.QtPositioning.QGeoLocation.__copy__": (),
-    "PySide2.QtPositioning.QGeoLocation.address": (),
-    "PySide2.QtPositioning.QGeoLocation.boundingBox": (),
-    "PySide2.QtPositioning.QGeoLocation.coordinate": (),
-    "PySide2.QtPositioning.QGeoLocation.extendedAttributes": (),
-    "PySide2.QtPositioning.QGeoLocation.isEmpty": (),
-    "PySide2.QtPositioning.QGeoLocation.setAddress": ('PySide2.QtPositioning.QGeoAddress',),
-    "PySide2.QtPositioning.QGeoLocation.setBoundingBox": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoLocation.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoLocation.setExtendedAttributes": ('typing.Dict',),
-# class PySide2.QtPositioning.QGeoPath:
-    "PySide2.QtPositioning.QGeoPath.__init__": [(), ('PySide2.QtPositioning.QGeoPath',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence', 'float')],
-    "PySide2.QtPositioning.QGeoPath.__copy__": (),
-    "PySide2.QtPositioning.QGeoPath.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.clearPath": (),
-    "PySide2.QtPositioning.QGeoPath.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPath.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPath.path": (),
-    "PySide2.QtPositioning.QGeoPath.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPath.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.setPath": ('typing.Sequence',),
-    "PySide2.QtPositioning.QGeoPath.setVariantPath": ('typing.Sequence',),
-    "PySide2.QtPositioning.QGeoPath.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoPath.size": (),
-    "PySide2.QtPositioning.QGeoPath.toString": (),
-    "PySide2.QtPositioning.QGeoPath.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.variantPath": (),
-    "PySide2.QtPositioning.QGeoPath.width": (),
-# class PySide2.QtPositioning.QGeoPolygon:
-    "PySide2.QtPositioning.QGeoPolygon.__init__": [(), ('PySide2.QtPositioning.QGeoPolygon',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence',)],
-    "PySide2.QtPositioning.QGeoPolygon.__copy__": (),
-    "PySide2.QtPositioning.QGeoPolygon.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.addHole": [('typing.Any',), ('typing.Sequence',)],
-    "PySide2.QtPositioning.QGeoPolygon.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.hole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holePath": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holesCount": (),
-    "PySide2.QtPositioning.QGeoPolygon.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPolygon.path": (),
-    "PySide2.QtPositioning.QGeoPolygon.perimeter": (),
-    "PySide2.QtPositioning.QGeoPolygon.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPolygon.removeHole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.setPath": ('typing.Sequence',),
-    "PySide2.QtPositioning.QGeoPolygon.setPerimeter": ('typing.Sequence',),
-    "PySide2.QtPositioning.QGeoPolygon.size": (),
-    "PySide2.QtPositioning.QGeoPolygon.toString": (),
-    "PySide2.QtPositioning.QGeoPolygon.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPolygon.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoPositionInfo:
-# class PySide2.QtPositioning.QGeoPositionInfo.Attribute:
-    "PySide2.QtPositioning.QGeoPositionInfo.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtCore.QDateTime'), ('PySide2.QtPositioning.QGeoPositionInfo',)],
-    "PySide2.QtPositioning.QGeoPositionInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.attribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.coordinate": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.hasAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.removeAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoPositionInfo.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setTimestamp": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoPositionInfo.timestamp": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSource:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.Error:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethod:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods:
-    "PySide2.QtPositioning.QGeoPositionInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.backendProperty": ('str',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.preferredPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setBackendProperty": ('str', 'typing.Any'),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setPreferredPositioningMethods": ('PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSourceFactory:
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.__init__": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.areaMonitor": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.positionInfoSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.satelliteInfoSource": ('PySide2.QtCore.QObject',),
-# class PySide2.QtPositioning.QGeoRectangle:
-    "PySide2.QtPositioning.QGeoRectangle.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('PySide2.QtPositioning.QGeoCoordinate', 'float', 'float'), ('PySide2.QtPositioning.QGeoRectangle',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence',)],
-    "PySide2.QtPositioning.QGeoRectangle.__copy__": (),
-    "PySide2.QtPositioning.QGeoRectangle.__ior__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.__or__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.bottomLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.bottomRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.center": (),
-    "PySide2.QtPositioning.QGeoRectangle.contains": [('PySide2.QtPositioning.QGeoCoordinate',), ('PySide2.QtPositioning.QGeoRectangle',)],
-    "PySide2.QtPositioning.QGeoRectangle.extendRectangle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.height": (),
-    "PySide2.QtPositioning.QGeoRectangle.intersects": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setHeight": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.toString": (),
-    "PySide2.QtPositioning.QGeoRectangle.topLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.topRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.united": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.width": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfo:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.Attribute:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem:
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__init__": [(), ('PySide2.QtPositioning.QGeoSatelliteInfo',)],
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.attribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.hasAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.removeAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteIdentifier": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteSystem": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteIdentifier": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteSystem": ('PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSignalStrength": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.signalStrength": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource:
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource.Error:
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoShape:
-# class PySide2.QtPositioning.QGeoShape.ShapeType:
-    "PySide2.QtPositioning.QGeoShape.__init__": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoShape.__copy__": (),
-    "PySide2.QtPositioning.QGeoShape.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.boundingGeoRectangle": (),
-    "PySide2.QtPositioning.QGeoShape.center": (),
-    "PySide2.QtPositioning.QGeoShape.contains": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.extendShape": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.isEmpty": (),
-    "PySide2.QtPositioning.QGeoShape.isValid": (),
-    "PySide2.QtPositioning.QGeoShape.toString": (),
-    "PySide2.QtPositioning.QGeoShape.type": (),
-# class PySide2.QtPositioning.QNmeaPositionInfoSource:
-# class PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode:
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.__init__": ('PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.device": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.parsePosInfoFromNmeaData": ('bytes', 'int', 'PySide2.QtPositioning.QGeoPositionInfo'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUserEquivalentRangeError": ('float',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.updateMode": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.userEquivalentRangeError": (),
-    }) if "PySide2.QtPositioning" in sys.modules else None
-# Module PySide2.QtLocation
-sig_dict.update({
-# class PySide2.QtLocation.QGeoCodeReply:
-# class PySide2.QtLocation.QGeoCodeReply.Error:
-    "PySide2.QtLocation.QGeoCodeReply.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtLocation.QGeoCodeReply.Error', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoCodeReply.abort": (),
-    "PySide2.QtLocation.QGeoCodeReply.addLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QGeoCodeReply.error": (),
-    "PySide2.QtLocation.QGeoCodeReply.errorString": (),
-    "PySide2.QtLocation.QGeoCodeReply.isFinished": (),
-    "PySide2.QtLocation.QGeoCodeReply.limit": (),
-    "PySide2.QtLocation.QGeoCodeReply.locations": (),
-    "PySide2.QtLocation.QGeoCodeReply.offset": (),
-    "PySide2.QtLocation.QGeoCodeReply.setError": ('PySide2.QtLocation.QGeoCodeReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoCodeReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoCodeReply.setLimit": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setLocations": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoCodeReply.setOffset": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setViewport": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QGeoCodeReply.viewport": (),
-# class PySide2.QtLocation.QGeoCodingManager:
-    "PySide2.QtLocation.QGeoCodingManager.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManager.locale": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManager.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManager.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoCodingManagerEngine:
-    "PySide2.QtLocation.QGeoCodingManagerEngine.__init__": ('typing.Dict', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoManeuver:
-# class PySide2.QtLocation.QGeoManeuver.InstructionDirection:
-    "PySide2.QtLocation.QGeoManeuver.__init__": [(), ('PySide2.QtLocation.QGeoManeuver',)],
-    "PySide2.QtLocation.QGeoManeuver.__copy__": (),
-    "PySide2.QtLocation.QGeoManeuver.direction": (),
-    "PySide2.QtLocation.QGeoManeuver.distanceToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoManeuver.instructionText": (),
-    "PySide2.QtLocation.QGeoManeuver.isValid": (),
-    "PySide2.QtLocation.QGeoManeuver.position": (),
-    "PySide2.QtLocation.QGeoManeuver.setDirection": ('PySide2.QtLocation.QGeoManeuver.InstructionDirection',),
-    "PySide2.QtLocation.QGeoManeuver.setDistanceToNextInstruction": ('float',),
-    "PySide2.QtLocation.QGeoManeuver.setExtendedAttributes": ('typing.Dict',),
-    "PySide2.QtLocation.QGeoManeuver.setInstructionText": ('str',),
-    "PySide2.QtLocation.QGeoManeuver.setPosition": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.setTimeToNextInstruction": ('int',),
-    "PySide2.QtLocation.QGeoManeuver.setWaypoint": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.timeToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.waypoint": (),
-# class PySide2.QtLocation.QGeoRoute:
-    "PySide2.QtLocation.QGeoRoute.__init__": [(), ('PySide2.QtLocation.QGeoRoute',)],
-    "PySide2.QtLocation.QGeoRoute.__copy__": (),
-    "PySide2.QtLocation.QGeoRoute.bounds": (),
-    "PySide2.QtLocation.QGeoRoute.distance": (),
-    "PySide2.QtLocation.QGeoRoute.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoRoute.firstRouteSegment": (),
-    "PySide2.QtLocation.QGeoRoute.path": (),
-    "PySide2.QtLocation.QGeoRoute.request": (),
-    "PySide2.QtLocation.QGeoRoute.routeId": (),
-    "PySide2.QtLocation.QGeoRoute.setBounds": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtLocation.QGeoRoute.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRoute.setExtendedAttributes": ('typing.Dict',),
-    "PySide2.QtLocation.QGeoRoute.setFirstRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRoute.setPath": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRoute.setRequest": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoute.setRouteId": ('str',),
-    "PySide2.QtLocation.QGeoRoute.setTravelMode": ('PySide2.QtLocation.QGeoRouteRequest.TravelMode',),
-    "PySide2.QtLocation.QGeoRoute.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRoute.travelMode": (),
-    "PySide2.QtLocation.QGeoRoute.travelTime": (),
-# class PySide2.QtLocation.QGeoRouteReply:
-# class PySide2.QtLocation.QGeoRouteReply.Error:
-    "PySide2.QtLocation.QGeoRouteReply.__init__": [('PySide2.QtLocation.QGeoRouteReply.Error', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtLocation.QGeoRouteRequest', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoRouteReply.abort": (),
-    "PySide2.QtLocation.QGeoRouteReply.addRoutes": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRouteReply.error": (),
-    "PySide2.QtLocation.QGeoRouteReply.errorString": (),
-    "PySide2.QtLocation.QGeoRouteReply.isFinished": (),
-    "PySide2.QtLocation.QGeoRouteReply.request": (),
-    "PySide2.QtLocation.QGeoRouteReply.routes": (),
-    "PySide2.QtLocation.QGeoRouteReply.setError": ('PySide2.QtLocation.QGeoRouteReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoRouteReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoRouteReply.setRoutes": ('typing.Sequence',),
-# class PySide2.QtLocation.QGeoRouteRequest:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureType:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureTypes:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeight:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeights:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimization:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelMode:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelModes:
-    "PySide2.QtLocation.QGeoRouteRequest.__init__": [('PySide2.QtLocation.QGeoRouteRequest',), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('typing.Sequence',)],
-    "PySide2.QtLocation.QGeoRouteRequest.departureTime": (),
-    "PySide2.QtLocation.QGeoRouteRequest.excludeAreas": (),
-    "PySide2.QtLocation.QGeoRouteRequest.extraParameters": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureTypes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType',),
-    "PySide2.QtLocation.QGeoRouteRequest.maneuverDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.numberAlternativeRoutes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.routeOptimization": (),
-    "PySide2.QtLocation.QGeoRouteRequest.segmentDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.setDepartureTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExcludeAreas": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExtraParameters": ('typing.Dict',),
-    "PySide2.QtLocation.QGeoRouteRequest.setFeatureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType', 'PySide2.QtLocation.QGeoRouteRequest.FeatureWeight'),
-    "PySide2.QtLocation.QGeoRouteRequest.setManeuverDetail": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setNumberAlternativeRoutes": ('int',),
-    "PySide2.QtLocation.QGeoRouteRequest.setRouteOptimization": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRouteRequest.setSegmentDetail": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypoints": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypointsMetadata": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRouteRequest.travelModes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypoints": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypointsMetadata": (),
-# class PySide2.QtLocation.QGeoRouteSegment:
-    "PySide2.QtLocation.QGeoRouteSegment.__init__": [(), ('PySide2.QtLocation.QGeoRouteSegment',)],
-    "PySide2.QtLocation.QGeoRouteSegment.__copy__": (),
-    "PySide2.QtLocation.QGeoRouteSegment.distance": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isLegLastSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isValid": (),
-    "PySide2.QtLocation.QGeoRouteSegment.maneuver": (),
-    "PySide2.QtLocation.QGeoRouteSegment.nextRouteSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.path": (),
-    "PySide2.QtLocation.QGeoRouteSegment.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRouteSegment.setManeuver": ('PySide2.QtLocation.QGeoManeuver',),
-    "PySide2.QtLocation.QGeoRouteSegment.setNextRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRouteSegment.setPath": ('typing.Sequence',),
-    "PySide2.QtLocation.QGeoRouteSegment.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRouteSegment.travelTime": (),
-# class PySide2.QtLocation.QGeoRoutingManager:
-    "PySide2.QtLocation.QGeoRoutingManager.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManager.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManager.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManager.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoRoutingManagerEngine:
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.__init__": ('typing.Dict', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureTypes": ('PySide2.QtLocation.QGeoRouteRequest.FeatureTypes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureWeights": ('PySide2.QtLocation.QGeoRouteRequest.FeatureWeights',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedManeuverDetails": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedRouteOptimizations": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedSegmentDetails": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoServiceProvider:
-# class PySide2.QtLocation.QGeoServiceProvider.Error:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeatures:
-    "PySide2.QtLocation.QGeoServiceProvider.__init__": ('str', 'typing.Dict', 'bool'),
-    "PySide2.QtLocation.QGeoServiceProvider.availableServiceProviders": (),
-    "PySide2.QtLocation.QGeoServiceProvider.error": (),
-    "PySide2.QtLocation.QGeoServiceProvider.errorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placeManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.setAllowExperimental": ('bool',),
-    "PySide2.QtLocation.QGeoServiceProvider.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoServiceProvider.setParameters": ('typing.Dict',),
-# class PySide2.QtLocation.QGeoServiceProviderFactory:
-    "PySide2.QtLocation.QGeoServiceProviderFactory.__init__": (),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createGeocodingManagerEngine": ('typing.Dict', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createPlaceManagerEngine": ('typing.Dict', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createRoutingManagerEngine": ('typing.Dict', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-# class PySide2.QtLocation.QGeoServiceProviderFactoryV2:
-    "PySide2.QtLocation.QGeoServiceProviderFactoryV2.__init__": (),
-# class PySide2.QtLocation.QPlace:
-    "PySide2.QtLocation.QPlace.__init__": [(), ('PySide2.QtLocation.QPlace',)],
-    "PySide2.QtLocation.QPlace.__copy__": (),
-    "PySide2.QtLocation.QPlace.appendContactDetail": ('str', 'PySide2.QtLocation.QPlaceContactDetail'),
-    "PySide2.QtLocation.QPlace.attribution": (),
-    "PySide2.QtLocation.QPlace.categories": (),
-    "PySide2.QtLocation.QPlace.contactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.contactTypes": (),
-    "PySide2.QtLocation.QPlace.content": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlace.detailsFetched": (),
-    "PySide2.QtLocation.QPlace.extendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.extendedAttributeTypes": (),
-    "PySide2.QtLocation.QPlace.icon": (),
-    "PySide2.QtLocation.QPlace.insertContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict'),
-    "PySide2.QtLocation.QPlace.isEmpty": (),
-    "PySide2.QtLocation.QPlace.location": (),
-    "PySide2.QtLocation.QPlace.name": (),
-    "PySide2.QtLocation.QPlace.placeId": (),
-    "PySide2.QtLocation.QPlace.primaryEmail": (),
-    "PySide2.QtLocation.QPlace.primaryFax": (),
-    "PySide2.QtLocation.QPlace.primaryPhone": (),
-    "PySide2.QtLocation.QPlace.primaryWebsite": (),
-    "PySide2.QtLocation.QPlace.ratings": (),
-    "PySide2.QtLocation.QPlace.removeContactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.removeExtendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlace.setCategories": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlace.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlace.setContactDetails": ('str', 'typing.Sequence'),
-    "PySide2.QtLocation.QPlace.setContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict'),
-    "PySide2.QtLocation.QPlace.setDetailsFetched": ('bool',),
-    "PySide2.QtLocation.QPlace.setExtendedAttribute": ('str', 'PySide2.QtLocation.QPlaceAttribute'),
-    "PySide2.QtLocation.QPlace.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlace.setLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QPlace.setName": ('str',),
-    "PySide2.QtLocation.QPlace.setPlaceId": ('str',),
-    "PySide2.QtLocation.QPlace.setRatings": ('PySide2.QtLocation.QPlaceRatings',),
-    "PySide2.QtLocation.QPlace.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlace.setTotalContentCount": ('PySide2.QtLocation.QPlaceContent.Type', 'int'),
-    "PySide2.QtLocation.QPlace.supplier": (),
-    "PySide2.QtLocation.QPlace.totalContentCount": ('PySide2.QtLocation.QPlaceContent.Type',),
-# class PySide2.QtLocation.QPlaceAttribute:
-    "PySide2.QtLocation.QPlaceAttribute.__init__": [(), ('PySide2.QtLocation.QPlaceAttribute',)],
-    "PySide2.QtLocation.QPlaceAttribute.__copy__": (),
-    "PySide2.QtLocation.QPlaceAttribute.isEmpty": (),
-    "PySide2.QtLocation.QPlaceAttribute.label": (),
-    "PySide2.QtLocation.QPlaceAttribute.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.setText": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.text": (),
-# class PySide2.QtLocation.QPlaceCategory:
-    "PySide2.QtLocation.QPlaceCategory.__init__": [(), ('PySide2.QtLocation.QPlaceCategory',)],
-    "PySide2.QtLocation.QPlaceCategory.__copy__": (),
-    "PySide2.QtLocation.QPlaceCategory.categoryId": (),
-    "PySide2.QtLocation.QPlaceCategory.icon": (),
-    "PySide2.QtLocation.QPlaceCategory.isEmpty": (),
-    "PySide2.QtLocation.QPlaceCategory.name": (),
-    "PySide2.QtLocation.QPlaceCategory.setCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceCategory.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceCategory.setName": ('str',),
-# class PySide2.QtLocation.QPlaceContactDetail:
-    "PySide2.QtLocation.QPlaceContactDetail.__init__": [(), ('PySide2.QtLocation.QPlaceContactDetail',)],
-    "PySide2.QtLocation.QPlaceContactDetail.__copy__": (),
-    "PySide2.QtLocation.QPlaceContactDetail.clear": (),
-    "PySide2.QtLocation.QPlaceContactDetail.label": (),
-    "PySide2.QtLocation.QPlaceContactDetail.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.setValue": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.value": (),
-# class PySide2.QtLocation.QPlaceContent:
-# class PySide2.QtLocation.QPlaceContent.Type:
-    "PySide2.QtLocation.QPlaceContent.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceContent.__copy__": (),
-    "PySide2.QtLocation.QPlaceContent.attribution": (),
-    "PySide2.QtLocation.QPlaceContent.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlaceContent.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlaceContent.setUser": ('PySide2.QtLocation.QPlaceUser',),
-    "PySide2.QtLocation.QPlaceContent.supplier": (),
-    "PySide2.QtLocation.QPlaceContent.type": (),
-    "PySide2.QtLocation.QPlaceContent.user": (),
-# class PySide2.QtLocation.QPlaceContentReply:
-    "PySide2.QtLocation.QPlaceContentReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceContentReply.content": (),
-    "PySide2.QtLocation.QPlaceContentReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.request": (),
-    "PySide2.QtLocation.QPlaceContentReply.setContent": ('typing.Dict',),
-    "PySide2.QtLocation.QPlaceContentReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setTotalCount": ('int',),
-    "PySide2.QtLocation.QPlaceContentReply.totalCount": (),
-    "PySide2.QtLocation.QPlaceContentReply.type": (),
-# class PySide2.QtLocation.QPlaceContentRequest:
-    "PySide2.QtLocation.QPlaceContentRequest.__init__": [(), ('PySide2.QtLocation.QPlaceContentRequest',)],
-    "PySide2.QtLocation.QPlaceContentRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceContentRequest.clear": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentContext": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentType": (),
-    "PySide2.QtLocation.QPlaceContentRequest.limit": (),
-    "PySide2.QtLocation.QPlaceContentRequest.placeId": (),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentType": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlaceContentRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceContentRequest.setPlaceId": ('str',),
-# class PySide2.QtLocation.QPlaceDetailsReply:
-    "PySide2.QtLocation.QPlaceDetailsReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceDetailsReply.place": (),
-    "PySide2.QtLocation.QPlaceDetailsReply.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceDetailsReply.type": (),
-# class PySide2.QtLocation.QPlaceEditorial:
-    "PySide2.QtLocation.QPlaceEditorial.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceEditorial.language": (),
-    "PySide2.QtLocation.QPlaceEditorial.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setText": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.text": (),
-    "PySide2.QtLocation.QPlaceEditorial.title": (),
-# class PySide2.QtLocation.QPlaceIcon:
-    "PySide2.QtLocation.QPlaceIcon.__init__": [(), ('PySide2.QtLocation.QPlaceIcon',)],
-    "PySide2.QtLocation.QPlaceIcon.__copy__": (),
-    "PySide2.QtLocation.QPlaceIcon.isEmpty": (),
-    "PySide2.QtLocation.QPlaceIcon.manager": (),
-    "PySide2.QtLocation.QPlaceIcon.parameters": (),
-    "PySide2.QtLocation.QPlaceIcon.setManager": ('PySide2.QtLocation.QPlaceManager',),
-    "PySide2.QtLocation.QPlaceIcon.setParameters": ('typing.Dict',),
-    "PySide2.QtLocation.QPlaceIcon.url": ('PySide2.QtCore.QSize',),
-# class PySide2.QtLocation.QPlaceIdReply:
-# class PySide2.QtLocation.QPlaceIdReply.OperationType:
-    "PySide2.QtLocation.QPlaceIdReply.__init__": ('PySide2.QtLocation.QPlaceIdReply.OperationType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceIdReply.id": (),
-    "PySide2.QtLocation.QPlaceIdReply.operationType": (),
-    "PySide2.QtLocation.QPlaceIdReply.setId": ('str',),
-    "PySide2.QtLocation.QPlaceIdReply.type": (),
-# class PySide2.QtLocation.QPlaceImage:
-    "PySide2.QtLocation.QPlaceImage.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceImage.imageId": (),
-    "PySide2.QtLocation.QPlaceImage.mimeType": (),
-    "PySide2.QtLocation.QPlaceImage.setImageId": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setMimeType": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceImage.url": (),
-# class PySide2.QtLocation.QPlaceManager:
-    "PySide2.QtLocation.QPlaceManager.category": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManager.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManager.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManager.locales": (),
-    "PySide2.QtLocation.QPlaceManager.managerName": (),
-    "PySide2.QtLocation.QPlaceManager.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManager.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManager.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManager.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManager.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QPlaceManager.setLocales": ('typing.Sequence',),
-# class PySide2.QtLocation.QPlaceManagerEngine:
-    "PySide2.QtLocation.QPlaceManagerEngine.__init__": ('typing.Dict', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceManagerEngine.category": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.constructIconUrl": ('PySide2.QtLocation.QPlaceIcon', 'PySide2.QtCore.QSize'),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.locales": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.manager": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerName": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManagerEngine.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.setLocales": ('typing.Sequence',),
-# class PySide2.QtLocation.QPlaceMatchReply:
-    "PySide2.QtLocation.QPlaceMatchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceMatchReply.places": (),
-    "PySide2.QtLocation.QPlaceMatchReply.request": (),
-    "PySide2.QtLocation.QPlaceMatchReply.setPlaces": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlaceMatchReply.setRequest": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceMatchReply.type": (),
-# class PySide2.QtLocation.QPlaceMatchRequest:
-    "PySide2.QtLocation.QPlaceMatchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceMatchRequest',)],
-    "PySide2.QtLocation.QPlaceMatchRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.parameters": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.places": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.setParameters": ('typing.Dict',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setPlaces": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setResults": ('typing.Sequence',),
-# class PySide2.QtLocation.QPlaceProposedSearchResult:
-    "PySide2.QtLocation.QPlaceProposedSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceProposedSearchResult.searchRequest": (),
-    "PySide2.QtLocation.QPlaceProposedSearchResult.setSearchRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-# class PySide2.QtLocation.QPlaceRatings:
-    "PySide2.QtLocation.QPlaceRatings.__init__": [(), ('PySide2.QtLocation.QPlaceRatings',)],
-    "PySide2.QtLocation.QPlaceRatings.__copy__": (),
-    "PySide2.QtLocation.QPlaceRatings.average": (),
-    "PySide2.QtLocation.QPlaceRatings.count": (),
-    "PySide2.QtLocation.QPlaceRatings.isEmpty": (),
-    "PySide2.QtLocation.QPlaceRatings.maximum": (),
-    "PySide2.QtLocation.QPlaceRatings.setAverage": ('float',),
-    "PySide2.QtLocation.QPlaceRatings.setCount": ('int',),
-    "PySide2.QtLocation.QPlaceRatings.setMaximum": ('float',),
-# class PySide2.QtLocation.QPlaceReply:
-# class PySide2.QtLocation.QPlaceReply.Error:
-# class PySide2.QtLocation.QPlaceReply.Type:
-    "PySide2.QtLocation.QPlaceReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceReply.abort": (),
-    "PySide2.QtLocation.QPlaceReply.error": (),
-    "PySide2.QtLocation.QPlaceReply.errorString": (),
-    "PySide2.QtLocation.QPlaceReply.isFinished": (),
-    "PySide2.QtLocation.QPlaceReply.setError": ('PySide2.QtLocation.QPlaceReply.Error', 'str'),
-    "PySide2.QtLocation.QPlaceReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QPlaceReply.type": (),
-# class PySide2.QtLocation.QPlaceResult:
-    "PySide2.QtLocation.QPlaceResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceResult.distance": (),
-    "PySide2.QtLocation.QPlaceResult.isSponsored": (),
-    "PySide2.QtLocation.QPlaceResult.place": (),
-    "PySide2.QtLocation.QPlaceResult.setDistance": ('float',),
-    "PySide2.QtLocation.QPlaceResult.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceResult.setSponsored": ('bool',),
-# class PySide2.QtLocation.QPlaceReview:
-    "PySide2.QtLocation.QPlaceReview.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceReview.dateTime": (),
-    "PySide2.QtLocation.QPlaceReview.language": (),
-    "PySide2.QtLocation.QPlaceReview.rating": (),
-    "PySide2.QtLocation.QPlaceReview.reviewId": (),
-    "PySide2.QtLocation.QPlaceReview.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QPlaceReview.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setRating": ('float',),
-    "PySide2.QtLocation.QPlaceReview.setReviewId": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setText": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceReview.text": (),
-    "PySide2.QtLocation.QPlaceReview.title": (),
-# class PySide2.QtLocation.QPlaceSearchReply:
-    "PySide2.QtLocation.QPlaceSearchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.request": (),
-    "PySide2.QtLocation.QPlaceSearchReply.results": (),
-    "PySide2.QtLocation.QPlaceSearchReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setResults": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlaceSearchReply.type": (),
-# class PySide2.QtLocation.QPlaceSearchRequest:
-# class PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint:
-    "PySide2.QtLocation.QPlaceSearchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceSearchRequest',)],
-    "PySide2.QtLocation.QPlaceSearchRequest.categories": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.limit": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.recommendationId": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.relevanceHint": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchArea": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchContext": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchTerm": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategories": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRecommendationId": ('str',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRelevanceHint": ('PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchTerm": ('str',),
-# class PySide2.QtLocation.QPlaceSearchResult:
-# class PySide2.QtLocation.QPlaceSearchResult.SearchResultType:
-    "PySide2.QtLocation.QPlaceSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceSearchResult.icon": (),
-    "PySide2.QtLocation.QPlaceSearchResult.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSearchResult.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceSearchResult.title": (),
-    "PySide2.QtLocation.QPlaceSearchResult.type": (),
-# class PySide2.QtLocation.QPlaceSearchSuggestionReply:
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.setSuggestions": ('typing.Sequence',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.suggestions": (),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.type": (),
-# class PySide2.QtLocation.QPlaceSupplier:
-    "PySide2.QtLocation.QPlaceSupplier.__init__": [(), ('PySide2.QtLocation.QPlaceSupplier',)],
-    "PySide2.QtLocation.QPlaceSupplier.__copy__": (),
-    "PySide2.QtLocation.QPlaceSupplier.icon": (),
-    "PySide2.QtLocation.QPlaceSupplier.isEmpty": (),
-    "PySide2.QtLocation.QPlaceSupplier.name": (),
-    "PySide2.QtLocation.QPlaceSupplier.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSupplier.setName": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setSupplierId": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceSupplier.supplierId": (),
-    "PySide2.QtLocation.QPlaceSupplier.url": (),
-# class PySide2.QtLocation.QPlaceUser:
-    "PySide2.QtLocation.QPlaceUser.__init__": [(), ('PySide2.QtLocation.QPlaceUser',)],
-    "PySide2.QtLocation.QPlaceUser.__copy__": (),
-    "PySide2.QtLocation.QPlaceUser.name": (),
-    "PySide2.QtLocation.QPlaceUser.setName": ('str',),
-    "PySide2.QtLocation.QPlaceUser.setUserId": ('str',),
-    "PySide2.QtLocation.QPlaceUser.userId": (),
-    }) if "PySide2.QtLocation" in sys.modules else None
-# Module PySide2.QtQml
-sig_dict.update({
-# class PySide2.QtQml.ListProperty:
-    "PySide2.QtQml.ListProperty.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable'),
-# class PySide2.QtQml.QJSEngine:
-# class PySide2.QtQml.QJSEngine.Extension:
-# class PySide2.QtQml.QJSEngine.Extensions:
-    "PySide2.QtQml.QJSEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QJSEngine.collectGarbage": (),
-    "PySide2.QtQml.QJSEngine.evaluate": ('str', 'str', 'int'),
-    "PySide2.QtQml.QJSEngine.globalObject": (),
-    "PySide2.QtQml.QJSEngine.importModule": ('str',),
-    "PySide2.QtQml.QJSEngine.installExtensions": ('PySide2.QtQml.QJSEngine.Extensions', 'PySide2.QtQml.QJSValue'),
-    "PySide2.QtQml.QJSEngine.installTranslatorFunctions": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSEngine.isInterrupted": (),
-    "PySide2.QtQml.QJSEngine.newArray": ('int',),
-    "PySide2.QtQml.QJSEngine.newErrorObject": ('PySide2.QtQml.QJSValue.ErrorType', 'str'),
-    "PySide2.QtQml.QJSEngine.newObject": (),
-    "PySide2.QtQml.QJSEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtQml.QJSEngine.newQObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QJSEngine.setInterrupted": ('bool',),
-    "PySide2.QtQml.QJSEngine.throwError": [('PySide2.QtQml.QJSValue.ErrorType', 'str'), ('str',)],
-    "PySide2.QtQml.QJSEngine.toScriptValue": ('typing.Any',),
-# class PySide2.QtQml.QJSValue:
-# class PySide2.QtQml.QJSValue.ErrorType:
-# class PySide2.QtQml.QJSValue.SpecialValue:
-    "PySide2.QtQml.QJSValue.__init__": [('PySide2.QtQml.QJSValue',), ('PySide2.QtQml.QJSValue.SpecialValue',), ('bool',), ('bytes',), ('float',), ('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.__copy__": (),
-    "PySide2.QtQml.QJSValue.call": ('typing.Sequence',),
-    "PySide2.QtQml.QJSValue.callAsConstructor": ('typing.Sequence',),
-    "PySide2.QtQml.QJSValue.callWithInstance": ('PySide2.QtQml.QJSValue', 'typing.Sequence'),
-    "PySide2.QtQml.QJSValue.deleteProperty": ('str',),
-    "PySide2.QtQml.QJSValue.engine": (),
-    "PySide2.QtQml.QJSValue.equals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.errorType": (),
-    "PySide2.QtQml.QJSValue.hasOwnProperty": ('str',),
-    "PySide2.QtQml.QJSValue.hasProperty": ('str',),
-    "PySide2.QtQml.QJSValue.isArray": (),
-    "PySide2.QtQml.QJSValue.isBool": (),
-    "PySide2.QtQml.QJSValue.isCallable": (),
-    "PySide2.QtQml.QJSValue.isDate": (),
-    "PySide2.QtQml.QJSValue.isError": (),
-    "PySide2.QtQml.QJSValue.isNull": (),
-    "PySide2.QtQml.QJSValue.isNumber": (),
-    "PySide2.QtQml.QJSValue.isObject": (),
-    "PySide2.QtQml.QJSValue.isQMetaObject": (),
-    "PySide2.QtQml.QJSValue.isQObject": (),
-    "PySide2.QtQml.QJSValue.isRegExp": (),
-    "PySide2.QtQml.QJSValue.isString": (),
-    "PySide2.QtQml.QJSValue.isUndefined": (),
-    "PySide2.QtQml.QJSValue.isVariant": (),
-    "PySide2.QtQml.QJSValue.property": [('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.prototype": (),
-    "PySide2.QtQml.QJSValue.setProperty": [('int', 'PySide2.QtQml.QJSValue'), ('str', 'PySide2.QtQml.QJSValue')],
-    "PySide2.QtQml.QJSValue.setPrototype": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.strictlyEquals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.toBool": (),
-    "PySide2.QtQml.QJSValue.toDateTime": (),
-    "PySide2.QtQml.QJSValue.toInt": (),
-    "PySide2.QtQml.QJSValue.toNumber": (),
-    "PySide2.QtQml.QJSValue.toQMetaObject": (),
-    "PySide2.QtQml.QJSValue.toQObject": (),
-    "PySide2.QtQml.QJSValue.toString": (),
-    "PySide2.QtQml.QJSValue.toUInt": (),
-    "PySide2.QtQml.QJSValue.toVariant": (),
-# class PySide2.QtQml.QJSValueIterator:
-    "PySide2.QtQml.QJSValueIterator.__init__": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValueIterator.hasNext": (),
-    "PySide2.QtQml.QJSValueIterator.name": (),
-    "PySide2.QtQml.QJSValueIterator.value": (),
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor:
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType:
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.__init__": (),
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.intercept": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType'),
-# class PySide2.QtQml.QQmlApplicationEngine:
-    "PySide2.QtQml.QQmlApplicationEngine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlApplicationEngine.load": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlApplicationEngine.loadData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlApplicationEngine.rootObjects": (),
-    "PySide2.QtQml.QQmlApplicationEngine.setInitialProperties": ('typing.Dict',),
-# class PySide2.QtQml.QQmlComponent:
-# class PySide2.QtQml.QQmlComponent.CompilationMode:
-# class PySide2.QtQml.QQmlComponent.Status:
-    "PySide2.QtQml.QQmlComponent.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlComponent.beginCreate": ('PySide2.QtQml.QQmlContext',),
-    "PySide2.QtQml.QQmlComponent.completeCreate": (),
-    "PySide2.QtQml.QQmlComponent.create": [('PySide2.QtQml.QQmlContext',), ('PySide2.QtQml.QQmlIncubator', 'PySide2.QtQml.QQmlContext', 'PySide2.QtQml.QQmlContext')],
-    "PySide2.QtQml.QQmlComponent.createWithInitialProperties": ('typing.Dict', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlComponent.creationContext": (),
-    "PySide2.QtQml.QQmlComponent.engine": (),
-    "PySide2.QtQml.QQmlComponent.errorString": (),
-    "PySide2.QtQml.QQmlComponent.errors": (),
-    "PySide2.QtQml.QQmlComponent.isError": (),
-    "PySide2.QtQml.QQmlComponent.isLoading": (),
-    "PySide2.QtQml.QQmlComponent.isNull": (),
-    "PySide2.QtQml.QQmlComponent.isReady": (),
-    "PySide2.QtQml.QQmlComponent.loadUrl": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode')],
-    "PySide2.QtQml.QQmlComponent.progress": (),
-    "PySide2.QtQml.QQmlComponent.setData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlComponent.setInitialProperties": ('PySide2.QtCore.QObject', 'typing.Dict'),
-    "PySide2.QtQml.QQmlComponent.status": (),
-    "PySide2.QtQml.QQmlComponent.url": (),
-# class PySide2.QtQml.QQmlContext:
-    "PySide2.QtQml.QQmlContext.__init__": [('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlContext.baseUrl": (),
-    "PySide2.QtQml.QQmlContext.contextObject": (),
-    "PySide2.QtQml.QQmlContext.contextProperty": ('str',),
-    "PySide2.QtQml.QQmlContext.engine": (),
-    "PySide2.QtQml.QQmlContext.isValid": (),
-    "PySide2.QtQml.QQmlContext.nameForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.parentContext": (),
-    "PySide2.QtQml.QQmlContext.resolvedUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setContextObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.setContextProperty": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Any')],
-# class PySide2.QtQml.QQmlDebuggingEnabler:
-# class PySide2.QtQml.QQmlDebuggingEnabler.StartMode:
-    "PySide2.QtQml.QQmlDebuggingEnabler.__init__": ('bool',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.connectToLocalDebugger": ('str', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.debuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.inspectorServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.nativeDebuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.profilerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.setServices": ('typing.Sequence',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startDebugConnector": ('str', 'typing.Dict'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startTcpDebugServer": ('int', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode', 'str'),
-# class PySide2.QtQml.QQmlEngine:
-# class PySide2.QtQml.QQmlEngine.ObjectOwnership:
-    "PySide2.QtQml.QQmlEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.addImageProvider": ('str', 'PySide2.QtQml.QQmlImageProviderBase'),
-    "PySide2.QtQml.QQmlEngine.addImportPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.addNamedBundle": ('str', 'str'),
-    "PySide2.QtQml.QQmlEngine.addPluginPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.baseUrl": (),
-    "PySide2.QtQml.QQmlEngine.clearComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.contextForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQml.QQmlEngine.imageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.importPathList": (),
-    "PySide2.QtQml.QQmlEngine.importPlugin": ('str', 'str', 'typing.Sequence'),
-    "PySide2.QtQml.QQmlEngine.incubationController": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManager": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManagerFactory": (),
-    "PySide2.QtQml.QQmlEngine.objectOwnership": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.offlineStorageDatabaseFilePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.offlineStoragePath": (),
-    "PySide2.QtQml.QQmlEngine.outputWarningsToStandardError": (),
-    "PySide2.QtQml.QQmlEngine.pluginPathList": (),
-    "PySide2.QtQml.QQmlEngine.removeImageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.retranslate": (),
-    "PySide2.QtQml.QQmlEngine.rootContext": (),
-    "PySide2.QtQml.QQmlEngine.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlEngine.setContextForObject": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlEngine.setImportPathList": ('typing.Sequence',),
-    "PySide2.QtQml.QQmlEngine.setIncubationController": ('PySide2.QtQml.QQmlIncubationController',),
-    "PySide2.QtQml.QQmlEngine.setNetworkAccessManagerFactory": ('PySide2.QtQml.QQmlNetworkAccessManagerFactory',),
-    "PySide2.QtQml.QQmlEngine.setObjectOwnership": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine.ObjectOwnership'),
-    "PySide2.QtQml.QQmlEngine.setOfflineStoragePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.setOutputWarningsToStandardError": ('bool',),
-    "PySide2.QtQml.QQmlEngine.setPluginPathList": ('typing.Sequence',),
-    "PySide2.QtQml.QQmlEngine.setUrlInterceptor": ('PySide2.QtQml.QQmlAbstractUrlInterceptor',),
-    "PySide2.QtQml.QQmlEngine.trimComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.urlInterceptor": (),
-# class PySide2.QtQml.QQmlError:
-    "PySide2.QtQml.QQmlError.__init__": [(), ('PySide2.QtQml.QQmlError',)],
-    "PySide2.QtQml.QQmlError.__copy__": (),
-    "PySide2.QtQml.QQmlError.column": (),
-    "PySide2.QtQml.QQmlError.description": (),
-    "PySide2.QtQml.QQmlError.isValid": (),
-    "PySide2.QtQml.QQmlError.line": (),
-    "PySide2.QtQml.QQmlError.messageType": (),
-    "PySide2.QtQml.QQmlError.object": (),
-    "PySide2.QtQml.QQmlError.setColumn": ('int',),
-    "PySide2.QtQml.QQmlError.setDescription": ('str',),
-    "PySide2.QtQml.QQmlError.setLine": ('int',),
-    "PySide2.QtQml.QQmlError.setMessageType": ('PySide2.QtCore.QtMsgType',),
-    "PySide2.QtQml.QQmlError.setObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlError.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlError.toString": (),
-    "PySide2.QtQml.QQmlError.url": (),
-# class PySide2.QtQml.QQmlExpression:
-    "PySide2.QtQml.QQmlExpression.__init__": [(), ('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlScriptString', 'PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlExpression.clearError": (),
-    "PySide2.QtQml.QQmlExpression.columnNumber": (),
-    "PySide2.QtQml.QQmlExpression.context": (),
-    "PySide2.QtQml.QQmlExpression.engine": (),
-    "PySide2.QtQml.QQmlExpression.error": (),
-    "PySide2.QtQml.QQmlExpression.evaluate": (),
-    "PySide2.QtQml.QQmlExpression.expression": (),
-    "PySide2.QtQml.QQmlExpression.hasError": (),
-    "PySide2.QtQml.QQmlExpression.lineNumber": (),
-    "PySide2.QtQml.QQmlExpression.notifyOnValueChanged": (),
-    "PySide2.QtQml.QQmlExpression.scopeObject": (),
-    "PySide2.QtQml.QQmlExpression.setExpression": ('str',),
-    "PySide2.QtQml.QQmlExpression.setNotifyOnValueChanged": ('bool',),
-    "PySide2.QtQml.QQmlExpression.setSourceLocation": ('str', 'int', 'int'),
-    "PySide2.QtQml.QQmlExpression.sourceFile": (),
-# class PySide2.QtQml.QQmlExtensionInterface:
-    "PySide2.QtQml.QQmlExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlExtensionInterface.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'bytes'),
-# class PySide2.QtQml.QQmlExtensionPlugin:
-    "PySide2.QtQml.QQmlExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlExtensionPlugin.baseUrl": (),
-    "PySide2.QtQml.QQmlExtensionPlugin.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'bytes'),
-    "PySide2.QtQml.QQmlExtensionPlugin.registerTypes": ('bytes',),
-# class PySide2.QtQml.QQmlFile:
-# class PySide2.QtQml.QQmlFile.Status:
-    "PySide2.QtQml.QQmlFile.__init__": [(), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.clear": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QQmlFile.connectDownloadProgress": [('PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtCore.QObject', 'int')],
-    "PySide2.QtQml.QQmlFile.connectFinished": [('PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtCore.QObject', 'int')],
-    "PySide2.QtQml.QQmlFile.data": (),
-    "PySide2.QtQml.QQmlFile.dataByteArray": (),
-    "PySide2.QtQml.QQmlFile.error": (),
-    "PySide2.QtQml.QQmlFile.isError": (),
-    "PySide2.QtQml.QQmlFile.isLoading": (),
-    "PySide2.QtQml.QQmlFile.isLocalFile": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.isNull": (),
-    "PySide2.QtQml.QQmlFile.isReady": (),
-    "PySide2.QtQml.QQmlFile.isSynchronous": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.load": [('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.size": (),
-    "PySide2.QtQml.QQmlFile.status": (),
-    "PySide2.QtQml.QQmlFile.url": (),
-    "PySide2.QtQml.QQmlFile.urlToLocalFileOrQrc": [('PySide2.QtCore.QUrl',), ('str',)],
-# class PySide2.QtQml.QQmlFileSelector:
-    "PySide2.QtQml.QQmlFileSelector.__init__": ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQml.QQmlFileSelector.get": ('PySide2.QtQml.QQmlEngine',),
-    "PySide2.QtQml.QQmlFileSelector.selector": (),
-    "PySide2.QtQml.QQmlFileSelector.setExtraSelectors": ('typing.Sequence',),
-    "PySide2.QtQml.QQmlFileSelector.setSelector": ('PySide2.QtCore.QFileSelector',),
-# class PySide2.QtQml.QQmlImageProviderBase:
-# class PySide2.QtQml.QQmlImageProviderBase.Flag:
-# class PySide2.QtQml.QQmlImageProviderBase.Flags:
-# class PySide2.QtQml.QQmlImageProviderBase.ImageType:
-    "PySide2.QtQml.QQmlImageProviderBase.flags": (),
-    "PySide2.QtQml.QQmlImageProviderBase.imageType": (),
-# class PySide2.QtQml.QQmlIncubationController:
-    "PySide2.QtQml.QQmlIncubationController.__init__": (),
-    "PySide2.QtQml.QQmlIncubationController.engine": (),
-    "PySide2.QtQml.QQmlIncubationController.incubateFor": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubateWhile": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCount": (),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCountChanged": ('int',),
-# class PySide2.QtQml.QQmlIncubator:
-# class PySide2.QtQml.QQmlIncubator.IncubationMode:
-# class PySide2.QtQml.QQmlIncubator.Status:
-    "PySide2.QtQml.QQmlIncubator.__init__": ('PySide2.QtQml.QQmlIncubator.IncubationMode',),
-    "PySide2.QtQml.QQmlIncubator.clear": (),
-    "PySide2.QtQml.QQmlIncubator.errors": (),
-    "PySide2.QtQml.QQmlIncubator.forceCompletion": (),
-    "PySide2.QtQml.QQmlIncubator.incubationMode": (),
-    "PySide2.QtQml.QQmlIncubator.isError": (),
-    "PySide2.QtQml.QQmlIncubator.isLoading": (),
-    "PySide2.QtQml.QQmlIncubator.isNull": (),
-    "PySide2.QtQml.QQmlIncubator.isReady": (),
-    "PySide2.QtQml.QQmlIncubator.object": (),
-    "PySide2.QtQml.QQmlIncubator.setInitialState": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlIncubator.status": (),
-    "PySide2.QtQml.QQmlIncubator.statusChanged": ('PySide2.QtQml.QQmlIncubator.Status',),
-# class PySide2.QtQml.QQmlListReference:
-    "PySide2.QtQml.QQmlListReference.__init__": [(), ('PySide2.QtCore.QObject', 'bytes', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlListReference',)],
-    "PySide2.QtQml.QQmlListReference.__copy__": (),
-    "PySide2.QtQml.QQmlListReference.append": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlListReference.at": ('int',),
-    "PySide2.QtQml.QQmlListReference.canAppend": (),
-    "PySide2.QtQml.QQmlListReference.canAt": (),
-    "PySide2.QtQml.QQmlListReference.canClear": (),
-    "PySide2.QtQml.QQmlListReference.canCount": (),
-    "PySide2.QtQml.QQmlListReference.clear": (),
-    "PySide2.QtQml.QQmlListReference.count": (),
-    "PySide2.QtQml.QQmlListReference.isManipulable": (),
-    "PySide2.QtQml.QQmlListReference.isReadable": (),
-    "PySide2.QtQml.QQmlListReference.isValid": (),
-    "PySide2.QtQml.QQmlListReference.listElementType": (),
-    "PySide2.QtQml.QQmlListReference.object": (),
-# class PySide2.QtQml.QQmlNetworkAccessManagerFactory:
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.__init__": (),
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.create": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.QQmlParserStatus:
-    "PySide2.QtQml.QQmlParserStatus.__init__": (),
-    "PySide2.QtQml.QQmlParserStatus.classBegin": (),
-    "PySide2.QtQml.QQmlParserStatus.componentComplete": (),
-# class PySide2.QtQml.QQmlProperty:
-# class PySide2.QtQml.QQmlProperty.PropertyTypeCategory:
-# class PySide2.QtQml.QQmlProperty.Type:
-    "PySide2.QtQml.QQmlProperty.__init__": [(), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlProperty',)],
-    "PySide2.QtQml.QQmlProperty.__copy__": (),
-    "PySide2.QtQml.QQmlProperty.connectNotifySignal": [('PySide2.QtCore.QObject', 'bytes'), ('PySide2.QtCore.QObject', 'int')],
-    "PySide2.QtQml.QQmlProperty.hasNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.index": (),
-    "PySide2.QtQml.QQmlProperty.isDesignable": (),
-    "PySide2.QtQml.QQmlProperty.isProperty": (),
-    "PySide2.QtQml.QQmlProperty.isResettable": (),
-    "PySide2.QtQml.QQmlProperty.isSignalProperty": (),
-    "PySide2.QtQml.QQmlProperty.isValid": (),
-    "PySide2.QtQml.QQmlProperty.isWritable": (),
-    "PySide2.QtQml.QQmlProperty.method": (),
-    "PySide2.QtQml.QQmlProperty.name": (),
-    "PySide2.QtQml.QQmlProperty.needsNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.object": (),
-    "PySide2.QtQml.QQmlProperty.property": (),
-    "PySide2.QtQml.QQmlProperty.propertyType": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeCategory": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeName": (),
-    "PySide2.QtQml.QQmlProperty.read": [(), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine')],
-    "PySide2.QtQml.QQmlProperty.reset": (),
-    "PySide2.QtQml.QQmlProperty.type": (),
-    "PySide2.QtQml.QQmlProperty.write": [('PySide2.QtCore.QObject', 'str', 'typing.Any'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlEngine'), ('typing.Any',)],
-# class PySide2.QtQml.QQmlPropertyMap:
-    "PySide2.QtQml.QQmlPropertyMap.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlPropertyMap.clear": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.contains": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.count": (),
-    "PySide2.QtQml.QQmlPropertyMap.insert": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.isEmpty": (),
-    "PySide2.QtQml.QQmlPropertyMap.keys": (),
-    "PySide2.QtQml.QQmlPropertyMap.size": (),
-    "PySide2.QtQml.QQmlPropertyMap.updateValue": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.value": ('str',),
-# class PySide2.QtQml.QQmlPropertyValueSource:
-    "PySide2.QtQml.QQmlPropertyValueSource.__init__": (),
-    "PySide2.QtQml.QQmlPropertyValueSource.setTarget": ('PySide2.QtQml.QQmlProperty',),
-# class PySide2.QtQml.QQmlScriptString:
-    "PySide2.QtQml.QQmlScriptString.__init__": [(), ('PySide2.QtQml.QQmlScriptString',)],
-    "PySide2.QtQml.QQmlScriptString.__copy__": (),
-    "PySide2.QtQml.QQmlScriptString.booleanLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isEmpty": (),
-    "PySide2.QtQml.QQmlScriptString.isNullLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isUndefinedLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.numberLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.stringLiteral": (),
-# class PySide2.QtQml.QQmlTypesExtensionInterface:
-    "PySide2.QtQml.QQmlTypesExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlTypesExtensionInterface.registerTypes": ('bytes',),
-# class PySide2.QtQml.QtQml:
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObject": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObjectById": ('int', 'PySide2.QtCore.QObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlContext": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlEngine": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlExecuteDeferred": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.VolatileBool:
-    "PySide2.QtQml.VolatileBool.get": (),
-    "PySide2.QtQml.VolatileBool.set": ('object',),
-    "PySide2.QtQml.VolatileBool.qmlRegisterType": ('type', 'bytes', 'int', 'int', 'bytes'),
-    }) if "PySide2.QtQml" in sys.modules else None
-# Module PySide2.QtQuick
-sig_dict.update({
-# class PySide2.QtQuick.QQuickAsyncImageProvider:
-    "PySide2.QtQuick.QQuickAsyncImageProvider.__init__": (),
-    "PySide2.QtQuick.QQuickAsyncImageProvider.requestImageResponse": ('str', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickFramebufferObject:
-# class PySide2.QtQuick.QQuickFramebufferObject.Renderer:
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.__init__": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.createFramebufferObject": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.framebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.invalidateFramebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.render": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.synchronize": ('PySide2.QtQuick.QQuickFramebufferObject',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.update": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickFramebufferObject.createRenderer": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickFramebufferObject.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.mirrorVertically": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.releaseResources": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.setMirrorVertically": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.setTextureFollowsItemSize": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureFollowsItemSize": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickImageProvider:
-    "PySide2.QtQuick.QQuickImageProvider.__init__": ('PySide2.QtQml.QQmlImageProviderBase.ImageType', 'PySide2.QtQml.QQmlImageProviderBase.Flags'),
-    "PySide2.QtQuick.QQuickImageProvider.flags": (),
-    "PySide2.QtQuick.QQuickImageProvider.imageType": (),
-    "PySide2.QtQuick.QQuickImageProvider.requestImage": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestPixmap": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestTexture": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickImageResponse:
-    "PySide2.QtQuick.QQuickImageResponse.__init__": (),
-    "PySide2.QtQuick.QQuickImageResponse.cancel": (),
-    "PySide2.QtQuick.QQuickImageResponse.errorString": (),
-    "PySide2.QtQuick.QQuickImageResponse.textureFactory": (),
-# class PySide2.QtQuick.QQuickItem:
-# class PySide2.QtQuick.QQuickItem.Flag:
-# class PySide2.QtQuick.QQuickItem.Flags:
-# class PySide2.QtQuick.QQuickItem.ItemChange:
-# class PySide2.QtQuick.QQuickItem.TransformOrigin:
-# class PySide2.QtQuick.QQuickItem.UpdatePaintNodeData:
-    "PySide2.QtQuick.QQuickItem.UpdatePaintNodeData.__copy__": (),
-    "PySide2.QtQuick.QQuickItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.acceptHoverEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptTouchEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptedMouseButtons": (),
-    "PySide2.QtQuick.QQuickItem.activeFocusOnTab": (),
-    "PySide2.QtQuick.QQuickItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickItem.baselineOffset": (),
-    "PySide2.QtQuick.QQuickItem.boundingRect": (),
-    "PySide2.QtQuick.QQuickItem.childAt": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.childItems": (),
-    "PySide2.QtQuick.QQuickItem.childMouseEventFilter": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickItem.childrenRect": (),
-    "PySide2.QtQuick.QQuickItem.classBegin": (),
-    "PySide2.QtQuick.QQuickItem.clip": (),
-    "PySide2.QtQuick.QQuickItem.clipRect": (),
-    "PySide2.QtQuick.QQuickItem.componentComplete": (),
-    "PySide2.QtQuick.QQuickItem.containmentMask": (),
-    "PySide2.QtQuick.QQuickItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.cursor": (),
-    "PySide2.QtQuick.QQuickItem.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuick.QQuickItem.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuick.QQuickItem.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuick.QQuickItem.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuick.QQuickItem.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItem.filtersChildMouseEvents": (),
-    "PySide2.QtQuick.QQuickItem.flags": (),
-    "PySide2.QtQuick.QQuickItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.forceActiveFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtQuick.QQuickItem.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.grabMouse": (),
-    "PySide2.QtQuick.QQuickItem.grabToImage": [('PySide2.QtCore.QSize',), ('PySide2.QtQml.QJSValue', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickItem.grabTouchPoints": ('typing.List',),
-    "PySide2.QtQuick.QQuickItem.hasActiveFocus": (),
-    "PySide2.QtQuick.QQuickItem.hasFocus": (),
-    "PySide2.QtQuick.QQuickItem.height": (),
-    "PySide2.QtQuick.QQuickItem.heightValid": (),
-    "PySide2.QtQuick.QQuickItem.hoverEnterEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverLeaveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverMoveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.implicitHeight": (),
-    "PySide2.QtQuick.QQuickItem.implicitWidth": (),
-    "PySide2.QtQuick.QQuickItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtQuick.QQuickItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtQuick.QQuickItem.isAncestorOf": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.isComponentComplete": (),
-    "PySide2.QtQuick.QQuickItem.isEnabled": (),
-    "PySide2.QtQuick.QQuickItem.isFocusScope": (),
-    "PySide2.QtQuick.QQuickItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickItem.isUnderMouse": (),
-    "PySide2.QtQuick.QQuickItem.isVisible": (),
-    "PySide2.QtQuick.QQuickItem.itemTransform": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.keepMouseGrab": (),
-    "PySide2.QtQuick.QQuickItem.keepTouchGrab": (),
-    "PySide2.QtQuick.QQuickItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.mapFromGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapFromScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapRectFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectFromScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapRectToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectToScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapToGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapToScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.nextItemInFocusChain": ('bool',),
-    "PySide2.QtQuick.QQuickItem.opacity": (),
-    "PySide2.QtQuick.QQuickItem.parentItem": (),
-    "PySide2.QtQuick.QQuickItem.polish": (),
-    "PySide2.QtQuick.QQuickItem.position": (),
-    "PySide2.QtQuick.QQuickItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickItem.resetAntialiasing": (),
-    "PySide2.QtQuick.QQuickItem.resetHeight": (),
-    "PySide2.QtQuick.QQuickItem.resetWidth": (),
-    "PySide2.QtQuick.QQuickItem.rotation": (),
-    "PySide2.QtQuick.QQuickItem.scale": (),
-    "PySide2.QtQuick.QQuickItem.scopedFocusItem": (),
-    "PySide2.QtQuick.QQuickItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtQuick.QQuickItem.setActiveFocusOnTab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setBaselineOffset": ('float',),
-    "PySide2.QtQuick.QQuickItem.setClip": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setContainmentMask": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtQuick.QQuickItem.setEnabled": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFiltersChildMouseEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFlag": ('PySide2.QtQuick.QQuickItem.Flag', 'bool'),
-    "PySide2.QtQuick.QQuickItem.setFlags": ('PySide2.QtQuick.QQuickItem.Flags',),
-    "PySide2.QtQuick.QQuickItem.setFocus": [('bool',), ('bool', 'PySide2.QtCore.Qt.FocusReason')],
-    "PySide2.QtQuick.QQuickItem.setHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitSize": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.setImplicitWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setKeepMouseGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setKeepTouchGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setOpacity": ('float',),
-    "PySide2.QtQuick.QQuickItem.setParentItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setRotation": ('float',),
-    "PySide2.QtQuick.QQuickItem.setScale": ('float',),
-    "PySide2.QtQuick.QQuickItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtQuick.QQuickItem.setSmooth": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setState": ('str',),
-    "PySide2.QtQuick.QQuickItem.setTransformOrigin": ('PySide2.QtQuick.QQuickItem.TransformOrigin',),
-    "PySide2.QtQuick.QQuickItem.setTransformOriginPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setVisible": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setX": ('float',),
-    "PySide2.QtQuick.QQuickItem.setY": ('float',),
-    "PySide2.QtQuick.QQuickItem.setZ": ('float',),
-    "PySide2.QtQuick.QQuickItem.size": (),
-    "PySide2.QtQuick.QQuickItem.smooth": (),
-    "PySide2.QtQuick.QQuickItem.stackAfter": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.stackBefore": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.state": (),
-    "PySide2.QtQuick.QQuickItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickItem.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtQuick.QQuickItem.touchUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.transformOrigin": (),
-    "PySide2.QtQuick.QQuickItem.transformOriginPoint": (),
-    "PySide2.QtQuick.QQuickItem.ungrabMouse": (),
-    "PySide2.QtQuick.QQuickItem.ungrabTouchPoints": (),
-    "PySide2.QtQuick.QQuickItem.unsetCursor": (),
-    "PySide2.QtQuick.QQuickItem.update": (),
-    "PySide2.QtQuick.QQuickItem.updateInputMethod": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtQuick.QQuickItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-    "PySide2.QtQuick.QQuickItem.updatePolish": (),
-    "PySide2.QtQuick.QQuickItem.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtQuick.QQuickItem.width": (),
-    "PySide2.QtQuick.QQuickItem.widthValid": (),
-    "PySide2.QtQuick.QQuickItem.window": (),
-    "PySide2.QtQuick.QQuickItem.windowDeactivateEvent": (),
-    "PySide2.QtQuick.QQuickItem.x": (),
-    "PySide2.QtQuick.QQuickItem.y": (),
-    "PySide2.QtQuick.QQuickItem.z": (),
-# class PySide2.QtQuick.QQuickItemGrabResult:
-    "PySide2.QtQuick.QQuickItemGrabResult.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItemGrabResult.image": (),
-    "PySide2.QtQuick.QQuickItemGrabResult.saveToFile": ('str',),
-    "PySide2.QtQuick.QQuickItemGrabResult.url": (),
-# class PySide2.QtQuick.QQuickPaintedItem:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHint:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHints:
-# class PySide2.QtQuick.QQuickPaintedItem.RenderTarget:
-    "PySide2.QtQuick.QQuickPaintedItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickPaintedItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsBoundingRect": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsScale": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.fillColor": (),
-    "PySide2.QtQuick.QQuickPaintedItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.mipmap": (),
-    "PySide2.QtQuick.QQuickPaintedItem.opaquePainting": (),
-    "PySide2.QtQuick.QQuickPaintedItem.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtQuick.QQuickPaintedItem.performanceHints": (),
-    "PySide2.QtQuick.QQuickPaintedItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickPaintedItem.renderTarget": (),
-    "PySide2.QtQuick.QQuickPaintedItem.resetContentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsScale": ('float',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.setFillColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickPaintedItem.setMipmap": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setOpaquePainting": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHint": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHint', 'bool'),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHints": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHints',),
-    "PySide2.QtQuick.QQuickPaintedItem.setRenderTarget": ('PySide2.QtQuick.QQuickPaintedItem.RenderTarget',),
-    "PySide2.QtQuick.QQuickPaintedItem.setTextureSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.textureSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.update": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtQuick.QQuickPaintedItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickRenderControl:
-    "PySide2.QtQuick.QQuickRenderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickRenderControl.grab": (),
-    "PySide2.QtQuick.QQuickRenderControl.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QQuickRenderControl.invalidate": (),
-    "PySide2.QtQuick.QQuickRenderControl.polishItems": (),
-    "PySide2.QtQuick.QQuickRenderControl.prepareThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtQuick.QQuickRenderControl.render": (),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindow": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindowFor": ('PySide2.QtQuick.QQuickWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtQuick.QQuickRenderControl.sync": (),
-# class PySide2.QtQuick.QQuickTextDocument:
-    "PySide2.QtQuick.QQuickTextDocument.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTextDocument.textDocument": (),
-# class PySide2.QtQuick.QQuickTextureFactory:
-    "PySide2.QtQuick.QQuickTextureFactory.__init__": (),
-    "PySide2.QtQuick.QQuickTextureFactory.createTexture": ('PySide2.QtQuick.QQuickWindow',),
-    "PySide2.QtQuick.QQuickTextureFactory.image": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureByteCount": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureFactoryForImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtQuick.QQuickTextureFactory.textureSize": (),
-# class PySide2.QtQuick.QQuickTransform:
-    "PySide2.QtQuick.QQuickTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickTransform.appendToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QQuickTransform.prependToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.update": (),
-# class PySide2.QtQuick.QQuickView:
-# class PySide2.QtQuick.QQuickView.ResizeMode:
-# class PySide2.QtQuick.QQuickView.Status:
-    "PySide2.QtQuick.QQuickView.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtGui.QWindow'), ('PySide2.QtCore.QUrl', 'PySide2.QtQuick.QQuickRenderControl'), ('PySide2.QtGui.QWindow',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtQuick.QQuickView.engine": (),
-    "PySide2.QtQuick.QQuickView.errors": (),
-    "PySide2.QtQuick.QQuickView.initialSize": (),
-    "PySide2.QtQuick.QQuickView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickView.resizeMode": (),
-    "PySide2.QtQuick.QQuickView.rootContext": (),
-    "PySide2.QtQuick.QQuickView.rootObject": (),
-    "PySide2.QtQuick.QQuickView.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuick.QQuickView.setInitialProperties": ('typing.Dict',),
-    "PySide2.QtQuick.QQuickView.setResizeMode": ('PySide2.QtQuick.QQuickView.ResizeMode',),
-    "PySide2.QtQuick.QQuickView.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuick.QQuickView.sizeHint": (),
-    "PySide2.QtQuick.QQuickView.source": (),
-    "PySide2.QtQuick.QQuickView.status": (),
-    "PySide2.QtQuick.QQuickView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtQuick.QQuickWindow:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOption:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOptions:
-# class PySide2.QtQuick.QQuickWindow.NativeObjectType:
-# class PySide2.QtQuick.QQuickWindow.RenderStage:
-# class PySide2.QtQuick.QQuickWindow.SceneGraphError:
-# class PySide2.QtQuick.QQuickWindow.TextRenderType:
-    "PySide2.QtQuick.QQuickWindow.__init__": [('PySide2.QtGui.QWindow',), ('PySide2.QtQuick.QQuickRenderControl',)],
-    "PySide2.QtQuick.QQuickWindow.accessibleRoot": (),
-    "PySide2.QtQuick.QQuickWindow.activeFocusItem": (),
-    "PySide2.QtQuick.QQuickWindow.beginExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.clearBeforeRendering": (),
-    "PySide2.QtQuick.QQuickWindow.color": (),
-    "PySide2.QtQuick.QQuickWindow.contentItem": (),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromImage": [('PySide2.QtGui.QImage',), ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions')],
-    "PySide2.QtQuick.QQuickWindow.createTextureFromNativeObject": ('PySide2.QtQuick.QQuickWindow.NativeObjectType', 'int', 'int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.effectiveDevicePixelRatio": (),
-    "PySide2.QtQuick.QQuickWindow.endExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusObject": (),
-    "PySide2.QtQuick.QQuickWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.grabWindow": (),
-    "PySide2.QtQuick.QQuickWindow.hasDefaultAlphaBuffer": (),
-    "PySide2.QtQuick.QQuickWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuick.QQuickWindow.incubationController": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentOpenGLContext": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentSceneGraph": (),
-    "PySide2.QtQuick.QQuickWindow.isSceneGraphInitialized": (),
-    "PySide2.QtQuick.QQuickWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseGrabberItem": (),
-    "PySide2.QtQuick.QQuickWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.openglContext": (),
-    "PySide2.QtQuick.QQuickWindow.releaseResources": (),
-    "PySide2.QtQuick.QQuickWindow.renderTarget": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetId": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetSize": (),
-    "PySide2.QtQuick.QQuickWindow.resetOpenGLState": (),
-    "PySide2.QtQuick.QQuickWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickWindow.sceneGraphBackend": (),
-    "PySide2.QtQuick.QQuickWindow.scheduleRenderJob": ('PySide2.QtCore.QRunnable', 'PySide2.QtQuick.QQuickWindow.RenderStage'),
-    "PySide2.QtQuick.QQuickWindow.sendEvent": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickWindow.setClearBeforeRendering": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickWindow.setDefaultAlphaBuffer": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentOpenGLContext": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentSceneGraph": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setRenderTarget": [('PySide2.QtGui.QOpenGLFramebufferObject',), ('int', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickWindow.setSceneGraphBackend": ('str',),
-    "PySide2.QtQuick.QQuickWindow.setTextRenderType": ('PySide2.QtQuick.QQuickWindow.TextRenderType',),
-    "PySide2.QtQuick.QQuickWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuick.QQuickWindow.textRenderType": (),
-    "PySide2.QtQuick.QQuickWindow.update": (),
-    "PySide2.QtQuick.QQuickWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtQuick.QSGAbstractRenderer:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearMode:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearModeBit:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlag:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags:
-    "PySide2.QtQuick.QSGAbstractRenderer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearColor": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearMode": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.deviceRect": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.nodeChanged": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode.DirtyState'),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrix": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrixWithNativeNDC": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.renderScene": ('int',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearMode": ('PySide2.QtQuick.QSGAbstractRenderer.ClearMode',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setDeviceRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixToRect": [('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRectF', 'PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags')],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixWithNativeNDC": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setViewportRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.viewportRect": (),
-# class PySide2.QtQuick.QSGBasicGeometryNode:
-    "PySide2.QtQuick.QSGBasicGeometryNode.__init__": ('PySide2.QtQuick.QSGNode.NodeType',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.clipList": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.geometry": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.matrix": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setGeometry": ('PySide2.QtQuick.QSGGeometry',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererClipList": ('PySide2.QtQuick.QSGClipNode',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSGClipNode:
-    "PySide2.QtQuick.QSGClipNode.__init__": (),
-    "PySide2.QtQuick.QSGClipNode.clipRect": (),
-    "PySide2.QtQuick.QSGClipNode.isRectangular": (),
-    "PySide2.QtQuick.QSGClipNode.setClipRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGClipNode.setIsRectangular": ('bool',),
-# class PySide2.QtQuick.QSGDynamicTexture:
-    "PySide2.QtQuick.QSGDynamicTexture.__init__": (),
-    "PySide2.QtQuick.QSGDynamicTexture.updateTexture": (),
-# class PySide2.QtQuick.QSGEngine:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOption:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOptions:
-    "PySide2.QtQuick.QSGEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGEngine.createRenderer": (),
-    "PySide2.QtQuick.QSGEngine.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.createTextureFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QSGEngine.invalidate": (),
-# class PySide2.QtQuick.QSGGeometry:
-# class PySide2.QtQuick.QSGGeometry.Attribute:
-    "PySide2.QtQuick.QSGGeometry.Attribute.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Attribute',)],
-    "PySide2.QtQuick.QSGGeometry.Attribute.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Attribute.create": ('int', 'int', 'int', 'bool'),
-    "PySide2.QtQuick.QSGGeometry.Attribute.createWithAttributeType": ('int', 'int', 'int', 'PySide2.QtQuick.QSGGeometry.AttributeType'),
-# class PySide2.QtQuick.QSGGeometry.AttributeSet:
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__init__": [(), ('PySide2.QtQuick.QSGGeometry.AttributeSet',)],
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__copy__": (),
-# class PySide2.QtQuick.QSGGeometry.AttributeType:
-# class PySide2.QtQuick.QSGGeometry.ColoredPoint2D:
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.ColoredPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.set": ('float', 'float', 'int', 'int', 'int', 'int'),
-# class PySide2.QtQuick.QSGGeometry.DataPattern:
-# class PySide2.QtQuick.QSGGeometry.DrawingMode:
-# class PySide2.QtQuick.QSGGeometry.Point2D:
-    "PySide2.QtQuick.QSGGeometry.Point2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Point2D',)],
-    "PySide2.QtQuick.QSGGeometry.Point2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Point2D.set": ('float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.TexturedPoint2D:
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.TexturedPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.set": ('float', 'float', 'float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.Type:
-    "PySide2.QtQuick.QSGGeometry.__init__": ('PySide2.QtQuick.QSGGeometry.AttributeSet', 'int', 'int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.allocate": ('int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.attributeCount": (),
-    "PySide2.QtQuick.QSGGeometry.attributes": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_ColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_Point2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_TexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.drawingMode": (),
-    "PySide2.QtQuick.QSGGeometry.indexCount": (),
-    "PySide2.QtQuick.QSGGeometry.indexData": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUInt": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUShort": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataPattern": (),
-    "PySide2.QtQuick.QSGGeometry.indexType": (),
-    "PySide2.QtQuick.QSGGeometry.lineWidth": (),
-    "PySide2.QtQuick.QSGGeometry.markIndexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.markVertexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.setDrawingMode": ('int',),
-    "PySide2.QtQuick.QSGGeometry.setIndexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.setLineWidth": ('float',),
-    "PySide2.QtQuick.QSGGeometry.setVertexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.sizeOfIndex": (),
-    "PySide2.QtQuick.QSGGeometry.sizeOfVertex": (),
-    "PySide2.QtQuick.QSGGeometry.updateColoredRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateTexturedRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.vertexCount": (),
-    "PySide2.QtQuick.QSGGeometry.vertexData": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsTexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataPattern": (),
-# class PySide2.QtQuick.QSGGeometryNode:
-    "PySide2.QtQuick.QSGGeometryNode.__init__": (),
-    "PySide2.QtQuick.QSGGeometryNode.inheritedOpacity": (),
-    "PySide2.QtQuick.QSGGeometryNode.renderOrder": (),
-    "PySide2.QtQuick.QSGGeometryNode.setInheritedOpacity": ('float',),
-    "PySide2.QtQuick.QSGGeometryNode.setRenderOrder": ('int',),
-# class PySide2.QtQuick.QSGMaterialType:
-    "PySide2.QtQuick.QSGMaterialType.__init__": (),
-# class PySide2.QtQuick.QSGNode:
-# class PySide2.QtQuick.QSGNode.DirtyState:
-# class PySide2.QtQuick.QSGNode.DirtyStateBit:
-# class PySide2.QtQuick.QSGNode.Flag:
-# class PySide2.QtQuick.QSGNode.Flags:
-# class PySide2.QtQuick.QSGNode.NodeType:
-    "PySide2.QtQuick.QSGNode.__init__": [(), ('PySide2.QtQuick.QSGNode.NodeType',)],
-    "PySide2.QtQuick.QSGNode.appendChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.childAtIndex": ('int',),
-    "PySide2.QtQuick.QSGNode.childCount": (),
-    "PySide2.QtQuick.QSGNode.clearDirty": (),
-    "PySide2.QtQuick.QSGNode.dirtyState": (),
-    "PySide2.QtQuick.QSGNode.firstChild": (),
-    "PySide2.QtQuick.QSGNode.flags": (),
-    "PySide2.QtQuick.QSGNode.insertChildNodeAfter": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.insertChildNodeBefore": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGNode.lastChild": (),
-    "PySide2.QtQuick.QSGNode.markDirty": ('PySide2.QtQuick.QSGNode.DirtyState',),
-    "PySide2.QtQuick.QSGNode.nextSibling": (),
-    "PySide2.QtQuick.QSGNode.parent": (),
-    "PySide2.QtQuick.QSGNode.prependChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.preprocess": (),
-    "PySide2.QtQuick.QSGNode.previousSibling": (),
-    "PySide2.QtQuick.QSGNode.removeAllChildNodes": (),
-    "PySide2.QtQuick.QSGNode.removeChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.reparentChildNodesTo": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.setFlag": ('PySide2.QtQuick.QSGNode.Flag', 'bool'),
-    "PySide2.QtQuick.QSGNode.setFlags": ('PySide2.QtQuick.QSGNode.Flags', 'bool'),
-    "PySide2.QtQuick.QSGNode.type": (),
-# class PySide2.QtQuick.QSGOpacityNode:
-    "PySide2.QtQuick.QSGOpacityNode.__init__": (),
-    "PySide2.QtQuick.QSGOpacityNode.combinedOpacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGOpacityNode.opacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.setCombinedOpacity": ('float',),
-    "PySide2.QtQuick.QSGOpacityNode.setOpacity": ('float',),
-# class PySide2.QtQuick.QSGSimpleRectNode:
-    "PySide2.QtQuick.QSGSimpleRectNode.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor')],
-    "PySide2.QtQuick.QSGSimpleRectNode.color": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGSimpleRectNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-# class PySide2.QtQuick.QSGSimpleTextureNode:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformFlag:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode:
-    "PySide2.QtQuick.QSGSimpleTextureNode.__init__": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.filtering": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.ownsTexture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setOwnsTexture": ('bool',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setSourceRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTexture": ('PySide2.QtQuick.QSGTexture',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTextureCoordinatesTransform": ('PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.sourceRect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.texture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.textureCoordinatesTransform": (),
-# class PySide2.QtQuick.QSGTexture:
-# class PySide2.QtQuick.QSGTexture.AnisotropyLevel:
-# class PySide2.QtQuick.QSGTexture.Filtering:
-# class PySide2.QtQuick.QSGTexture.WrapMode:
-    "PySide2.QtQuick.QSGTexture.__init__": (),
-    "PySide2.QtQuick.QSGTexture.anisotropyLevel": (),
-    "PySide2.QtQuick.QSGTexture.bind": (),
-    "PySide2.QtQuick.QSGTexture.comparisonKey": (),
-    "PySide2.QtQuick.QSGTexture.convertToNormalizedSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGTexture.filtering": (),
-    "PySide2.QtQuick.QSGTexture.hasAlphaChannel": (),
-    "PySide2.QtQuick.QSGTexture.hasMipmaps": (),
-    "PySide2.QtQuick.QSGTexture.horizontalWrapMode": (),
-    "PySide2.QtQuick.QSGTexture.isAtlasTexture": (),
-    "PySide2.QtQuick.QSGTexture.mipmapFiltering": (),
-    "PySide2.QtQuick.QSGTexture.normalizedTextureSubRect": (),
-    "PySide2.QtQuick.QSGTexture.removedFromAtlas": (),
-    "PySide2.QtQuick.QSGTexture.setAnisotropyLevel": ('PySide2.QtQuick.QSGTexture.AnisotropyLevel',),
-    "PySide2.QtQuick.QSGTexture.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setHorizontalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.setMipmapFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setVerticalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.textureId": (),
-    "PySide2.QtQuick.QSGTexture.textureSize": (),
-    "PySide2.QtQuick.QSGTexture.updateBindOptions": ('bool',),
-    "PySide2.QtQuick.QSGTexture.verticalWrapMode": (),
-# class PySide2.QtQuick.QSGTextureProvider:
-    "PySide2.QtQuick.QSGTextureProvider.__init__": (),
-    "PySide2.QtQuick.QSGTextureProvider.texture": (),
-# class PySide2.QtQuick.QSGTransformNode:
-    "PySide2.QtQuick.QSGTransformNode.__init__": (),
-    "PySide2.QtQuick.QSGTransformNode.combinedMatrix": (),
-    "PySide2.QtQuick.QSGTransformNode.matrix": (),
-    "PySide2.QtQuick.QSGTransformNode.setCombinedMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGTransformNode.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >:
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.__copy__": (),
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.data": (),
-    }) if "PySide2.QtQuick" in sys.modules else None
-# Module PySide2.QtQuickWidgets
-sig_dict.update({
-# class PySide2.QtQuickWidgets.QQuickWidget:
-# class PySide2.QtQuickWidgets.QQuickWidget.ResizeMode:
-# class PySide2.QtQuickWidgets.QQuickWidget.Status:
-    "PySide2.QtQuickWidgets.QQuickWidget.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtQuickWidgets.QQuickWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.engine": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.errors": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.format": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.grabFramebuffer": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.initialSize": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.quickWindow": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeMode": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootContext": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootObject": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuickWidgets.QQuickWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setResizeMode": ('PySide2.QtQuickWidgets.QQuickWidget.ResizeMode',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuickWidgets.QQuickWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.sizeHint": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.source": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.status": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    }) if "PySide2.QtQuickWidgets" in sys.modules else None
-# Module PySide2.QtRemoteObjects
-sig_dict.update({
-# class PySide2.QtRemoteObjects.QAbstractItemModelReplica:
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.availableRoles": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasData": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.roleNames": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.selectionModel": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-# class PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence'),
-# class PySide2.QtRemoteObjects.QRemoteObjectDynamicReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase:
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas:
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.addHostSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.disableRemoting": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.enableRemoting": [('PySide2.QtCore.QAbstractItemModel', 'str', 'typing.List', 'PySide2.QtCore.QItemSelectionModel'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.proxy": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.reverseProxy": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setName": ('str',),
-# class PySide2.QtRemoteObjects.QRemoteObjectNode:
-# class PySide2.QtRemoteObjects.QRemoteObjectNode.ErrorCode:
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireDynamic": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireModel": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.addClientSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.connectToNode": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.heartbeatInterval": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.instances": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.lastError": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.persistedStore": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registry": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registryUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setHeartbeatInterval": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setName": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setPersistedStore": ('PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.waitForRegistry": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall:
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall.Error:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.__init__": [(), ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall',)],
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.error": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.fromCompletedCall": ('typing.Any',),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.returnValue": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.waitForFinished": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.__init__": ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.waitForFinished": [(), ('int',)],
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistry:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.pushToRegistryIfNeeded": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.registerMetatypes": (),
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistryHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.__init__": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica.State:
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.__init__": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initializeNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode', 'str'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isReplicaValid": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.node": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.persistProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.propAsVariant": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.retrieveProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.send": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.sendWithReply": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setChild": ('int', 'typing.Any'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setProperties": ('typing.Sequence',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.state": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.waitForSource": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectSettingsStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence'),
-    }) if "PySide2.QtRemoteObjects" in sys.modules else None
-# Module PySide2.QtScxml
-sig_dict.update({
-# class PySide2.QtScxml.QScxmlCompiler:
-# class PySide2.QtScxml.QScxmlCompiler.Loader:
-    "PySide2.QtScxml.QScxmlCompiler.Loader.__init__": (),
-    "PySide2.QtScxml.QScxmlCompiler.Loader.load": ('str', 'str'),
-    "PySide2.QtScxml.QScxmlCompiler.__init__": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtScxml.QScxmlCompiler.compile": (),
-    "PySide2.QtScxml.QScxmlCompiler.errors": (),
-    "PySide2.QtScxml.QScxmlCompiler.fileName": (),
-    "PySide2.QtScxml.QScxmlCompiler.loader": (),
-    "PySide2.QtScxml.QScxmlCompiler.setFileName": ('str',),
-    "PySide2.QtScxml.QScxmlCompiler.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-# class PySide2.QtScxml.QScxmlCppDataModel:
-    "PySide2.QtScxml.QScxmlCppDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.inState": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlEvent": (),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlCppDataModel.setup": ('typing.Dict',),
-# class PySide2.QtScxml.QScxmlDataModel:
-# class PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody:
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.__init__": (),
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.run": (),
-    "PySide2.QtScxml.QScxmlDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlDataModel.setStateMachine": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlDataModel.setup": ('typing.Dict',),
-    "PySide2.QtScxml.QScxmlDataModel.stateMachine": (),
-# class PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List', 'typing.List', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlEcmaScriptDataModel:
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setup": ('typing.Dict',),
-# class PySide2.QtScxml.QScxmlError:
-    "PySide2.QtScxml.QScxmlError.__init__": [(), ('PySide2.QtScxml.QScxmlError',), ('str', 'int', 'int', 'str')],
-    "PySide2.QtScxml.QScxmlError.__copy__": (),
-    "PySide2.QtScxml.QScxmlError.column": (),
-    "PySide2.QtScxml.QScxmlError.description": (),
-    "PySide2.QtScxml.QScxmlError.fileName": (),
-    "PySide2.QtScxml.QScxmlError.isValid": (),
-    "PySide2.QtScxml.QScxmlError.line": (),
-    "PySide2.QtScxml.QScxmlError.toString": (),
-# class PySide2.QtScxml.QScxmlEvent:
-# class PySide2.QtScxml.QScxmlEvent.EventType:
-    "PySide2.QtScxml.QScxmlEvent.__init__": [(), ('PySide2.QtScxml.QScxmlEvent',)],
-    "PySide2.QtScxml.QScxmlEvent.clear": (),
-    "PySide2.QtScxml.QScxmlEvent.data": (),
-    "PySide2.QtScxml.QScxmlEvent.delay": (),
-    "PySide2.QtScxml.QScxmlEvent.errorMessage": (),
-    "PySide2.QtScxml.QScxmlEvent.eventType": (),
-    "PySide2.QtScxml.QScxmlEvent.invokeId": (),
-    "PySide2.QtScxml.QScxmlEvent.isErrorEvent": (),
-    "PySide2.QtScxml.QScxmlEvent.name": (),
-    "PySide2.QtScxml.QScxmlEvent.origin": (),
-    "PySide2.QtScxml.QScxmlEvent.originType": (),
-    "PySide2.QtScxml.QScxmlEvent.scxmlType": (),
-    "PySide2.QtScxml.QScxmlEvent.sendId": (),
-    "PySide2.QtScxml.QScxmlEvent.setData": ('typing.Any',),
-    "PySide2.QtScxml.QScxmlEvent.setDelay": ('int',),
-    "PySide2.QtScxml.QScxmlEvent.setErrorMessage": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setEventType": ('PySide2.QtScxml.QScxmlEvent.EventType',),
-    "PySide2.QtScxml.QScxmlEvent.setInvokeId": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setName": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOrigin": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOriginType": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setSendId": ('str',),
-# class PySide2.QtScxml.QScxmlExecutableContent:
-# class PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlInvokableService:
-    "PySide2.QtScxml.QScxmlInvokableService.__init__": ('PySide2.QtScxml.QScxmlStateMachine', 'PySide2.QtScxml.QScxmlInvokableServiceFactory'),
-    "PySide2.QtScxml.QScxmlInvokableService.id": (),
-    "PySide2.QtScxml.QScxmlInvokableService.name": (),
-    "PySide2.QtScxml.QScxmlInvokableService.parentStateMachine": (),
-    "PySide2.QtScxml.QScxmlInvokableService.postEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlInvokableService.start": (),
-# class PySide2.QtScxml.QScxmlInvokableServiceFactory:
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List', 'typing.List', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invokeInfo": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.names": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.parameters": (),
-# class PySide2.QtScxml.QScxmlNullDataModel:
-    "PySide2.QtScxml.QScxmlNullDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlNullDataModel.setup": ('typing.Dict',),
-# class PySide2.QtScxml.QScxmlStateMachine:
-    "PySide2.QtScxml.QScxmlStateMachine.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStateMachine.activeStateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.cancelDelayedEvent": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToEvent": ('str', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToState": ('str', 'PySide2.QtCore.QObject', 'bytes', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.dataModel": (),
-    "PySide2.QtScxml.QScxmlStateMachine.fromData": ('PySide2.QtCore.QIODevice', 'str'),
-    "PySide2.QtScxml.QScxmlStateMachine.fromFile": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.init": (),
-    "PySide2.QtScxml.QScxmlStateMachine.initialValues": (),
-    "PySide2.QtScxml.QScxmlStateMachine.invokedServices": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isActive": [('int',), ('str',)],
-    "PySide2.QtScxml.QScxmlStateMachine.isDispatchableTarget": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.isInitialized": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isInvoked": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isRunning": (),
-    "PySide2.QtScxml.QScxmlStateMachine.loader": (),
-    "PySide2.QtScxml.QScxmlStateMachine.name": (),
-    "PySide2.QtScxml.QScxmlStateMachine.parseErrors": (),
-    "PySide2.QtScxml.QScxmlStateMachine.sessionId": (),
-    "PySide2.QtScxml.QScxmlStateMachine.setDataModel": ('PySide2.QtScxml.QScxmlDataModel',),
-    "PySide2.QtScxml.QScxmlStateMachine.setInitialValues": ('typing.Dict',),
-    "PySide2.QtScxml.QScxmlStateMachine.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-    "PySide2.QtScxml.QScxmlStateMachine.setRunning": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.setTableData": ('PySide2.QtScxml.QScxmlTableData',),
-    "PySide2.QtScxml.QScxmlStateMachine.start": (),
-    "PySide2.QtScxml.QScxmlStateMachine.stateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.stop": (),
-    "PySide2.QtScxml.QScxmlStateMachine.submitEvent": [('PySide2.QtScxml.QScxmlEvent',), ('str',), ('str', 'typing.Any')],
-    "PySide2.QtScxml.QScxmlStateMachine.tableData": (),
-# class PySide2.QtScxml.QScxmlStaticScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List', 'typing.List', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlTableData:
-    "PySide2.QtScxml.QScxmlTableData.__init__": (),
-    "PySide2.QtScxml.QScxmlTableData.assignmentInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.dataNames": (),
-    "PySide2.QtScxml.QScxmlTableData.evaluatorInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.foreachInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.initialSetup": (),
-    "PySide2.QtScxml.QScxmlTableData.instructions": (),
-    "PySide2.QtScxml.QScxmlTableData.name": (),
-    "PySide2.QtScxml.QScxmlTableData.serviceFactory": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.stateMachineTable": (),
-    "PySide2.QtScxml.QScxmlTableData.string": ('int',),
-    }) if "PySide2.QtScxml" in sys.modules else None
-# Module PySide2.QtScript
-sig_dict.update({
-# class PySide2.QtScript.QScriptClass:
-# class PySide2.QtScript.QScriptClass.Extension:
-# class PySide2.QtScript.QScriptClass.QueryFlag:
-    "PySide2.QtScript.QScriptClass.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptClass.engine": (),
-    "PySide2.QtScript.QScriptClass.extension": ('PySide2.QtScript.QScriptClass.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptClass.name": (),
-    "PySide2.QtScript.QScriptClass.newIterator": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClass.property": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.propertyFlags": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.prototype": (),
-    "PySide2.QtScript.QScriptClass.setProperty": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptClass.supportsExtension": ('PySide2.QtScript.QScriptClass.Extension',),
-# class PySide2.QtScript.QScriptClassPropertyIterator:
-    "PySide2.QtScript.QScriptClassPropertyIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClassPropertyIterator.flags": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasNext": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.id": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.name": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.object": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.previous": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toBack": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toFront": (),
-# class PySide2.QtScript.QScriptContext:
-# class PySide2.QtScript.QScriptContext.Error:
-# class PySide2.QtScript.QScriptContext.ExecutionState:
-    "PySide2.QtScript.QScriptContext.activationObject": (),
-    "PySide2.QtScript.QScriptContext.argument": ('int',),
-    "PySide2.QtScript.QScriptContext.argumentCount": (),
-    "PySide2.QtScript.QScriptContext.argumentsObject": (),
-    "PySide2.QtScript.QScriptContext.backtrace": (),
-    "PySide2.QtScript.QScriptContext.callee": (),
-    "PySide2.QtScript.QScriptContext.engine": (),
-    "PySide2.QtScript.QScriptContext.isCalledAsConstructor": (),
-    "PySide2.QtScript.QScriptContext.parentContext": (),
-    "PySide2.QtScript.QScriptContext.popScope": (),
-    "PySide2.QtScript.QScriptContext.pushScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.returnValue": (),
-    "PySide2.QtScript.QScriptContext.scopeChain": (),
-    "PySide2.QtScript.QScriptContext.setActivationObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setReturnValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setThisObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.state": (),
-    "PySide2.QtScript.QScriptContext.thisObject": (),
-    "PySide2.QtScript.QScriptContext.throwError": [('PySide2.QtScript.QScriptContext.Error', 'str'), ('str',)],
-    "PySide2.QtScript.QScriptContext.throwValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.toString": (),
-# class PySide2.QtScript.QScriptContextInfo:
-# class PySide2.QtScript.QScriptContextInfo.FunctionType:
-    "PySide2.QtScript.QScriptContextInfo.__init__": [(), ('PySide2.QtScript.QScriptContext',), ('PySide2.QtScript.QScriptContextInfo',)],
-    "PySide2.QtScript.QScriptContextInfo.__copy__": (),
-    "PySide2.QtScript.QScriptContextInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.columnNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.fileName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionEndLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionMetaIndex": (),
-    "PySide2.QtScript.QScriptContextInfo.functionName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionParameterNames": (),
-    "PySide2.QtScript.QScriptContextInfo.functionStartLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionType": (),
-    "PySide2.QtScript.QScriptContextInfo.isNull": (),
-    "PySide2.QtScript.QScriptContextInfo.lineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.scriptId": (),
-# class PySide2.QtScript.QScriptEngine:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOption:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOptions:
-# class PySide2.QtScript.QScriptEngine.ValueOwnership:
-    "PySide2.QtScript.QScriptEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtScript.QScriptEngine.abortEvaluation": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.agent": (),
-    "PySide2.QtScript.QScriptEngine.availableExtensions": (),
-    "PySide2.QtScript.QScriptEngine.canEvaluate": ('str',),
-    "PySide2.QtScript.QScriptEngine.clearExceptions": (),
-    "PySide2.QtScript.QScriptEngine.collectGarbage": (),
-    "PySide2.QtScript.QScriptEngine.currentContext": (),
-    "PySide2.QtScript.QScriptEngine.defaultPrototype": ('int',),
-    "PySide2.QtScript.QScriptEngine.evaluate": [('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptEngine.globalObject": (),
-    "PySide2.QtScript.QScriptEngine.hasUncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.importExtension": ('str',),
-    "PySide2.QtScript.QScriptEngine.importedExtensions": (),
-    "PySide2.QtScript.QScriptEngine.installTranslatorFunctions": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.isEvaluating": (),
-    "PySide2.QtScript.QScriptEngine.newActivationObject": (),
-    "PySide2.QtScript.QScriptEngine.newArray": ('int',),
-    "PySide2.QtScript.QScriptEngine.newDate": [('PySide2.QtCore.QDateTime',), ('float',)],
-    "PySide2.QtScript.QScriptEngine.newObject": [(), ('PySide2.QtScript.QScriptClass', 'PySide2.QtScript.QScriptValue')],
-    "PySide2.QtScript.QScriptEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.newQObject": [('PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions'), ('PySide2.QtScript.QScriptValue', 'PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions')],
-    "PySide2.QtScript.QScriptEngine.newRegExp": [('PySide2.QtCore.QRegExp',), ('str', 'str')],
-    "PySide2.QtScript.QScriptEngine.newVariant": [('PySide2.QtScript.QScriptValue', 'typing.Any'), ('typing.Any',)],
-    "PySide2.QtScript.QScriptEngine.nullValue": (),
-    "PySide2.QtScript.QScriptEngine.objectById": ('int',),
-    "PySide2.QtScript.QScriptEngine.popContext": (),
-    "PySide2.QtScript.QScriptEngine.processEventsInterval": (),
-    "PySide2.QtScript.QScriptEngine.pushContext": (),
-    "PySide2.QtScript.QScriptEngine.reportAdditionalMemoryCost": ('int',),
-    "PySide2.QtScript.QScriptEngine.setAgent": ('PySide2.QtScript.QScriptEngineAgent',),
-    "PySide2.QtScript.QScriptEngine.setDefaultPrototype": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.setGlobalObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.setProcessEventsInterval": ('int',),
-    "PySide2.QtScript.QScriptEngine.toObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.toStringHandle": ('str',),
-    "PySide2.QtScript.QScriptEngine.uncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionBacktrace": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionLineNumber": (),
-    "PySide2.QtScript.QScriptEngine.undefinedValue": (),
-# class PySide2.QtScript.QScriptEngineAgent:
-# class PySide2.QtScript.QScriptEngineAgent.Extension:
-    "PySide2.QtScript.QScriptEngineAgent.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptEngineAgent.contextPop": (),
-    "PySide2.QtScript.QScriptEngineAgent.contextPush": (),
-    "PySide2.QtScript.QScriptEngineAgent.engine": (),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionCatch": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionThrow": ('int', 'PySide2.QtScript.QScriptValue', 'bool'),
-    "PySide2.QtScript.QScriptEngineAgent.extension": ('PySide2.QtScript.QScriptEngineAgent.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptEngineAgent.functionEntry": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.functionExit": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.positionChange": ('int', 'int', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptLoad": ('int', 'str', 'str', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptUnload": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.supportsExtension": ('PySide2.QtScript.QScriptEngineAgent.Extension',),
-# class PySide2.QtScript.QScriptExtensionInterface:
-    "PySide2.QtScript.QScriptExtensionInterface.__init__": (),
-    "PySide2.QtScript.QScriptExtensionInterface.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptExtensionPlugin:
-    "PySide2.QtScript.QScriptExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScript.QScriptExtensionPlugin.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-    "PySide2.QtScript.QScriptExtensionPlugin.keys": (),
-    "PySide2.QtScript.QScriptExtensionPlugin.setupPackage": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptProgram:
-    "PySide2.QtScript.QScriptProgram.__init__": [(), ('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptProgram.__copy__": (),
-    "PySide2.QtScript.QScriptProgram.fileName": (),
-    "PySide2.QtScript.QScriptProgram.firstLineNumber": (),
-    "PySide2.QtScript.QScriptProgram.isNull": (),
-    "PySide2.QtScript.QScriptProgram.sourceCode": (),
-# class PySide2.QtScript.QScriptString:
-    "PySide2.QtScript.QScriptString.__init__": [(), ('PySide2.QtScript.QScriptString',)],
-    "PySide2.QtScript.QScriptString.__copy__": (),
-    "PySide2.QtScript.QScriptString.isValid": (),
-    "PySide2.QtScript.QScriptString.toArrayIndex": (),
-    "PySide2.QtScript.QScriptString.toString": (),
-# class PySide2.QtScript.QScriptValue:
-# class PySide2.QtScript.QScriptValue.PropertyFlag:
-# class PySide2.QtScript.QScriptValue.PropertyFlags:
-# class PySide2.QtScript.QScriptValue.ResolveFlag:
-# class PySide2.QtScript.QScriptValue.ResolveFlags:
-# class PySide2.QtScript.QScriptValue.SpecialValue:
-    "PySide2.QtScript.QScriptValue.__init__": [(), ('PySide2.QtScript.QScriptEngine', 'PySide2.QtScript.QScriptValue.SpecialValue'), ('PySide2.QtScript.QScriptEngine', 'bool'), ('PySide2.QtScript.QScriptEngine', 'bytes'), ('PySide2.QtScript.QScriptEngine', 'float'), ('PySide2.QtScript.QScriptEngine', 'int'), ('PySide2.QtScript.QScriptEngine', 'str'), ('PySide2.QtScript.QScriptValue',), ('PySide2.QtScript.QScriptValue.SpecialValue',), ('bool',), ('bytes',), ('float',), ('int',), ('str',)],
-    "PySide2.QtScript.QScriptValue.__copy__": (),
-    "PySide2.QtScript.QScriptValue.__iter__": (),
-    "PySide2.QtScript.QScriptValue.__repr__": (),
-    "PySide2.QtScript.QScriptValue.call": [('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue'), ('PySide2.QtScript.QScriptValue', 'typing.Sequence')],
-    "PySide2.QtScript.QScriptValue.construct": [('PySide2.QtScript.QScriptValue',), ('typing.Sequence',)],
-    "PySide2.QtScript.QScriptValue.data": (),
-    "PySide2.QtScript.QScriptValue.engine": (),
-    "PySide2.QtScript.QScriptValue.equals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.instanceOf": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.isArray": (),
-    "PySide2.QtScript.QScriptValue.isBool": (),
-    "PySide2.QtScript.QScriptValue.isBoolean": (),
-    "PySide2.QtScript.QScriptValue.isDate": (),
-    "PySide2.QtScript.QScriptValue.isError": (),
-    "PySide2.QtScript.QScriptValue.isFunction": (),
-    "PySide2.QtScript.QScriptValue.isNull": (),
-    "PySide2.QtScript.QScriptValue.isNumber": (),
-    "PySide2.QtScript.QScriptValue.isObject": (),
-    "PySide2.QtScript.QScriptValue.isQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.isQObject": (),
-    "PySide2.QtScript.QScriptValue.isRegExp": (),
-    "PySide2.QtScript.QScriptValue.isString": (),
-    "PySide2.QtScript.QScriptValue.isUndefined": (),
-    "PySide2.QtScript.QScriptValue.isValid": (),
-    "PySide2.QtScript.QScriptValue.isVariant": (),
-    "PySide2.QtScript.QScriptValue.lessThan": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.objectId": (),
-    "PySide2.QtScript.QScriptValue.property": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('int', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.propertyFlags": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.prototype": (),
-    "PySide2.QtScript.QScriptValue.scope": (),
-    "PySide2.QtScript.QScriptValue.scriptClass": (),
-    "PySide2.QtScript.QScriptValue.setData": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setProperty": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('int', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('str', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags')],
-    "PySide2.QtScript.QScriptValue.setPrototype": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScriptClass": ('PySide2.QtScript.QScriptClass',),
-    "PySide2.QtScript.QScriptValue.strictlyEquals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.toBool": (),
-    "PySide2.QtScript.QScriptValue.toBoolean": (),
-    "PySide2.QtScript.QScriptValue.toDateTime": (),
-    "PySide2.QtScript.QScriptValue.toInt32": (),
-    "PySide2.QtScript.QScriptValue.toInteger": (),
-    "PySide2.QtScript.QScriptValue.toNumber": (),
-    "PySide2.QtScript.QScriptValue.toObject": (),
-    "PySide2.QtScript.QScriptValue.toQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.toQObject": (),
-    "PySide2.QtScript.QScriptValue.toRegExp": (),
-    "PySide2.QtScript.QScriptValue.toString": (),
-    "PySide2.QtScript.QScriptValue.toUInt16": (),
-    "PySide2.QtScript.QScriptValue.toUInt32": (),
-    "PySide2.QtScript.QScriptValue.toVariant": (),
-# class PySide2.QtScript.QScriptValueIterator:
-    "PySide2.QtScript.QScriptValueIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.__iter__": (),
-    "PySide2.QtScript.QScriptValueIterator.flags": (),
-    "PySide2.QtScript.QScriptValueIterator.hasNext": (),
-    "PySide2.QtScript.QScriptValueIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptValueIterator.name": (),
-    "PySide2.QtScript.QScriptValueIterator.previous": (),
-    "PySide2.QtScript.QScriptValueIterator.remove": (),
-    "PySide2.QtScript.QScriptValueIterator.scriptName": (),
-    "PySide2.QtScript.QScriptValueIterator.setValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.toBack": (),
-    "PySide2.QtScript.QScriptValueIterator.toFront": (),
-    "PySide2.QtScript.QScriptValueIterator.value": (),
-# class PySide2.QtScript.QScriptable:
-    "PySide2.QtScript.QScriptable.__init__": (),
-    "PySide2.QtScript.QScriptable.argument": ('int',),
-    "PySide2.QtScript.QScriptable.argumentCount": (),
-    "PySide2.QtScript.QScriptable.context": (),
-    "PySide2.QtScript.QScriptable.engine": (),
-    "PySide2.QtScript.QScriptable.thisObject": (),
-    }) if "PySide2.QtScript" in sys.modules else None
-# Module PySide2.QtScriptTools
-sig_dict.update({
-# class PySide2.QtScriptTools.QScriptEngineDebugger:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerState:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget:
-    "PySide2.QtScriptTools.QScriptEngineDebugger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.action": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.attachTo": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.autoShowStandardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardMenu": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardToolBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.setAutoShowStandardWindow": ('bool',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.standardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.state": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.widget": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget',),
-    }) if "PySide2.QtScriptTools" in sys.modules else None
-# Module PySide2.QtSensors
-sig_dict.update({
-# class PySide2.QtSensors.QAccelerometer:
-# class PySide2.QtSensors.QAccelerometer.AccelerationMode:
-    "PySide2.QtSensors.QAccelerometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometer.accelerationMode": (),
-    "PySide2.QtSensors.QAccelerometer.reading": (),
-    "PySide2.QtSensors.QAccelerometer.setAccelerationMode": ('PySide2.QtSensors.QAccelerometer.AccelerationMode',),
-# class PySide2.QtSensors.QAccelerometerFilter:
-    "PySide2.QtSensors.QAccelerometerFilter.__init__": (),
-    "PySide2.QtSensors.QAccelerometerFilter.filter": [('PySide2.QtSensors.QAccelerometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAccelerometerReading:
-    "PySide2.QtSensors.QAccelerometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAccelerometerReading.setX": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setY": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.x": (),
-    "PySide2.QtSensors.QAccelerometerReading.y": (),
-    "PySide2.QtSensors.QAccelerometerReading.z": (),
-# class PySide2.QtSensors.QAltimeter:
-    "PySide2.QtSensors.QAltimeter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeter.reading": (),
-# class PySide2.QtSensors.QAltimeterFilter:
-    "PySide2.QtSensors.QAltimeterFilter.__init__": (),
-    "PySide2.QtSensors.QAltimeterFilter.filter": [('PySide2.QtSensors.QAltimeterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAltimeterReading:
-    "PySide2.QtSensors.QAltimeterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeterReading.altitude": (),
-    "PySide2.QtSensors.QAltimeterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAltimeterReading.setAltitude": ('float',),
-# class PySide2.QtSensors.QAmbientLightFilter:
-    "PySide2.QtSensors.QAmbientLightFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientLightFilter.filter": [('PySide2.QtSensors.QAmbientLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientLightReading:
-# class PySide2.QtSensors.QAmbientLightReading.LightLevel:
-    "PySide2.QtSensors.QAmbientLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientLightReading.lightLevel": (),
-    "PySide2.QtSensors.QAmbientLightReading.setLightLevel": ('PySide2.QtSensors.QAmbientLightReading.LightLevel',),
-# class PySide2.QtSensors.QAmbientLightSensor:
-    "PySide2.QtSensors.QAmbientLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightSensor.reading": (),
-# class PySide2.QtSensors.QAmbientTemperatureFilter:
-    "PySide2.QtSensors.QAmbientTemperatureFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientTemperatureFilter.filter": [('PySide2.QtSensors.QAmbientTemperatureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientTemperatureReading:
-    "PySide2.QtSensors.QAmbientTemperatureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.temperature": (),
-# class PySide2.QtSensors.QAmbientTemperatureSensor:
-    "PySide2.QtSensors.QAmbientTemperatureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureSensor.reading": (),
-# class PySide2.QtSensors.QCompass:
-    "PySide2.QtSensors.QCompass.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompass.reading": (),
-# class PySide2.QtSensors.QCompassFilter:
-    "PySide2.QtSensors.QCompassFilter.__init__": (),
-    "PySide2.QtSensors.QCompassFilter.filter": [('PySide2.QtSensors.QCompassReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QCompassReading:
-    "PySide2.QtSensors.QCompassReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompassReading.azimuth": (),
-    "PySide2.QtSensors.QCompassReading.calibrationLevel": (),
-    "PySide2.QtSensors.QCompassReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QCompassReading.setAzimuth": ('float',),
-    "PySide2.QtSensors.QCompassReading.setCalibrationLevel": ('float',),
-# class PySide2.QtSensors.QDistanceFilter:
-    "PySide2.QtSensors.QDistanceFilter.__init__": (),
-    "PySide2.QtSensors.QDistanceFilter.filter": [('PySide2.QtSensors.QDistanceReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QDistanceReading:
-    "PySide2.QtSensors.QDistanceReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QDistanceReading.distance": (),
-    "PySide2.QtSensors.QDistanceReading.setDistance": ('float',),
-# class PySide2.QtSensors.QDistanceSensor:
-    "PySide2.QtSensors.QDistanceSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceSensor.reading": (),
-# class PySide2.QtSensors.QGyroscope:
-    "PySide2.QtSensors.QGyroscope.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscope.reading": (),
-# class PySide2.QtSensors.QGyroscopeFilter:
-    "PySide2.QtSensors.QGyroscopeFilter.__init__": (),
-    "PySide2.QtSensors.QGyroscopeFilter.filter": [('PySide2.QtSensors.QGyroscopeReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QGyroscopeReading:
-    "PySide2.QtSensors.QGyroscopeReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscopeReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QGyroscopeReading.setX": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setY": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setZ": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.x": (),
-    "PySide2.QtSensors.QGyroscopeReading.y": (),
-    "PySide2.QtSensors.QGyroscopeReading.z": (),
-# class PySide2.QtSensors.QHolsterFilter:
-    "PySide2.QtSensors.QHolsterFilter.__init__": (),
-    "PySide2.QtSensors.QHolsterFilter.filter": [('PySide2.QtSensors.QHolsterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHolsterReading:
-    "PySide2.QtSensors.QHolsterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHolsterReading.holstered": (),
-    "PySide2.QtSensors.QHolsterReading.setHolstered": ('bool',),
-# class PySide2.QtSensors.QHolsterSensor:
-    "PySide2.QtSensors.QHolsterSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterSensor.reading": (),
-# class PySide2.QtSensors.QHumidityFilter:
-    "PySide2.QtSensors.QHumidityFilter.__init__": (),
-    "PySide2.QtSensors.QHumidityFilter.filter": [('PySide2.QtSensors.QHumidityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHumidityReading:
-    "PySide2.QtSensors.QHumidityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumidityReading.absoluteHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHumidityReading.relativeHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.setAbsoluteHumidity": ('float',),
-    "PySide2.QtSensors.QHumidityReading.setRelativeHumidity": ('float',),
-# class PySide2.QtSensors.QHumiditySensor:
-    "PySide2.QtSensors.QHumiditySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumiditySensor.reading": (),
-# class PySide2.QtSensors.QIRProximityFilter:
-    "PySide2.QtSensors.QIRProximityFilter.__init__": (),
-    "PySide2.QtSensors.QIRProximityFilter.filter": [('PySide2.QtSensors.QIRProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QIRProximityReading:
-    "PySide2.QtSensors.QIRProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QIRProximityReading.reflectance": (),
-    "PySide2.QtSensors.QIRProximityReading.setReflectance": ('float',),
-# class PySide2.QtSensors.QIRProximitySensor:
-    "PySide2.QtSensors.QIRProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximitySensor.reading": (),
-# class PySide2.QtSensors.QLidFilter:
-    "PySide2.QtSensors.QLidFilter.__init__": (),
-    "PySide2.QtSensors.QLidFilter.filter": [('PySide2.QtSensors.QLidReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLidReading:
-    "PySide2.QtSensors.QLidReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidReading.backLidClosed": (),
-    "PySide2.QtSensors.QLidReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLidReading.frontLidClosed": (),
-    "PySide2.QtSensors.QLidReading.setBackLidClosed": ('bool',),
-    "PySide2.QtSensors.QLidReading.setFrontLidClosed": ('bool',),
-# class PySide2.QtSensors.QLidSensor:
-    "PySide2.QtSensors.QLidSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidSensor.reading": (),
-# class PySide2.QtSensors.QLightFilter:
-    "PySide2.QtSensors.QLightFilter.__init__": (),
-    "PySide2.QtSensors.QLightFilter.filter": [('PySide2.QtSensors.QLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLightReading:
-    "PySide2.QtSensors.QLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLightReading.lux": (),
-    "PySide2.QtSensors.QLightReading.setLux": ('float',),
-# class PySide2.QtSensors.QLightSensor:
-    "PySide2.QtSensors.QLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightSensor.fieldOfView": (),
-    "PySide2.QtSensors.QLightSensor.reading": (),
-    "PySide2.QtSensors.QLightSensor.setFieldOfView": ('float',),
-# class PySide2.QtSensors.QMagnetometer:
-    "PySide2.QtSensors.QMagnetometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometer.reading": (),
-    "PySide2.QtSensors.QMagnetometer.returnGeoValues": (),
-    "PySide2.QtSensors.QMagnetometer.setReturnGeoValues": ('bool',),
-# class PySide2.QtSensors.QMagnetometerFilter:
-    "PySide2.QtSensors.QMagnetometerFilter.__init__": (),
-    "PySide2.QtSensors.QMagnetometerFilter.filter": [('PySide2.QtSensors.QMagnetometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QMagnetometerReading:
-    "PySide2.QtSensors.QMagnetometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometerReading.calibrationLevel": (),
-    "PySide2.QtSensors.QMagnetometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QMagnetometerReading.setCalibrationLevel": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setX": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setY": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.x": (),
-    "PySide2.QtSensors.QMagnetometerReading.y": (),
-    "PySide2.QtSensors.QMagnetometerReading.z": (),
-# class PySide2.QtSensors.QOrientationFilter:
-    "PySide2.QtSensors.QOrientationFilter.__init__": (),
-    "PySide2.QtSensors.QOrientationFilter.filter": [('PySide2.QtSensors.QOrientationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QOrientationReading:
-# class PySide2.QtSensors.QOrientationReading.Orientation:
-    "PySide2.QtSensors.QOrientationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QOrientationReading.orientation": (),
-    "PySide2.QtSensors.QOrientationReading.setOrientation": ('PySide2.QtSensors.QOrientationReading.Orientation',),
-# class PySide2.QtSensors.QOrientationSensor:
-    "PySide2.QtSensors.QOrientationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationSensor.reading": (),
-# class PySide2.QtSensors.QPressureFilter:
-    "PySide2.QtSensors.QPressureFilter.__init__": (),
-    "PySide2.QtSensors.QPressureFilter.filter": [('PySide2.QtSensors.QPressureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QPressureReading:
-    "PySide2.QtSensors.QPressureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QPressureReading.pressure": (),
-    "PySide2.QtSensors.QPressureReading.setPressure": ('float',),
-    "PySide2.QtSensors.QPressureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QPressureReading.temperature": (),
-# class PySide2.QtSensors.QPressureSensor:
-    "PySide2.QtSensors.QPressureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureSensor.reading": (),
-# class PySide2.QtSensors.QProximityFilter:
-    "PySide2.QtSensors.QProximityFilter.__init__": (),
-    "PySide2.QtSensors.QProximityFilter.filter": [('PySide2.QtSensors.QProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QProximityReading:
-    "PySide2.QtSensors.QProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximityReading.close": (),
-    "PySide2.QtSensors.QProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QProximityReading.setClose": ('bool',),
-# class PySide2.QtSensors.QProximitySensor:
-    "PySide2.QtSensors.QProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximitySensor.reading": (),
-# class PySide2.QtSensors.QRotationFilter:
-    "PySide2.QtSensors.QRotationFilter.__init__": (),
-    "PySide2.QtSensors.QRotationFilter.filter": [('PySide2.QtSensors.QRotationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QRotationReading:
-    "PySide2.QtSensors.QRotationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QRotationReading.setFromEuler": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QRotationReading.x": (),
-    "PySide2.QtSensors.QRotationReading.y": (),
-    "PySide2.QtSensors.QRotationReading.z": (),
-# class PySide2.QtSensors.QRotationSensor:
-    "PySide2.QtSensors.QRotationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationSensor.hasZ": (),
-    "PySide2.QtSensors.QRotationSensor.reading": (),
-    "PySide2.QtSensors.QRotationSensor.setHasZ": ('bool',),
-# class PySide2.QtSensors.QSensor:
-# class PySide2.QtSensors.QSensor.AxesOrientationMode:
-# class PySide2.QtSensors.QSensor.Feature:
-    "PySide2.QtSensors.QSensor.__init__": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensor.addFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.availableDataRates": (),
-    "PySide2.QtSensors.QSensor.axesOrientationMode": (),
-    "PySide2.QtSensors.QSensor.backend": (),
-    "PySide2.QtSensors.QSensor.bufferSize": (),
-    "PySide2.QtSensors.QSensor.connectToBackend": (),
-    "PySide2.QtSensors.QSensor.currentOrientation": (),
-    "PySide2.QtSensors.QSensor.dataRate": (),
-    "PySide2.QtSensors.QSensor.defaultSensorForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.description": (),
-    "PySide2.QtSensors.QSensor.efficientBufferSize": (),
-    "PySide2.QtSensors.QSensor.error": (),
-    "PySide2.QtSensors.QSensor.filters": (),
-    "PySide2.QtSensors.QSensor.identifier": (),
-    "PySide2.QtSensors.QSensor.isActive": (),
-    "PySide2.QtSensors.QSensor.isAlwaysOn": (),
-    "PySide2.QtSensors.QSensor.isBusy": (),
-    "PySide2.QtSensors.QSensor.isConnectedToBackend": (),
-    "PySide2.QtSensors.QSensor.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensor.maxBufferSize": (),
-    "PySide2.QtSensors.QSensor.outputRange": (),
-    "PySide2.QtSensors.QSensor.outputRanges": (),
-    "PySide2.QtSensors.QSensor.reading": (),
-    "PySide2.QtSensors.QSensor.removeFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.sensorTypes": (),
-    "PySide2.QtSensors.QSensor.sensorsForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setActive": ('bool',),
-    "PySide2.QtSensors.QSensor.setAlwaysOn": ('bool',),
-    "PySide2.QtSensors.QSensor.setAxesOrientationMode": ('PySide2.QtSensors.QSensor.AxesOrientationMode',),
-    "PySide2.QtSensors.QSensor.setBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setCurrentOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.setDataRate": ('int',),
-    "PySide2.QtSensors.QSensor.setEfficientBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setIdentifier": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setMaxBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setOutputRange": ('int',),
-    "PySide2.QtSensors.QSensor.setSkipDuplicates": ('bool',),
-    "PySide2.QtSensors.QSensor.setUserOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.skipDuplicates": (),
-    "PySide2.QtSensors.QSensor.start": (),
-    "PySide2.QtSensors.QSensor.stop": (),
-    "PySide2.QtSensors.QSensor.type": (),
-    "PySide2.QtSensors.QSensor.userOrientation": (),
-# class PySide2.QtSensors.QSensorBackend:
-    "PySide2.QtSensors.QSensorBackend.__init__": ('PySide2.QtSensors.QSensor', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensorBackend.addDataRate": ('float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.addOutputRange": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensorBackend.newReadingAvailable": (),
-    "PySide2.QtSensors.QSensorBackend.reading": (),
-    "PySide2.QtSensors.QSensorBackend.sensor": (),
-    "PySide2.QtSensors.QSensorBackend.sensorBusy": (),
-    "PySide2.QtSensors.QSensorBackend.sensorError": ('int',),
-    "PySide2.QtSensors.QSensorBackend.sensorStopped": (),
-    "PySide2.QtSensors.QSensorBackend.setDataRates": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorBackend.setDescription": ('str',),
-    "PySide2.QtSensors.QSensorBackend.start": (),
-    "PySide2.QtSensors.QSensorBackend.stop": (),
-# class PySide2.QtSensors.QSensorBackendFactory:
-    "PySide2.QtSensors.QSensorBackendFactory.__init__": (),
-    "PySide2.QtSensors.QSensorBackendFactory.createBackend": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorChangesInterface:
-    "PySide2.QtSensors.QSensorChangesInterface.__init__": (),
-    "PySide2.QtSensors.QSensorChangesInterface.sensorsChanged": (),
-# class PySide2.QtSensors.QSensorFilter:
-    "PySide2.QtSensors.QSensorFilter.__init__": (),
-    "PySide2.QtSensors.QSensorFilter.filter": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorFilter.setSensor": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorGestureManager:
-    "PySide2.QtSensors.QSensorGestureManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureManager.gestureIds": (),
-    "PySide2.QtSensors.QSensorGestureManager.recognizerSignals": ('str',),
-    "PySide2.QtSensors.QSensorGestureManager.registerSensorGestureRecognizer": ('PySide2.QtSensors.QSensorGestureRecognizer',),
-    "PySide2.QtSensors.QSensorGestureManager.sensorGestureRecognizer": ('str',),
-# class PySide2.QtSensors.QSensorGesturePluginInterface:
-    "PySide2.QtSensors.QSensorGesturePluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.createRecognizers": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.name": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.supportedIds": (),
-# class PySide2.QtSensors.QSensorGestureRecognizer:
-    "PySide2.QtSensors.QSensorGestureRecognizer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureRecognizer.create": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.createBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.gestureSignals": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.id": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.isActive": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.start": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.startBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stop": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stopBackend": (),
-# class PySide2.QtSensors.QSensorManager:
-    "PySide2.QtSensors.QSensorManager.__init__": (),
-    "PySide2.QtSensors.QSensorManager.createBackend": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorManager.isBackendRegistered": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.registerBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtSensors.QSensorBackendFactory'),
-    "PySide2.QtSensors.QSensorManager.setDefaultBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.unregisterBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtSensors.QSensorPluginInterface:
-    "PySide2.QtSensors.QSensorPluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorPluginInterface.registerSensors": (),
-# class PySide2.QtSensors.QSensorReading:
-    "PySide2.QtSensors.QSensorReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorReading.setTimestamp": ('int',),
-    "PySide2.QtSensors.QSensorReading.timestamp": (),
-    "PySide2.QtSensors.QSensorReading.value": ('int',),
-    "PySide2.QtSensors.QSensorReading.valueCount": (),
-# class PySide2.QtSensors.QTapFilter:
-    "PySide2.QtSensors.QTapFilter.__init__": (),
-    "PySide2.QtSensors.QTapFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTapReading',)],
-# class PySide2.QtSensors.QTapReading:
-# class PySide2.QtSensors.QTapReading.TapDirection:
-    "PySide2.QtSensors.QTapReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTapReading.isDoubleTap": (),
-    "PySide2.QtSensors.QTapReading.setDoubleTap": ('bool',),
-    "PySide2.QtSensors.QTapReading.setTapDirection": ('PySide2.QtSensors.QTapReading.TapDirection',),
-    "PySide2.QtSensors.QTapReading.tapDirection": (),
-# class PySide2.QtSensors.QTapSensor:
-    "PySide2.QtSensors.QTapSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapSensor.reading": (),
-    "PySide2.QtSensors.QTapSensor.returnDoubleTapEvents": (),
-    "PySide2.QtSensors.QTapSensor.setReturnDoubleTapEvents": ('bool',),
-# class PySide2.QtSensors.QTiltFilter:
-    "PySide2.QtSensors.QTiltFilter.__init__": (),
-    "PySide2.QtSensors.QTiltFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTiltReading',)],
-# class PySide2.QtSensors.QTiltReading:
-    "PySide2.QtSensors.QTiltReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTiltReading.setXRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.setYRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.xRotation": (),
-    "PySide2.QtSensors.QTiltReading.yRotation": (),
-# class PySide2.QtSensors.QTiltSensor:
-    "PySide2.QtSensors.QTiltSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltSensor.calibrate": (),
-    "PySide2.QtSensors.QTiltSensor.reading": (),
-# class PySide2.QtSensors.qoutputrange:
-    "PySide2.QtSensors.qoutputrange.__init__": [(), ('PySide2.QtSensors.qoutputrange',)],
-    "PySide2.QtSensors.qoutputrange.__copy__": (),
-    }) if "PySide2.QtSensors" in sys.modules else None
-# Module PySide2.QtTextToSpeech
-sig_dict.update({
-# class PySide2.QtTextToSpeech.QTextToSpeech:
-# class PySide2.QtTextToSpeech.QTextToSpeech.State:
-    "PySide2.QtTextToSpeech.QTextToSpeech.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableEngines": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.volume": (),
-# class PySide2.QtTextToSpeech.QTextToSpeechEngine:
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.createVoice": ('str', 'PySide2.QtTextToSpeech.QVoice.Gender', 'PySide2.QtTextToSpeech.QVoice.Age', 'typing.Any'),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voiceData": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.volume": (),
-# class PySide2.QtTextToSpeech.QVoice:
-# class PySide2.QtTextToSpeech.QVoice.Age:
-# class PySide2.QtTextToSpeech.QVoice.Gender:
-    "PySide2.QtTextToSpeech.QVoice.__init__": [(), ('PySide2.QtTextToSpeech.QVoice',)],
-    "PySide2.QtTextToSpeech.QVoice.__copy__": (),
-    "PySide2.QtTextToSpeech.QVoice.age": (),
-    "PySide2.QtTextToSpeech.QVoice.ageName": ('PySide2.QtTextToSpeech.QVoice.Age',),
-    "PySide2.QtTextToSpeech.QVoice.gender": (),
-    "PySide2.QtTextToSpeech.QVoice.genderName": ('PySide2.QtTextToSpeech.QVoice.Gender',),
-    "PySide2.QtTextToSpeech.QVoice.name": (),
-    }) if "PySide2.QtTextToSpeech" in sys.modules else None
-# Module PySide2.QtCharts
-sig_dict.update({
-# class PySide2.QtCharts.QtCharts:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis.AxisType:
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.alignment": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isMinorGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isReverse": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isTitleVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsEditable": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePenColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.orientation": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsAngle": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsEditable": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePenColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMax": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMin": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setRange": ('typing.Any', 'typing.Any'),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setReverse": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleText": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBorderColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesPen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleText": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition:
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.append": [('PySide2.QtCharts.QtCharts.QBarSet',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barSets": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barWidth": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBarSet'),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.isLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPrecision": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.remove": ('PySide2.QtCharts.QtCharts.QBarSet',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setBarWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPrecision": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.take": ('PySide2.QtCharts.QtCharts.QBarSet',),
-# class PySide2.QtCharts.QtCharts.QAbstractSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractSeries.SeriesType:
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachedAxes": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.chart": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.detachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.name": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.opacity": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setName": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setOpacity": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setUseOpenGL": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.useOpenGL": (),
-# class PySide2.QtCharts.QtCharts.QAreaLegendMarker:
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAreaSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QAreaSeries:
-    "PySide2.QtCharts.QtCharts.QAreaSeries.__init__": [('PySide2.QtCharts.QtCharts.QLineSeries', 'PySide2.QtCharts.QtCharts.QLineSeries'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCharts.QtCharts.QAreaSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.lowerSeries": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setLowerSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setUpperSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.upperSeries": (),
-# class PySide2.QtCharts.QtCharts.QBarCategoryAxis:
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.append": [('str',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.categories": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.clear": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.insert": ('int', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.replace": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setCategories": ('typing.Sequence',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMax": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMin": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setRange": [('str', 'str'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QBarLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries', 'PySide2.QtCharts.QtCharts.QBarSet', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.barset": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.firstBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.lastBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirstBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setLastBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QBarSeries:
-    "PySide2.QtCharts.QtCharts.QBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBarSet:
-    "PySide2.QtCharts.QtCharts.QBarSet.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBarSet.append": [('float',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QBarSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarSet.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.color": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.insert": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.remove": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QBarSet.replace": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBarSet.sum": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.firstBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.lastBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirstBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setLastBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QBoxPlotSeries:
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.append": [('PySide2.QtCharts.QtCharts.QBoxSet',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxSets": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxWidth": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBoxSet'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.remove": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.take": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxSet:
-# class PySide2.QtCharts.QtCharts.QBoxSet.ValuePositions:
-    "PySide2.QtCharts.QtCharts.QBoxSet.__init__": [('float', 'float', 'float', 'float', 'float', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QBoxSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.append": [('float',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QBoxSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setValue": ('int', 'float'),
-# class PySide2.QtCharts.QtCharts.QCandlestickLegendMarker:
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QCandlestickSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.firstSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.lastSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setClose": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setFirstSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setHigh": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLastSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLow": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setOpen": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QCandlestickSeries',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setTimestamp": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSeries:
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.append": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.decreasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.increasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QCandlestickSet'),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.maximumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.minimumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.remove": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setDecreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setIncreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMaximumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMinimumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.sets": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.take": ('PySide2.QtCharts.QtCharts.QCandlestickSet',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSet:
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.__init__": [('float', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setClose": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setHigh": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setLow": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setOpen": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setTimestamp": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCategoryAxis:
-# class PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition:
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.append": ('str', 'float'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.categoriesLabels": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.endValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.replaceLabel": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setStartValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.startValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QChart:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOption:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOptions:
-# class PySide2.QtCharts.QtCharts.QChart.ChartTheme:
-# class PySide2.QtCharts.QtCharts.QChart.ChartType:
-    "PySide2.QtCharts.QtCharts.QChart.__init__": [('PySide2.QtCharts.QtCharts.QChart.ChartType', 'PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtCharts.QtCharts.QChart.addAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtCharts.QtCharts.QChart.addSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.animationDuration": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationEasingCurve": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationOptions": (),
-    "PySide2.QtCharts.QtCharts.QChart.axes": ('PySide2.QtCore.Qt.Orientations', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.axisX": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.axisY": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundRoundness": (),
-    "PySide2.QtCharts.QtCharts.QChart.chartType": (),
-    "PySide2.QtCharts.QtCharts.QChart.createDefaultAxes": (),
-    "PySide2.QtCharts.QtCharts.QChart.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isDropShadowEnabled": (),
-    "PySide2.QtCharts.QtCharts.QChart.isPlotAreaBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isZoomed": (),
-    "PySide2.QtCharts.QtCharts.QChart.legend": (),
-    "PySide2.QtCharts.QtCharts.QChart.locale": (),
-    "PySide2.QtCharts.QtCharts.QChart.localizeNumbers": (),
-    "PySide2.QtCharts.QtCharts.QChart.mapToPosition": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.mapToValue": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.margins": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotArea": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAllSeries": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QChart.removeSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.scroll": ('float', 'float'),
-    "PySide2.QtCharts.QtCharts.QChart.series": (),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationDuration": ('int',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationOptions": ('PySide2.QtCharts.QtCharts.QChart.AnimationOptions',),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisX": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisY": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundRoundness": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setDropShadowEnabled": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocalizeNumbers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setMargins": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotArea": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setTheme": ('PySide2.QtCharts.QtCharts.QChart.ChartTheme',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitle": ('str',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QChart.theme": (),
-    "PySide2.QtCharts.QtCharts.QChart.title": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoom": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.zoomIn": [(), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtCharts.QtCharts.QChart.zoomOut": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoomReset": (),
-# class PySide2.QtCharts.QtCharts.QChartView:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBand:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBands:
-    "PySide2.QtCharts.QtCharts.QChartView.__init__": [('PySide2.QtCharts.QtCharts.QChart', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtCharts.QtCharts.QChartView.chart": (),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.rubberBand": (),
-    "PySide2.QtCharts.QtCharts.QChartView.setChart": ('PySide2.QtCharts.QtCharts.QChart',),
-    "PySide2.QtCharts.QtCharts.QChartView.setRubberBand": ('PySide2.QtCharts.QtCharts.QChartView.RubberBands',),
-# class PySide2.QtCharts.QtCharts.QDateTimeAxis:
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.format": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMax": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMin": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setRange": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QHBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.lastBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setLastBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.lastBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setLastBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QHCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.closeColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.firstSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.highColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lastSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lowColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.openColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setCloseColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setFirstSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setHighColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLastSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLowColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setOpenColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setTimestampColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.timestampColumn": (),
-# class PySide2.QtCharts.QtCharts.QHPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.labelsRow": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setLabelsRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setValuesRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.valuesRow": (),
-# class PySide2.QtCharts.QtCharts.QHXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setXRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setYRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.xRow": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.yRow": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLegend:
-# class PySide2.QtCharts.QtCharts.QLegend.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QLegend.alignment": (),
-    "PySide2.QtCharts.QtCharts.QLegend.attachToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.color": (),
-    "PySide2.QtCharts.QtCharts.QLegend.detachFromChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.font": (),
-    "PySide2.QtCharts.QtCharts.QLegend.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.isAttachedToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markers": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QLegend.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtCharts.QtCharts.QLegend.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegend.reverseMarkers": (),
-    "PySide2.QtCharts.QtCharts.QLegend.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setMarkerShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegend.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegend.setReverseMarkers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setShowToolTips": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.showToolTips": (),
-# class PySide2.QtCharts.QtCharts.QLegendMarker:
-# class PySide2.QtCharts.QtCharts.QLegendMarker.LegendMarkerType:
-    "PySide2.QtCharts.QtCharts.QLegendMarker.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.font": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.label": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.shape": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QLineSeries:
-    "PySide2.QtCharts.QtCharts.QLineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLogValueAxis:
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.base": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setBase": ('float',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QPieLegendMarker:
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QPieSeries', 'PySide2.QtCharts.QtCharts.QPieSlice', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.slice": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.labelsSection": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setLabelsSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setValuesSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.valuesSection": (),
-# class PySide2.QtCharts.QtCharts.QPieSeries:
-    "PySide2.QtCharts.QtCharts.QPieSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.__lshift__": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.append": [('PySide2.QtCharts.QtCharts.QPieSlice',), ('str', 'float'), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QPieSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.holeSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.horizontalPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QPieSlice'),
-    "PySide2.QtCharts.QtCharts.QPieSeries.isEmpty": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieEndAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieStartAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.remove": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHoleSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHorizontalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieEndAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieStartAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setVerticalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.slices": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.sum": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.take": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.verticalPosition": (),
-# class PySide2.QtCharts.QtCharts.QPieSlice:
-# class PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition:
-    "PySide2.QtCharts.QtCharts.QPieSlice.__init__": [('PySide2.QtCore.QObject',), ('str', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QPieSlice.angleSpan": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderWidth": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.brush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.color": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.explodeDistanceFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isExploded": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isLabelVisible": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.label": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelArmLengthFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.pen": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.percentage": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.series": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderWidth": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExplodeDistanceFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExploded": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelArmLengthFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.startAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.value": (),
-# class PySide2.QtCharts.QtCharts.QPolarChart:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientations:
-    "PySide2.QtCharts.QtCharts.QPolarChart.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtCharts.QtCharts.QPolarChart.addAxis": [('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation'), ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtCharts.QtCharts.QPolarChart.axisPolarOrientation": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-# class PySide2.QtCharts.QtCharts.QScatterSeries:
-# class PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QScatterSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerSize": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerShape": ('PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QSplineSeries:
-    "PySide2.QtCharts.QtCharts.QSplineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QSplineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QVBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.lastBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setLastBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.lastBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setLastBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QVCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.closeRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.firstSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.highRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lastSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lowRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.openRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setCloseRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setFirstSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setHighRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLastSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLowRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setOpenRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setTimestampRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.timestampRow": (),
-# class PySide2.QtCharts.QtCharts.QVPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.labelsColumn": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setLabelsColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setValuesColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.valuesColumn": (),
-# class PySide2.QtCharts.QtCharts.QVXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setXColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setYColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.xColumn": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.yColumn": (),
-# class PySide2.QtCharts.QtCharts.QValueAxis:
-    "PySide2.QtCharts.QtCharts.QValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.applyNiceNumbers": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickAnchor": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickInterval": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickAnchor": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickInterval": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QXYLegendMarker:
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QXYSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setXSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setYSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.xSection": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.ySection": (),
-# class PySide2.QtCharts.QtCharts.QXYSeries:
-    "PySide2.QtCharts.QtCharts.QXYSeries.__lshift__": [('PySide2.QtCore.QPointF',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.append": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.insert": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.points": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVector": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.remove": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('int',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.removePoints": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.replace": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'float', 'float'), ('typing.List',), ('typing.Sequence',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointsVisible": ('bool',),
-    }) if "PySide2.QtCharts" in sys.modules else None
-# Module PySide2.QtSvg
-sig_dict.update({
-# class PySide2.QtSvg.QGraphicsSvgItem:
-    "PySide2.QtSvg.QGraphicsSvgItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtSvg.QGraphicsSvgItem.boundingRect": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.elementId": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.isCachingEnabled": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.maximumCacheSize": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtSvg.QGraphicsSvgItem.renderer": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.setCachingEnabled": ('bool',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setElementId": ('str',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setMaximumCacheSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setSharedRenderer": ('PySide2.QtSvg.QSvgRenderer',),
-    "PySide2.QtSvg.QGraphicsSvgItem.type": (),
-# class PySide2.QtSvg.QSvgGenerator:
-    "PySide2.QtSvg.QSvgGenerator.__init__": (),
-    "PySide2.QtSvg.QSvgGenerator.description": (),
-    "PySide2.QtSvg.QSvgGenerator.fileName": (),
-    "PySide2.QtSvg.QSvgGenerator.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtSvg.QSvgGenerator.outputDevice": (),
-    "PySide2.QtSvg.QSvgGenerator.paintEngine": (),
-    "PySide2.QtSvg.QSvgGenerator.resolution": (),
-    "PySide2.QtSvg.QSvgGenerator.setDescription": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setFileName": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setOutputDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtSvg.QSvgGenerator.setResolution": ('int',),
-    "PySide2.QtSvg.QSvgGenerator.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QSvgGenerator.setTitle": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgGenerator.size": (),
-    "PySide2.QtSvg.QSvgGenerator.title": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBox": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBoxF": (),
-# class PySide2.QtSvg.QSvgRenderer:
-    "PySide2.QtSvg.QSvgRenderer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QXmlStreamReader', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtSvg.QSvgRenderer.animated": (),
-    "PySide2.QtSvg.QSvgRenderer.animationDuration": (),
-    "PySide2.QtSvg.QSvgRenderer.boundsOnElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.currentFrame": (),
-    "PySide2.QtSvg.QSvgRenderer.defaultSize": (),
-    "PySide2.QtSvg.QSvgRenderer.elementExists": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.framesPerSecond": (),
-    "PySide2.QtSvg.QSvgRenderer.isValid": (),
-    "PySide2.QtSvg.QSvgRenderer.load": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QXmlStreamReader',), ('str',)],
-    "PySide2.QtSvg.QSvgRenderer.matrixForElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.render": [('PySide2.QtGui.QPainter',), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'), ('PySide2.QtGui.QPainter', 'str', 'PySide2.QtCore.QRectF')],
-    "PySide2.QtSvg.QSvgRenderer.setCurrentFrame": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setFramesPerSecond": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgRenderer.viewBox": (),
-    "PySide2.QtSvg.QSvgRenderer.viewBoxF": (),
-# class PySide2.QtSvg.QSvgWidget:
-    "PySide2.QtSvg.QSvgWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtSvg.QSvgWidget.load": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtSvg.QSvgWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtSvg.QSvgWidget.renderer": (),
-    "PySide2.QtSvg.QSvgWidget.sizeHint": (),
-    }) if "PySide2.QtSvg" in sys.modules else None
-# Module PySide2.QtDataVisualization
-sig_dict.update({
-# class PySide2.QtDataVisualization.QtDataVisualization:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DBars:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barSpacing": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barThickness": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.columnAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.floorLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.insertSeries": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isBarSpacingRelative": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isMultiSeriesUniform": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.primarySeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.rowAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacing": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacingRelative": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarThickness": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setColumnAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setFloorLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setMultiSeriesUniform": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setPrimarySeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setRowAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setValueAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.valueAxis": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.cameraPreset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.maxZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.minZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPosition": ('float', 'float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPreset": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMaxZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMinZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setTarget": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapXRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapYRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setXRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setYRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.target": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapXRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapYRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.xRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.yRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.zoomLevel": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isRotationEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isSelectionEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomAtTargetEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setRotationEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setSelectionEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomAtTargetEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DLight:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.isAutoPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.setAutoPosition": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DObject:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.isDirty": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.parentScene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setPosition": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScene:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeLight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.devicePixelRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.graphPositionQuery": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.invalidSelectionPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInPrimarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInSecondarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSecondarySubviewOnTop": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSlicingActive": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.primarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.secondarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.selectionQueryPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveCamera": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveLight": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DLight',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setDevicePixelRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setGraphPositionQuery": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setPrimarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubviewOnTop": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSelectionQueryPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSlicingActive": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.viewport": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.flipHorizontalGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setFlipHorizontalGrid": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ambientLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseColors": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseGradients": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.gridLineColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.highlightLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isGridEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelBackgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelTextColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setAmbientLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseColors": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseGradients": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setHighlightLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setType": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setWindowColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.windowColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisOrientation:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isAutoAdjustRange": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleFixed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labelAutoRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.max": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.min": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.orientation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setAutoAdjustRange": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabelAutoRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabels": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMax": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setRange": ('float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitle": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleFixed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.title": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ElementType:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHint:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeInputHandler": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeTheme": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.aspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.clearSelection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.currentFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.customItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.hasContext": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.horizontalAspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.inputHandlers": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isOrthoProjection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isPolar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isReflection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.margin": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.measureFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.optimizationHints": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.queriedGraphPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.radialLabelOffset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.reflectivity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItemAt": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.renderToImage": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItemIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedElement": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedLabelIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectionMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setHorizontalAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMargin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMeasureFps": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOptimizationHints": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOrthoProjection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setPolar": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setRadialLabelOffset": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflectivity": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setSelectionMode": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setShadowQuality": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowQuality": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowsSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.themes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputView": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.prevDistance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.previousInputPos": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputView": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPrevDistance": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPreviousInputPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setScene": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DScene',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.SeriesType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isItemLabelVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isMeshSmooth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.mesh": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.meshRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.name": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMesh": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshSmooth": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setName": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setUserDefinedMesh": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.userDefinedMesh": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.DataType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.meshAngle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.selectedBar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setMeshAngle": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setSelectedBar": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem',), ('float',), ('float', 'float')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.value": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRow": [('typing.List',), ('typing.List', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRows": [('typing.List',), ('typing.List', 'typing.Sequence')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.columnLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRow": [('int', 'typing.List'), ('int', 'typing.List', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRows": [('int', 'typing.List'), ('int', 'typing.List', 'typing.Sequence')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.removeRows": ('int', 'int', 'bool'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.resetArray": [(), ('typing.List',), ('typing.List', 'typing.Sequence', 'typing.Sequence')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setColumnLabels": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRow": [('int', 'typing.List'), ('int', 'typing.List', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRowLabels": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRows": [('int', 'typing.List'), ('int', 'typing.List', 'typing.Sequence')],
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.setLabels": ('typing.Sequence',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isPositionAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isScalingAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isShadowCasting": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.meshFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.scaling": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setMeshFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPositionAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotationAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScaling": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScalingAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setShadowCasting": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isFacingCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFacingCamera": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setText": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.text": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.textColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'int', 'int', 'int', 'typing.List', 'PySide2.QtGui.QImage.Format', 'typing.List', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.alphaMultiplier": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.colorTable": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.createTextureData": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSliceFrames": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSlices": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.preserveOpacity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.renderSlice": ('PySide2.QtCore.Qt.Axis', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setAlphaMultiplier": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setColorTable": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSliceFrames": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSlices": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setPreserveOpacity": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameGaps": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameThicknesses": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameWidths": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexX": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexY": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexZ": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndices": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSubTextureData": [('PySide2.QtCore.Qt.Axis', 'int', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.Qt.Axis', 'int', 'bytes')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureData": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDepth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDimensions": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureHeight": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureWidth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setUseHighDefShader": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameGaps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameThicknesses": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameWidths": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDataWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDepth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureHeight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.useHighDefShader": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QImage', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMap": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMapFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMapFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setValueRanges": ('float', 'float', 'float', 'float'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.remap": ('str', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnCategories": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowCategories": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.remap": ('str', 'str', 'str', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.remap": ('str', 'str', 'str', 'str', 'str', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnCategories": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowCategories": ('typing.Sequence',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.autoSubGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.base": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setAutoSubGrid": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setBase": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setShowEdgeLabels": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.showEdgeLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.valueAt": ('float',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.invalidSelectionIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.itemSize": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.selectedItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setItemSize": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setSelectedItem": ('int',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItem": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItems": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItems": ('int', 'typing.List'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.removeItems": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.resetArray": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItems": ('int', 'typing.List'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.drawMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.selectedPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDrawMode": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setFlatShadingEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setSelectedPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTexture": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.texture": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRow": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRows": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.columnCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRow": ('int', 'typing.List'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRows": ('int', 'typing.List'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.removeRows": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.resetArray": ('typing.List',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRow": ('int', 'typing.List'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRows": ('int', 'typing.List'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.formatter": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.labelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.reversed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.segmentCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setFormatter": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setReversed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSubSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.subSegmentCount": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowNegatives": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowZero": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.axis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.gridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelStrings": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.markDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowNegatives": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowZero": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.stringForValue": ('float', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.subGridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.valueAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.qDefaultSurfaceFormat": ('bool',),
-    }) if "PySide2.QtDataVisualization" in sys.modules else None
-# Module PySide2.QtUiTools
-sig_dict.update({
-# class PySide2.QtUiTools.QUiLoader:
-    "PySide2.QtUiTools.QUiLoader.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtUiTools.QUiLoader.addPluginPath": ('str',),
-    "PySide2.QtUiTools.QUiLoader.availableLayouts": (),
-    "PySide2.QtUiTools.QUiLoader.availableWidgets": (),
-    "PySide2.QtUiTools.QUiLoader.clearPluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.createAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createActionGroup": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createLayout": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createWidget": ('str', 'PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtUiTools.QUiLoader.errorString": (),
-    "PySide2.QtUiTools.QUiLoader.isLanguageChangeEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.isTranslationEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.load": [('PySide2.QtCore.QIODevice', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtUiTools.QUiLoader.pluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.registerCustomWidget": ('object',),
-    "PySide2.QtUiTools.QUiLoader.setLanguageChangeEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setTranslationEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setWorkingDirectory": ('PySide2.QtCore.QDir',),
-    "PySide2.QtUiTools.QUiLoader.workingDirectory": (),
-    }) if "PySide2.QtUiTools" in sys.modules else None
-# Module PySide2.QtAxContainer
-sig_dict.update({
-# class PySide2.QtAxContainer.QAxBase:
-    "PySide2.QtAxContainer.QAxBase.__init__": (),
-    "PySide2.QtAxContainer.QAxBase.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtAxContainer.QAxBase.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtAxContainer.QAxBase.argumentsToList": ('typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any'),
-    "PySide2.QtAxContainer.QAxBase.asVariant": (),
-    "PySide2.QtAxContainer.QAxBase.classContext": (),
-    "PySide2.QtAxContainer.QAxBase.className": (),
-    "PySide2.QtAxContainer.QAxBase.clear": (),
-    "PySide2.QtAxContainer.QAxBase.control": (),
-    "PySide2.QtAxContainer.QAxBase.disableClassInfo": (),
-    "PySide2.QtAxContainer.QAxBase.disableEventSink": (),
-    "PySide2.QtAxContainer.QAxBase.disableMetaObject": (),
-    "PySide2.QtAxContainer.QAxBase.dynamicCall": [('bytes', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any'), ('bytes', 'typing.Sequence'), ('bytes', 'typing.Sequence', 'int')],
-    "PySide2.QtAxContainer.QAxBase.fallbackMetaObject": (),
-    "PySide2.QtAxContainer.QAxBase.generateDocumentation": (),
-    "PySide2.QtAxContainer.QAxBase.indexOfVerb": ('str',),
-    "PySide2.QtAxContainer.QAxBase.initializeFrom": ('PySide2.QtAxContainer.QAxBase',),
-    "PySide2.QtAxContainer.QAxBase.internalRelease": (),
-    "PySide2.QtAxContainer.QAxBase.isNull": (),
-    "PySide2.QtAxContainer.QAxBase.propertyBag": (),
-    "PySide2.QtAxContainer.QAxBase.propertyWritable": ('bytes',),
-    "PySide2.QtAxContainer.QAxBase.qObject": (),
-    "PySide2.QtAxContainer.QAxBase.querySubObject": [('bytes', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any'), ('bytes', 'typing.Sequence')],
-    "PySide2.QtAxContainer.QAxBase.setClassContext": ('int',),
-    "PySide2.QtAxContainer.QAxBase.setControl": ('str',),
-    "PySide2.QtAxContainer.QAxBase.setPropertyBag": ('typing.Dict',),
-    "PySide2.QtAxContainer.QAxBase.setPropertyWritable": ('bytes', 'bool'),
-    "PySide2.QtAxContainer.QAxBase.verbs": (),
-# class PySide2.QtAxContainer.QAxObject:
-    "PySide2.QtAxContainer.QAxObject.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtAxContainer.QAxObject.className": (),
-    "PySide2.QtAxContainer.QAxObject.doVerb": ('str',),
-    "PySide2.QtAxContainer.QAxObject.fallbackMetaObject": (),
-    "PySide2.QtAxContainer.QAxObject.qObject": (),
-# class PySide2.QtAxContainer.QAxScript:
-# class PySide2.QtAxContainer.QAxScript.FunctionFlags:
-    "PySide2.QtAxContainer.QAxScript.__init__": ('str', 'PySide2.QtAxContainer.QAxScriptManager'),
-    "PySide2.QtAxContainer.QAxScript.call": [('str', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any'), ('str', 'typing.Sequence')],
-    "PySide2.QtAxContainer.QAxScript.functions": ('PySide2.QtAxContainer.QAxScript.FunctionFlags',),
-    "PySide2.QtAxContainer.QAxScript.load": ('str', 'str'),
-    "PySide2.QtAxContainer.QAxScript.scriptCode": (),
-    "PySide2.QtAxContainer.QAxScript.scriptEngine": (),
-    "PySide2.QtAxContainer.QAxScript.scriptName": (),
-# class PySide2.QtAxContainer.QAxScriptEngine:
-    "PySide2.QtAxContainer.QAxScriptEngine.__init__": ('str', 'PySide2.QtAxContainer.QAxScript'),
-    "PySide2.QtAxContainer.QAxScriptEngine.addItem": ('str',),
-    "PySide2.QtAxContainer.QAxScriptEngine.hasIntrospection": (),
-    "PySide2.QtAxContainer.QAxScriptEngine.isValid": (),
-    "PySide2.QtAxContainer.QAxScriptEngine.scriptLanguage": (),
-# class PySide2.QtAxContainer.QAxScriptManager:
-    "PySide2.QtAxContainer.QAxScriptManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtAxContainer.QAxScriptManager.addObject": ('PySide2.QtAxContainer.QAxBase',),
-    "PySide2.QtAxContainer.QAxScriptManager.call": [('str', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any', 'typing.Any'), ('str', 'typing.Sequence')],
-    "PySide2.QtAxContainer.QAxScriptManager.functions": ('PySide2.QtAxContainer.QAxScript.FunctionFlags',),
-    "PySide2.QtAxContainer.QAxScriptManager.load": [('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtAxContainer.QAxScriptManager.registerEngine": ('str', 'str', 'str'),
-    "PySide2.QtAxContainer.QAxScriptManager.script": ('str',),
-    "PySide2.QtAxContainer.QAxScriptManager.scriptFileFilter": (),
-    "PySide2.QtAxContainer.QAxScriptManager.scriptNames": (),
-# class PySide2.QtAxContainer.QAxSelect:
-    "PySide2.QtAxContainer.QAxSelect.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtAxContainer.QAxSelect.clsid": (),
-# class PySide2.QtAxContainer.QAxWidget:
-    "PySide2.QtAxContainer.QAxWidget.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtAxContainer.QAxWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtAxContainer.QAxWidget.className": (),
-    "PySide2.QtAxContainer.QAxWidget.clear": (),
-    "PySide2.QtAxContainer.QAxWidget.createHostWindow": [('bool',), ('bool', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtAxContainer.QAxWidget.doVerb": ('str',),
-    "PySide2.QtAxContainer.QAxWidget.fallbackMetaObject": (),
-    "PySide2.QtAxContainer.QAxWidget.minimumSizeHint": (),
-    "PySide2.QtAxContainer.QAxWidget.qObject": (),
-    "PySide2.QtAxContainer.QAxWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtAxContainer.QAxWidget.sizeHint": (),
-    "PySide2.QtAxContainer.QAxWidget.translateKeyEvent": ('int', 'int'),
-    }) if "PySide2.QtAxContainer" in sys.modules else None
-# Module PySide2.QtWebChannel
-sig_dict.update({
-# class PySide2.QtWebChannel.QWebChannel:
-    "PySide2.QtWebChannel.QWebChannel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.blockUpdates": (),
-    "PySide2.QtWebChannel.QWebChannel.connectTo": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.deregisterObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.disconnectFrom": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.registerObject": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebChannel.QWebChannel.registerObjects": ('typing.Dict',),
-    "PySide2.QtWebChannel.QWebChannel.registeredObjects": (),
-    "PySide2.QtWebChannel.QWebChannel.setBlockUpdates": ('bool',),
-# class PySide2.QtWebChannel.QWebChannelAbstractTransport:
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.sendMessage": ('typing.Dict',),
-    }) if "PySide2.QtWebChannel" in sys.modules else None
-# Module PySide2.QtWebEngineCore
-sig_dict.update({
-# class PySide2.QtWebEngineCore.QWebEngineCookieStore:
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteAllCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteSessionCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.loadAllCookies": (),
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest:
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method:
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method'), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.hasHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.header": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.headers": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.method": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postData": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postRequest": ('PySide2.QtCore.QUrl', 'typing.Dict'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setMethod": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setPostData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.swap": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.unsetHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.url": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.NavigationType:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.ResourceType:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.block": ('bool',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.changed": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.firstPartyUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.navigationType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.resourceType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.setHttpHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.interceptRequest": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo',),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.fail": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.reply": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestHeaders": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestUrl": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flag:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.SpecialPort:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax:
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',)],
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__copy__": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.defaultPort": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.flags": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.name": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.registerScheme": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.schemeByName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setDefaultPort": ('int',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setFlags": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setSyntax": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.syntax": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler:
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.requestStarted": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob',),
-    }) if "PySide2.QtWebEngineCore" in sys.modules else None
-# Module PySide2.QtWebEngine
-sig_dict.update({
-# class PySide2.QtWebEngine.QtWebEngine:
-    "PySide2.QtWebEngine.QtWebEngine.initialize": (),
-    }) if "PySide2.QtWebEngine" in sys.modules else None
-# Module PySide2.QtWebEngineWidgets
-sig_dict.update({
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError:
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError.Error:
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.__init__": [('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',), ('int', 'PySide2.QtCore.QUrl', 'bool', 'str')],
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.answered": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.certificateChain": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.defer": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.deferred": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.error": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.errorDescription": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.ignoreCertificateError": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.isOverridable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.rejectCertificate": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaType:
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineContextMenuData',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.editFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isContentEditable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.misspelledWord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.position": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.spellCheckerSuggestions": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadInterruptReason:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadState:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadType:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat:
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.cancel": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadDirectory": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.id": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReason": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReasonString": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isFinished": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isPaused": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isSavePageDownload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.mimeType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.path": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.pause": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.receivedBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.resume": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.savePageFormat": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadDirectory": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadFileName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setSavePageFormat": ('PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.state": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.suggestedFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.totalBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.type": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest:
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.origin": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.reject": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.toggleOn": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistory:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoBack": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoForward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItemIndex": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.goToItem": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.itemAt": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.items": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistoryItem:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__init__": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.lastVisited": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.originalUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.swap": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEnginePage:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.Feature:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlag:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.RenderProcessTerminationStatus:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType:
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtWebEngineWidgets.QWebEngineProfile', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.acceptNavigationRequest": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.action": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.backgroundColor": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.certificateError": ('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.chooseFiles": ('PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode', 'typing.Sequence', 'typing.Sequence'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contentsSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contextMenuData": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createStandardContextMenu": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.devToolsPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.download": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.inspectedPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isAudioMuted": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isVisible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptAlert": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConfirm": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConsoleMessage": ('PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel', 'str', 'int', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptPrompt": ('PySide2.QtCore.QUrl', 'str', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.print": ('PySide2.QtPrintSupport.QPrinter', 'object'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.printToPdf": [('object', 'PySide2.QtGui.QPageLayout'), ('str', 'PySide2.QtGui.QPageLayout')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.profile": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.recentlyAudible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.replaceMisspelledWord": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.requestedUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.runJavaScript": [('str',), ('str', 'int'), ('str', 'int', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.save": ('str', 'PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scrollPosition": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setAudioMuted": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setDevToolsPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setFeaturePermission": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.Feature', 'PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setInspectedPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setView": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setVisible": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setWebChannel": [('PySide2.QtWebChannel.QWebChannel',), ('PySide2.QtWebChannel.QWebChannel', 'int')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toHtml": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toPlainText": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.triggerAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.view": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.webChannel": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.zoomFactor": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy:
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cachePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearAllVisitedLinks": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearHttpCache": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearVisitedLinks": ('typing.Sequence',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cookieStore": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.defaultProfile": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.downloadPath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpAcceptLanguage": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheMaximumSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpUserAgent": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.installUrlSchemeHandler": ('PySide2.QtCore.QByteArray', 'PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler'),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isOffTheRecord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isSpellCheckEnabled": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isUsedForGlobalCertificateVerification": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentCookiesPolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentStoragePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeAllUrlSchemeHandlers": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlScheme": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlSchemeHandler": ('PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setCachePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setDownloadPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpAcceptLanguage": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheMaximumSize": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheType": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpUserAgent": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentCookiesPolicy": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentStoragePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckEnabled": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckLanguages": ('typing.Sequence',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUseForGlobalCertificateVerification": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.spellCheckLanguages": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.storageName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.urlSchemeHandler": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.visitedLinksContainsUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtWebEngineWidgets.QWebEngineScript:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.ScriptWorldId:
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineScript',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.injectionPoint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.isNull": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.name": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.runsOnSubFrames": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setInjectionPoint": ('PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setRunsOnSubFrames": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setSourceCode": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setWorldId": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.sourceCode": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.swap": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.worldId": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineScriptCollection:
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.contains": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScript": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScripts": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.insert": [('PySide2.QtWebEngineWidgets.QWebEngineScript',), ('typing.Sequence',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.isEmpty": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.remove": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.size": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.toList": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute:
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultTextEncoding": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.globalSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetUnknownUrlSchemePolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setDefaultTextEncoding": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize', 'int'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setUnknownUrlSchemePolicy": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.testAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.unknownUrlSchemePolicy": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineView:
-    "PySide2.QtWebEngineWidgets.QWebEngineView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.pageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.reload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.sizeHint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.stop": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.triggerPageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.zoomFactor": (),
-    }) if "PySide2.QtWebEngineWidgets" in sys.modules else None
-# Module PySide2.QtWebSockets
-sig_dict.update({
-# class PySide2.QtWebSockets.QMaskGenerator:
-    "PySide2.QtWebSockets.QMaskGenerator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebSockets.QMaskGenerator.nextMask": (),
-    "PySide2.QtWebSockets.QMaskGenerator.seed": (),
-# class PySide2.QtWebSockets.QWebSocket:
-    "PySide2.QtWebSockets.QWebSocket.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketProtocol.Version', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocket.abort": (),
-    "PySide2.QtWebSockets.QWebSocket.bytesToWrite": (),
-    "PySide2.QtWebSockets.QWebSocket.close": ('PySide2.QtWebSockets.QWebSocketProtocol.CloseCode', 'str'),
-    "PySide2.QtWebSockets.QWebSocket.closeCode": (),
-    "PySide2.QtWebSockets.QWebSocket.closeReason": (),
-    "PySide2.QtWebSockets.QWebSocket.error": (),
-    "PySide2.QtWebSockets.QWebSocket.errorString": (),
-    "PySide2.QtWebSockets.QWebSocket.flush": (),
-    "PySide2.QtWebSockets.QWebSocket.isValid": (),
-    "PySide2.QtWebSockets.QWebSocket.localAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.localPort": (),
-    "PySide2.QtWebSockets.QWebSocket.maskGenerator": (),
-    "PySide2.QtWebSockets.QWebSocket.open": [('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtWebSockets.QWebSocket.origin": (),
-    "PySide2.QtWebSockets.QWebSocket.pauseMode": (),
-    "PySide2.QtWebSockets.QWebSocket.peerAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.peerName": (),
-    "PySide2.QtWebSockets.QWebSocket.peerPort": (),
-    "PySide2.QtWebSockets.QWebSocket.ping": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.proxy": (),
-    "PySide2.QtWebSockets.QWebSocket.readBufferSize": (),
-    "PySide2.QtWebSockets.QWebSocket.request": (),
-    "PySide2.QtWebSockets.QWebSocket.requestUrl": (),
-    "PySide2.QtWebSockets.QWebSocket.resourceName": (),
-    "PySide2.QtWebSockets.QWebSocket.resume": (),
-    "PySide2.QtWebSockets.QWebSocket.sendBinaryMessage": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.sendTextMessage": ('str',),
-    "PySide2.QtWebSockets.QWebSocket.setMaskGenerator": ('PySide2.QtWebSockets.QMaskGenerator',),
-    "PySide2.QtWebSockets.QWebSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtWebSockets.QWebSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocket.setReadBufferSize": ('int',),
-    "PySide2.QtWebSockets.QWebSocket.state": (),
-    "PySide2.QtWebSockets.QWebSocket.version": (),
-# class PySide2.QtWebSockets.QWebSocketCorsAuthenticator:
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.__init__": [('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',), ('str',)],
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.allowed": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.origin": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.setAllowed": ('bool',),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.swap": ('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',),
-# class PySide2.QtWebSockets.QWebSocketProtocol:
-# class PySide2.QtWebSockets.QWebSocketProtocol.CloseCode:
-# class PySide2.QtWebSockets.QWebSocketProtocol.Version:
-# class PySide2.QtWebSockets.QWebSocketServer:
-# class PySide2.QtWebSockets.QWebSocketServer.SslMode:
-    "PySide2.QtWebSockets.QWebSocketServer.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketServer.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocketServer.close": (),
-    "PySide2.QtWebSockets.QWebSocketServer.error": (),
-    "PySide2.QtWebSockets.QWebSocketServer.errorString": (),
-    "PySide2.QtWebSockets.QWebSocketServer.handleConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtWebSockets.QWebSocketServer.handshakeTimeoutMS": (),
-    "PySide2.QtWebSockets.QWebSocketServer.hasPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.isListening": (),
-    "PySide2.QtWebSockets.QWebSocketServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtWebSockets.QWebSocketServer.maxPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nativeDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nextPendingConnection": (),
-    "PySide2.QtWebSockets.QWebSocketServer.pauseAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.proxy": (),
-    "PySide2.QtWebSockets.QWebSocketServer.resumeAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.secureMode": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverAddress": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverName": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverPort": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverUrl": (),
-    "PySide2.QtWebSockets.QWebSocketServer.setHandshakeTimeout": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setNativeDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocketServer.setServerName": ('str',),
-    "PySide2.QtWebSockets.QWebSocketServer.setSocketDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.socketDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.supportedVersions": (),
-    }) if "PySide2.QtWebSockets" in sys.modules else None
-# Module PySide2.Qt3DCore
-sig_dict.update({
-# class PySide2.Qt3DCore.Qt3DCore:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlag:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlags:
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractAspect:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.rootEntityId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.unregisterBackendType": ('PySide2.QtCore.QMetaObject',),
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton.jointCount": (),
-# class PySide2.Qt3DCore.Qt3DCore.QArmature:
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.skeleton": (),
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine:
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.aspects": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.executeCommand": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.processFrame": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.runMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.setRunMode": ('PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.unregisterAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-# class PySide2.Qt3DCore.Qt3DCore.QAspectJob:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.__init__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.run": (),
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode:
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode:
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode',),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.mode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.peerId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.setEnabled": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponent:
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.entities": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.isShareable": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.setShareable": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QEntity:
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.addComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.components": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.parentEntity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.removeComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-# class PySide2.Qt3DCore.Qt3DCore.QJoint:
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.addChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.childJoints": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.inverseBindMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.removeChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setInverseBindMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setScale": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setToIdentity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.translation": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNode:
-# class PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode:
-    "PySide2.Qt3DCore.Qt3DCore.QNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.blockNotifications": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.childNodes": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTrackings": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.defaultPropertyTrackingMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.notificationsBlocked": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.parentNode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.propertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setDefaultPropertyTrackingMode": ('PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setParent": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QObject',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setPropertyTracking": ('str', 'PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode'),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCommand:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.commandId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.data": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.inReplyTo": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setData": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setReplyToCommandId": ('int',),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.isNodeEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.parentId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode', 'typing.List'),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.subtreeIdsAndTypes": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeId:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__copy__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.createId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.isNull": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.QtCore.QMetaObject'), ('PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__copy__": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.addedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.removedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.addedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.setAddedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.removedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.setRemovedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlag:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags:
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.ChangeFlag', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.deliveryFlags": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.setDeliveryFlags": ('PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags',),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.subjectId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.type": (),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.setRootJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader:
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.Status:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.isCreateJointsEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setCreateJointsEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.source": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.status": (),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.setPropertyName": ('bytes',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.setPropertyName": ('bytes',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.setPropertyName": ('bytes',),
-# class PySide2.Qt3DCore.Qt3DCore.QTransform:
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxesAndAngles": [('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.matrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateAround": ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateFromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale3D": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale3D": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.translation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.worldMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.qHash": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'int'),
-    "PySide2.Qt3DCore.Qt3DCore.qIdForNode": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    }) if "PySide2.Qt3DCore" in sys.modules else None
-# Module PySide2.Qt3DRender
-sig_dict.update({
-# class PySide2.Qt3DRender.Qt3DRender:
-# class PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface:
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.readProperty": ('typing.Any',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.id": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight.Type:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.color": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.intensity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setIntensity": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.type": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.hits": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.runMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setRunMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.addTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.generateMipMaps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.removeTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.samples": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setGenerateMipMaps": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSamples": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWrapMode": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.textureImages": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.wrapMode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.notifyDataGeneratorChanged": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setMipLevel": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest:
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.alphaFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setAlphaFunction": ('PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setReferenceValue": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType:
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'str', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.attributeType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.buffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteStride": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.count": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultColorAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointIndicesAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointWeightsAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultNormalAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultPositionAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTangentAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate1AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate2AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinateAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.divisor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setAttributeType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setBuffer": ('PySide2.Qt3DRender.Qt3DRender.QBuffer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteStride": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDivisor": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexBaseType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexBaseType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexSize": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.blendFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.setBlendFunction": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.bufferIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationRgb": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setBufferIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceRgb": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod:
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destination": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.interpolationMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestination": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setInterpolationMethod": ('PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSource": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceRect": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType:
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.accessType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.data": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.isSyncData": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setAccessType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setSyncData": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setUsage": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.updateData": ('int', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.usage": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCamera:
-# class PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption:
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.lens": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.pan": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panAboutViewCenter": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.roll": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotate": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotateAboutViewCenter": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotation": ('float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setUpVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setViewCenter": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tilt": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.transform": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translate": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translateWorld": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.upVector": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewCenter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewVector": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens:
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFrustumProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setOrthographicProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setPerspectiveProjection": ('float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewAll": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferTypeFlags:
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.buffers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearColor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearDepthValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearStencilValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.colorBuffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setBuffers": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearDepthValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearStencilValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setColorBuffer": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QClipPlane:
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.normal": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.planeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setDistance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setNormal": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setPlaneIndex": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QColorMask:
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isAlphaMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isBlueMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isGreenMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isRedMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setAlphaMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setBlueMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setGreenMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setRedMasked": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand:
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType:
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.runType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setRunType": ('PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.trigger": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace:
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode:
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.mode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.setMode": ('PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest:
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.depthFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.setDepthFunction": ('PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QDirectionalLight:
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.setWorldDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.worldDirection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDispatchCompute:
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDithering:
-    "PySide2.Qt3DRender.Qt3DRender.QDithering.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QEffect:
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.techniques": (),
-# class PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight:
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.irradiance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setIrradiance": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.specular": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFilterKey:
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.parentFrameGraphNode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.__init__": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.parentFrameGraphNodeId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace:
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection:
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.setDirection": ('PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection',),
-# class PySide2.Qt3DRender.Qt3DRender.QFrustumCulling:
-    "PySide2.Qt3DRender.Qt3DRender.QFrustumCulling.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometry:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.attributes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.boundingVolumePositionAttribute": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.maxExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.minExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.setBoundingVolumePositionAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryFactory:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryFactory.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer:
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstInstance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstVertex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.geometry": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexBufferByteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.instanceCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveRestartEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.restartIndexValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstInstance": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstVertex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexBufferByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setInstanceCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVertexCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVerticesPerPatch": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.vertexCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.verticesPerPatch": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile:
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.api": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.extensions": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.majorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.minorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.profile": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setApi": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setExtensions": ('typing.Sequence',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMajorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMinorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setProfile": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setVendor": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.vendor": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLayer:
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.recursive": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.setRecursive": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode:
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail:
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.createBoundingSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.currentIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCurrentIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholdType": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholds": ('typing.List',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setVolumeOverride": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholdType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholds": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.volumeOverride": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.__init__": [('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',), ('PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.center": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.isEmpty": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.radius": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLineWidth:
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setSmooth": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.smooth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMaterial:
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.effect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.setEffect": ('PySide2.Qt3DRender.Qt3DRender.QEffect',),
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operation:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations:
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.setWaitOperations": ('PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.waitOperations": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMesh:
-# class PySide2.Qt3DRender.Qt3DRender.QMesh.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.meshName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setMeshName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing:
-    "PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDepthMask:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDepthMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDraw:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDraw.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoPicking:
-    "PySide2.Qt3DRender.Qt3DRender.QNoPicking.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QObjectPicker:
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.containsMouse": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isDragEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isHoverEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isPressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.priority": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setDragEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setHoverEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setPriority": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.size": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.update": ('PySide2.QtCore.QRect',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QParameter:
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('str', 'PySide2.Qt3DRender.Qt3DRender.QAbstractTexture', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('str', 'typing.Any', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Modifiers:
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.button": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.buttons": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.isAccepted": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.modifiers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.viewport": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickLineEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.edgeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex2Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickPointEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.pointIndex": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.triangleIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.uvw": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex3Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.faceOrientationPickingMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickResultMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setFaceOrientationPickingMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickMethod": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickResultMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setWorldSpaceTolerance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.worldSpaceTolerance": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPointLight:
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize:
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setSizeMode": ('PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.sizeMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPolygonOffset:
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.depthSteps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.scaleFactor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setDepthSteps": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setScaleFactor": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QProximityFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.distanceThreshold": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setDistanceThreshold": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.length": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.origin": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setLength": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.trigger": [(), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float')],
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit:
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__init__": [(), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit',), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType', 'PySide2.Qt3DCore.Qt3DCore.QNodeId', 'float', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__copy__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entityId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.primitiveIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex3Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderAspect.__init__": [('PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.requestCapture": [(), ('PySide2.QtCore.QRect',), ('int',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.captureId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.image": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.isComplete": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveImage": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveToFile": ('str',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPass:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.renderStates": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.shaderProgram": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.matchAny": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.activeFrameGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.pickingSettings": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.renderPolicy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setRenderPolicy": ('PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderState:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderStateSet:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.renderStates": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.externalRenderTargetSize": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurfacePixelRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surface": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surfacePixelRatio": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTarget:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.addOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.removeOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.attachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setOutputs": ('typing.List',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.target": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.component": ('str', 'PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType'),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entity": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entityNames": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScissorTest:
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setBottom": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setLeft": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.setPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.trigger": [(), ('PySide2.QtCore.QPoint',)],
-# class PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap:
-    "PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence:
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handleType": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderData:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.event": ('PySide2.QtCore.QEvent',),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.access": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layered": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setAccess": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayered": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.loadSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.log": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setComputeShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setFragmentShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setGeometryShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setShaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationControlShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationEvaluationShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setVertexShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.shaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.vertexShaderCode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.enabledLayers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setComputeShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setEnabledLayers": ('typing.Sequence',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setFragmentShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setGeometryShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationControlShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationEvaluationShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setVertexShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.shaderProgram": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderGraph": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture:
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.setTextureId": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.textureId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy:
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType:
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.setSortTypes": ('typing.List',),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypesInt": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSpotLight:
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.cutOffAngle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.localDirection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setCutOffAngle": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLocalDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilMask:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.backOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.frontOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setBackOutputMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setFrontOutputMask": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.FaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.allTestsPassOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.depthTestFailureOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setAllTestsPassOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setDepthTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setStencilTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.stencilTestFailureOperation": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTest:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.comparisonMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setComparisonMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setReferenceValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setStencilFunction": ('PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.stencilFunction": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechnique:
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.graphicsApiFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.renderPasses": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.matchAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture3D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture3D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureBuffer:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureBuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.isAutoMipMapGenerationEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.cleanup": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.data": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.faces": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.isCompressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.mipLevels": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelFormat": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setData": ('PySide2.QtCore.QByteArray', 'int', 'bool'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFaces": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setImage": ('PySide2.QtGui.QImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setMipLevels": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelFormat": ('PySide2.QtGui.QOpenGLTexture.PixelFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelType": ('PySide2.QtGui.QOpenGLTexture.PixelType',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setTarget": ('PySide2.QtGui.QOpenGLTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageDataGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureLoader:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.source": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureRectangle:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureRectangle.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.__init__": [('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject'), ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject')],
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.x": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.y": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.z": (),
-# class PySide2.Qt3DRender.Qt3DRender.QViewport:
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.gamma": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.normalizedRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setGamma": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setNormalizedRect": ('PySide2.QtCore.QRectF',),
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence:
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setTimeout": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setWaitOnCPU": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.timeout": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.waitOnCPU": (),
-    }) if "PySide2.Qt3DRender" in sys.modules else None
-# Module PySide2.Qt3DInput
-sig_dict.update({
-# class PySide2.Qt3DInput.Qt3DInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.addAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisSettings": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.removeAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-# class PySide2.Qt3DInput.Qt3DInput.QAction:
-    "PySide2.Qt3DInput.Qt3DInput.QAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.isActive": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-# class PySide2.Qt3DInput.Qt3DInput.QActionInput:
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setButtons": ('typing.List',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.axis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.setAxis": ('int',),
-# class PySide2.Qt3DInput.Qt3DInput.QAxis:
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.value": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator:
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setScale": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxisType": ('PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxisType": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.value": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.velocity": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisSetting:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.deadZoneRadius": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.isSmoothEnabled": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setAxes": ('typing.List',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setDeadZoneRadius": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setSmoothEnabled": ('bool',),
-# class PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.acceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.deceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setAcceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setButtons": ('typing.List',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setDeceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setScale": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputAspect:
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.availablePhysicalDevices": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.createPhysicalDevice": ('str',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputChord:
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.addChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.chords": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.removeChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSequence:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.addSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.buttonInterval": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.removeSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.sequences": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setButtonInterval": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSettings:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.eventSource": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.setEventSource": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyEvent:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.count": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAutoRepeat": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.key": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.nativeScanCode": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.text": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.type": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.activeInput": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonNames": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.focus": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setFocus": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QLogicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.actions": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice.Axis:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.sensitivity": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.setSensitivity": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.button": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.wasHeld": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.y": (),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.containsMouse": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setContainsMouse": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QMouseDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.angleDelta": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.y": (),
-    }) if "PySide2.Qt3DInput" in sys.modules else None
-# Module PySide2.Qt3DLogic
-sig_dict.update({
-# class PySide2.Qt3DLogic.Qt3DLogic:
-# class PySide2.Qt3DLogic.Qt3DLogic.QFrameAction:
-    "PySide2.Qt3DLogic.Qt3DLogic.QFrameAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect:
-    "PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect.__init__": ('PySide2.QtCore.QObject',),
-    }) if "PySide2.Qt3DLogic" in sys.modules else None
-# Module PySide2.Qt3DAnimation
-sig_dict.update({
-# class PySide2.Qt3DAnimation.Qt3DAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.AnimationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setAnimationName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setDuration": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip.duration": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractChannelMapping:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.Loops:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.clock": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.isRunning": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.loopCount": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.normalizedTime": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setClock": ('PySide2.Qt3DAnimation.Qt3DAnimation.QClock',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setLoopCount": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setNormalizedTime": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setRunning": ('bool',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.start": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.stop": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.baseClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setBaseClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.Flag:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.__init__": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.valueChanged": ('typing.Any',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.Status:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.source": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.status": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.activeAnimationGroup": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.addAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.animationGroupList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.entity": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getAnimationIndex": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionOffset": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionScale": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.recursive": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.removeAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setActiveAnimationGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setAnimationGroups": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPosition": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionOffset": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionScale": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setRecursive": ('bool',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.addAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.animationList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.name": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.removeAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setAnimations": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.blendTree": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.setBlendTree": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.clip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.setClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClock:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.playbackRate": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.setPlaybackRate": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.__init__": [(), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.coordinates": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.interpolationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.leftControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.rightControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setCoordinates": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setInterpolationType": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setLeftControlPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setRightControlPoint": ('PySide2.QtGui.QVector2D',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.addKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.endMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.framePositions": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.keyframeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.removeKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEndMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setFramePositions": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setKeyframes": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setStartMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTarget": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.startMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.targetName": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.blendFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.endClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setBlendFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setEndClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setStartClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.startClip": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeNames": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.fromGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry', 'typing.Sequence'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.setAttributes": ('typing.List',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.getWeights": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.method": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMethod": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMorphTargets": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetPositions": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setWeights": ('int', 'typing.List'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetPositions": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.skeleton": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setMorphTargets": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetPositions": ('typing.List',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetPositions": (),
-    }) if "PySide2.Qt3DAnimation" in sys.modules else None
-# Module PySide2.Qt3DExtras
-sig_dict.update({
-# class PySide2.Qt3DExtras.Qt3DExtras:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__init__": [(), ('PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__copy__": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.acceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.deceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.linearSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.lookSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setAcceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setDeceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLinearSpeed": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLookSpeed": ('float',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.currentIndex": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setCurrentIndex": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.topRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.topRadius": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setDiffuse": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setSpecular": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.extrusionLength": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.depth": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer:
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.buffersToClear": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.clearColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.externalRenderTargetSize": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.gamma": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.isFrustumCullingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setBuffersToClear": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setFrustumCullingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setGamma": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setViewportRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.surface": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.viewportRect": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.beta": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.cool": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setBeta": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setCool": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setWarm": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.warm": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.ambientOcclusion": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.baseColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.metalness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.roughness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setAmbientOcclusion": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setBaseColor": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setMetalness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setRoughness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.interpolator": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setInterpolator": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.setZoomInLimit": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.zoomInLimit": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.blendFunctionArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setBlendFunctionArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.resolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.meshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.baseName": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.extension": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.isGammaCorrectEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setBaseName": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setExtension": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setGammaCorrectEnabled": ('bool',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.columns": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.rows": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setColumns": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setRows": ('int',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.addSprite": [('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.removeSprite": ('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.setSprites": ('typing.List',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.sprites": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setHeight": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setWidth": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setX": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setY": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.width": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.x": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.y": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.color": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.text": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureOffset": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureTransform": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureOffset": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow:
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.__init__": ('PySide2.QtGui.QScreen',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.activeFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.defaultFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.renderSettings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setRootEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    }) if "PySide2.Qt3DExtras" in sys.modules else None
-# Module testbinding
-sig_dict.update({
-# class testbinding.Enum1:
-# class testbinding.IntValue:
-    "testbinding.IntValue.__init__": [(), ('int',), ('testbinding.IntValue',)],
-    "testbinding.IntValue.__copy__": (),
-# class testbinding.PySideCPP:
-# class testbinding.PySideCPP.TestObject2WithNamespace:
-    "testbinding.PySideCPP.TestObject2WithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObject2WithNamespace.__repr__": (),
-    "testbinding.PySideCPP.TestObject2WithNamespace.name": (),
-# class testbinding.PySideCPP.TestObjectWithNamespace:
-    "testbinding.PySideCPP.TestObjectWithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignal": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithNamespace": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.name": (),
-# class testbinding.TestObject:
-    "testbinding.TestObject.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "testbinding.TestObject.addChild": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObject.checkType": ('typing.Any',),
-    "testbinding.TestObject.createApp": (),
-    "testbinding.TestObject.emitIdValueSignal": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_bool": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_void": (),
-    "testbinding.TestObject.emitSignalWithTypedefValue": ('int',),
-    "testbinding.TestObject.emitStaticMethodDoubleSignal": (),
-    "testbinding.TestObject.idValue": (),
-    "testbinding.TestObject.staticMethodDouble": ('int',),
-# class testbinding.TestObjectWithoutNamespace:
-# class testbinding.TestObjectWithoutNamespace.Enum2:
-    "testbinding.TestObjectWithoutNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObjectWithoutNamespace.callSignal": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithNamespace": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.TestObjectWithoutNamespace.name": (),
-# class testbinding.TestView:
-    "testbinding.TestView.__init__": ('PySide2.QtCore.QAbstractListModel', 'PySide2.QtCore.QObject'),
-    "testbinding.TestView.getData": (),
-    "testbinding.TestView.getEditorWidgetFromItemDelegate": (),
-    "testbinding.TestView.model": (),
-    "testbinding.TestView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "testbinding.TestView.getHiddenObject": (),
-    }) if "testbinding" in sys.modules else None
-# Module Shiboken
-sig_dict.update({
-# class Shiboken.VoidPtr:
-    }) if "Shiboken" in sys.modules else None
-# Module minimal
-sig_dict.update({
-# class minimal.ListUser:
-    "minimal.ListUser.__init__": [(), ('minimal.ListUser',)],
-    "minimal.ListUser.__copy__": (),
-    "minimal.ListUser.callCreateIntList": ('int',),
-    "minimal.ListUser.callCreateListOfIntLists": ('int',),
-    "minimal.ListUser.callCreateMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.callCreateObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.callCreateValList": ('int',),
-    "minimal.ListUser.callOredMinBoolList": ('typing.List',),
-    "minimal.ListUser.callSumIntList": ('typing.List',),
-    "minimal.ListUser.callSumListOfIntLists": ('typing.List',),
-    "minimal.ListUser.callSumObjList": ('typing.List',),
-    "minimal.ListUser.callSumValList": ('typing.List',),
-    "minimal.ListUser.createIntList": ('int',),
-    "minimal.ListUser.createListOfIntLists": ('int',),
-    "minimal.ListUser.createMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.createObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.createValList": ('int',),
-    "minimal.ListUser.oredMinBoolList": ('typing.List',),
-    "minimal.ListUser.sumIntList": ('typing.List',),
-    "minimal.ListUser.sumListOfIntLists": ('typing.List',),
-    "minimal.ListUser.sumObjList": ('typing.List',),
-    "minimal.ListUser.sumValList": ('typing.List',),
-# class minimal.MinBoolUser:
-    "minimal.MinBoolUser.__init__": [(), ('minimal.MinBoolUser',)],
-    "minimal.MinBoolUser.__copy__": (),
-    "minimal.MinBoolUser.callInvertedMinBool": (),
-    "minimal.MinBoolUser.invertedMinBool": (),
-    "minimal.MinBoolUser.minBool": (),
-    "minimal.MinBoolUser.setMinBool": ('bool',),
-# class minimal.Obj:
-    "minimal.Obj.__init__": ('int',),
-    "minimal.Obj.callPassObjectType": ('minimal.Obj',),
-    "minimal.Obj.callPassObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.callVirtualMethod": ('int',),
-    "minimal.Obj.objId": (),
-    "minimal.Obj.passObjectType": ('minimal.Obj',),
-    "minimal.Obj.passObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.setObjId": ('int',),
-    "minimal.Obj.virtualMethod": ('int',),
-# class minimal.Val:
-# class minimal.Val.ValEnum:
-    "minimal.Val.__init__": [('int',), ('minimal.Val',)],
-    "minimal.Val.__copy__": (),
-    "minimal.Val.callPassValueType": ('minimal.Val',),
-    "minimal.Val.callPassValueTypePointer": ('minimal.Val',),
-    "minimal.Val.callPassValueTypeReference": ('minimal.Val',),
-    "minimal.Val.oneOrTheOtherEnumValue": ('minimal.Val.ValEnum',),
-    "minimal.Val.passValueType": ('minimal.Val',),
-    "minimal.Val.passValueTypePointer": ('minimal.Val',),
-    "minimal.Val.passValueTypeReference": ('minimal.Val',),
-    "minimal.Val.setValId": ('int',),
-    "minimal.Val.valId": (),
-    "minimal.Val.arrayFunc": ('typing.List',),
-    "minimal.Val.arrayFuncInt": ('typing.List',),
-    "minimal.Val.arrayFuncIntReturn": ('int',),
-    "minimal.Val.arrayFuncIntReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncIntTypedef": ('typing.List',),
-    "minimal.Val.arrayFuncReturn": ('int',),
-    "minimal.Val.arrayFuncReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncTypedef": ('typing.List',),
-    }) if "minimal" in sys.modules else None
-# Module sample
-sig_dict.update({
-# class sample.Abstract:
-# class sample.Abstract.PrintFormat:
-# class sample.Abstract.Type:
-    "sample.Abstract.__init__": ('int',),
-    "sample.Abstract.callPureVirtual": (),
-    "sample.Abstract.callUnpureVirtual": (),
-    "sample.Abstract.callVirtualGettingEnum": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.className": (),
-    "sample.Abstract.createObject": (),
-    "sample.Abstract.getObjectId": ('sample.Abstract',),
-    "sample.Abstract.id_": (),
-    "sample.Abstract.pureVirtual": (),
-    "sample.Abstract.pureVirtualReturningVoidPtr": (),
-    "sample.Abstract.returnAnEnum": (),
-    "sample.Abstract.show": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.type": (),
-    "sample.Abstract.unpureVirtual": (),
-    "sample.Abstract.virtualGettingAEnum": ('sample.Abstract.PrintFormat',),
-# class sample.AbstractModifications:
-    "sample.AbstractModifications.__init__": (),
-    "sample.AbstractModifications.invert": ('bool',),
-    "sample.AbstractModifications.pointlessPureVirtualMethod": (),
-# class sample.ArrayModifyTest:
-    "sample.ArrayModifyTest.__init__": [(), ('sample.ArrayModifyTest',)],
-    "sample.ArrayModifyTest.__copy__": (),
-    "sample.ArrayModifyTest.sumIntArray": ('int', 'typing.Sequence'),
-# class sample.Base1:
-    "sample.Base1.__init__": (),
-    "sample.Base1.base1Method": (),
-    "sample.Base1.publicMethod": (),
-# class sample.Base2:
-    "sample.Base2.__init__": (),
-    "sample.Base2.base2Method": (),
-# class sample.Base3:
-    "sample.Base3.__init__": ('int',),
-    "sample.Base3.base3Method": (),
-# class sample.Base4:
-    "sample.Base4.__init__": (),
-    "sample.Base4.base4Method": (),
-# class sample.Base5:
-    "sample.Base5.__init__": (),
-    "sample.Base5.base5Method": (),
-# class sample.Base6:
-    "sample.Base6.__init__": (),
-    "sample.Base6.base6Method": (),
-# class sample.BlackBox:
-    "sample.BlackBox.__init__": [(), ('sample.BlackBox',)],
-    "sample.BlackBox.__copy__": (),
-    "sample.BlackBox.disposeObjectType": ('int',),
-    "sample.BlackBox.disposePoint": ('int',),
-    "sample.BlackBox.keepObjectType": ('object',),
-    "sample.BlackBox.keepPoint": ('typing.Tuple',),
-    "sample.BlackBox.objects": (),
-    "sample.BlackBox.points": (),
-    "sample.BlackBox.referenceToObjectPointer": ('object',),
-    "sample.BlackBox.referenceToValuePointer": ('typing.Tuple',),
-    "sample.BlackBox.retrieveObjectType": ('int',),
-    "sample.BlackBox.retrievePoint": ('int',),
-# class sample.Bucket:
-    "sample.Bucket.__init__": (),
-    "sample.Bucket.callVirtualBlockerMethodButYouDontKnowThis": (),
-    "sample.Bucket.empty": (),
-    "sample.Bucket.lock": (),
-    "sample.Bucket.locked": (),
-    "sample.Bucket.pop": (),
-    "sample.Bucket.push": ('int',),
-    "sample.Bucket.unlock": (),
-    "sample.Bucket.virtualBlockerMethod": (),
-# class sample.ByteArray:
-    "sample.ByteArray.__init__": [(), ('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__add__": [('bytes',), ('int',), ('sample.ByteArray',), ('str',)],
-    "sample.ByteArray.__copy__": (),
-    "sample.ByteArray.__iadd__": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__repr__": (),
-    "sample.ByteArray.__str__": (),
-    "sample.ByteArray.append": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.at": ('int',),
-    "sample.ByteArray.data": (),
-    "sample.ByteArray.size": (),
-# class sample.CVListUser:
-    "sample.CVListUser.__init__": [(), ('sample.CVListUser',)],
-    "sample.CVListUser.__copy__": (),
-    "sample.CVListUser.consume": ('typing.List',),
-    "sample.CVListUser.produce": (),
-# class sample.CVValueType:
-    "sample.CVValueType.__copy__": (),
-# class sample.ClassWithFunctionPointer:
-    "sample.ClassWithFunctionPointer.__init__": [(), ('sample.ClassWithFunctionPointer',)],
-    "sample.ClassWithFunctionPointer.__copy__": (),
-    "sample.ClassWithFunctionPointer.doNothing": ('int',),
-# class sample.Collector:
-    "sample.Collector.__init__": (),
-    "sample.Collector.__lshift__": [('Missing("sample.ObjectType.Identifier")',), ('object',), ('sample.IntWrapper',)],
-    "sample.Collector.clear": (),
-    "sample.Collector.items": (),
-    "sample.Collector.size": (),
-# class sample.Color:
-    "sample.Color.__init__": [(), ('int',), ('sample.Color',), ('sample.SampleNamespace.InValue',)],
-    "sample.Color.__copy__": (),
-    "sample.Color.isNull": (),
-# class sample.CtorConvRule:
-    "sample.CtorConvRule.__init__": [('int',), ('sample.CtorConvRule',)],
-    "sample.CtorConvRule.__copy__": (),
-    "sample.CtorConvRule.dummyVirtualMethod": (),
-    "sample.CtorConvRule.value": (),
-# class sample.Data:
-# class sample.Data.Field:
-    "sample.Data.__init__": [('sample.Data',), ('sample.Data.Field', 'str')],
-    "sample.Data.__and__": ('sample.Union',),
-    "sample.Data.__copy__": (),
-    "sample.Data.field": (),
-    "sample.Data.value": (),
-# class sample.Derived:
-# class sample.Derived.OtherOverloadedFuncEnum:
-# class sample.Derived.SomeInnerClass:
-    "sample.Derived.SomeInnerClass.__init__": [(), ('sample.Derived.SomeInnerClass',)],
-    "sample.Derived.SomeInnerClass.__add__": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.SomeInnerClass.__copy__": (),
-    "sample.Derived.SomeInnerClass.uselessMethod": (),
-    "sample.Derived.__init__": ('int',),
-    "sample.Derived.className": (),
-    "sample.Derived.createObject": (),
-    "sample.Derived.defaultValue": ('int',),
-    "sample.Derived.getClassName": (),
-    "sample.Derived.otherOverloaded": [('int', 'float'), ('int', 'int', 'bool', 'float')],
-    "sample.Derived.overloaded": [('float',), ('int', 'int')],
-    "sample.Derived.pureVirtual": (),
-    "sample.Derived.pureVirtualReturningVoidPtr": (),
-    "sample.Derived.returnAnEnum": (),
-    "sample.Derived.returnMyParameter": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.singleArgument": ('bool',),
-    "sample.Derived.triggerAnotherImpossibleTypeDiscovery": (),
-    "sample.Derived.triggerImpossibleTypeDiscovery": (),
-    "sample.Derived.type": (),
-    "sample.Derived.unpureVirtual": (),
-# class sample.Echo:
-    "sample.Echo.__init__": [(), ('sample.Echo',)],
-    "sample.Echo.__call__": ('sample.Str', 'int'),
-    "sample.Echo.__copy__": (),
-    "sample.Echo.__lshift__": [('int',), ('object',), ('sample.Str',)],
-    "sample.Echo.doNothingWithConstBool": ('bool',),
-    "sample.Echo.echo": ('bytes',),
-    "sample.Echo.methodWithNamedArg": ('sample.Str',),
-# class sample.EnumOnNamespace:
-# class sample.Event:
-# class sample.Event.EventType:
-# class sample.Event.EventTypeClass:
-    "sample.Event.__init__": [('sample.Event',), ('sample.Event.EventType',)],
-    "sample.Event.__copy__": (),
-    "sample.Event.eventType": (),
-    "sample.Event.setEventType": ('sample.Event.EventType',),
-    "sample.Event.setEventTypeByConstRef": ('sample.Event.EventType',),
-# class sample.ExceptionTest:
-    "sample.ExceptionTest.__init__": (),
-    "sample.ExceptionTest.intThrowInt": ('bool',),
-    "sample.ExceptionTest.intThrowStdException": ('bool',),
-    "sample.ExceptionTest.voidThrowInt": ('bool',),
-    "sample.ExceptionTest.voidThrowStdException": ('bool',),
-# class sample.Expression:
-    "sample.Expression.__init__": [('int',), ('sample.Expression',)],
-    "sample.Expression.__add__": ('sample.Expression',),
-    "sample.Expression.__copy__": (),
-    "sample.Expression.__sub__": ('sample.Expression',),
-    "sample.Expression.toString": (),
-# class sample.Filter:
-    "sample.Filter.__init__": [(), ('sample.Filter',)],
-    "sample.Filter.__copy__": (),
-# class sample.FriendOfOnlyCopy:
-    "sample.FriendOfOnlyCopy.__init__": [(), ('sample.FriendOfOnlyCopy',)],
-    "sample.FriendOfOnlyCopy.__copy__": (),
-    "sample.FriendOfOnlyCopy.createListOfOnlyCopy": ('int',),
-    "sample.FriendOfOnlyCopy.createOnlyCopy": ('int',),
-# class sample.GlobalEnum:
-# class sample.GlobalOverloadFuncEnum:
-# class sample.HandleHolder:
-    "sample.HandleHolder.__init__": ('int',),
-    "sample.HandleHolder.compare": ('sample.HandleHolder',),
-    "sample.HandleHolder.compare2": ('sample.HandleHolder',),
-    "sample.HandleHolder.createHandle": (),
-    "sample.HandleHolder.handle": (),
-    "sample.HandleHolder.handle2": (),
-    "sample.HandleHolder.set": ('int',),
-# class sample.ImplicitBase:
-    "sample.ImplicitBase.__init__": [(), ('sample.ImplicitBase',), ('sample.ImplicitTarget',)],
-    "sample.ImplicitBase.__copy__": (),
-# class sample.ImplicitConv:
-# class sample.ImplicitConv.CtorEnum:
-# class sample.ImplicitConv.ICOverloadedFuncEnum:
-    "sample.ImplicitConv.__init__": [(), ('None',), ('float', 'bool'), ('int',), ('object',), ('sample.ImplicitConv',), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.__copy__": (),
-    "sample.ImplicitConv.ctorEnum": (),
-    "sample.ImplicitConv.implicitConvCommon": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvDefault": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvOverloading": [('int',), ('sample.ImplicitConv', 'bool'), ('sample.ImplicitConv', 'int'), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.objId": (),
-    "sample.ImplicitConv.value": (),
-# class sample.ImplicitTarget:
-    "sample.ImplicitTarget.__init__": [(), ('sample.ImplicitTarget',)],
-    "sample.ImplicitTarget.__copy__": (),
-# class sample.InjectCode:
-    "sample.InjectCode.__init__": [(), ('sample.InjectCode',)],
-    "sample.InjectCode.__copy__": (),
-    "sample.InjectCode.arrayMethod": ('int',),
-    "sample.InjectCode.callArrayMethod": ('int',),
-    "sample.InjectCode.overloadedMethod": [('int', 'bool'), ('int', 'float'), ('int', 'typing.List')],
-    "sample.InjectCode.simpleMethod1": ('int', 'int'),
-    "sample.InjectCode.simpleMethod2": (),
-    "sample.InjectCode.simpleMethod3": ('int', 'typing.List'),
-    "sample.InjectCode.sumArrayAndLength": (),
-    "sample.InjectCode.virtualMethod": ('int',),
-# class sample.IntArray2:
-    "sample.IntArray2.__init__": [('int',), ('sample.IntArray2',), ('typing.Sequence',)],
-    "sample.IntArray2.__copy__": (),
-    "sample.IntArray2.sum": (),
-# class sample.IntArray3:
-    "sample.IntArray3.__init__": [('int',), ('sample.IntArray3',), ('typing.Sequence',)],
-    "sample.IntArray3.__copy__": (),
-    "sample.IntArray3.sum": (),
-# class sample.IntList:
-# class sample.IntList.CtorEnum:
-    "sample.IntList.__init__": [(), ('int',), ('sample.IntList',), ('typing.Sequence',)],
-    "sample.IntList.__copy__": (),
-    "sample.IntList.append": ('int',),
-    "sample.IntList.constructorUsed": (),
-# class sample.IntWrapper:
-    "sample.IntWrapper.__init__": [('int',), ('sample.IntWrapper',)],
-    "sample.IntWrapper.__copy__": (),
-# class sample.Intersection:
-    "sample.Intersection.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Intersection.__and__": ('sample.Intersection',),
-    "sample.Intersection.__copy__": (),
-    "sample.Intersection.addFilter": ('sample.Filter',),
-    "sample.Intersection.filters": (),
-# class sample.ListUser:
-# class sample.ListUser.ListOfSomething:
-    "sample.ListUser.__init__": [(), ('sample.ListUser',)],
-    "sample.ListUser.__copy__": (),
-    "sample.ListUser.callCreateList": (),
-    "sample.ListUser.createComplexList": ('complex', 'complex'),
-    "sample.ListUser.createList": (),
-    "sample.ListUser.getList": (),
-    "sample.ListUser.listOfPoints": ('typing.List',),
-    "sample.ListUser.multiplyPointList": ('typing.List', 'float'),
-    "sample.ListUser.setList": ('typing.List',),
-    "sample.ListUser.sumList": ('typing.List',),
-# class sample.MDerived1:
-    "sample.MDerived1.__init__": (),
-    "sample.MDerived1.base1Method": (),
-    "sample.MDerived1.base2Method": (),
-    "sample.MDerived1.castToBase1": (),
-    "sample.MDerived1.castToBase2": (),
-    "sample.MDerived1.mderived1Method": (),
-    "sample.MDerived1.publicMethod": (),
-    "sample.MDerived1.transformFromBase1": ('sample.Base1',),
-    "sample.MDerived1.transformFromBase2": ('sample.Base2',),
-# class sample.MDerived2:
-    "sample.MDerived2.__init__": (),
-    "sample.MDerived2.base4Method": (),
-    "sample.MDerived2.castToBase3": (),
-    "sample.MDerived2.castToBase4": (),
-    "sample.MDerived2.castToBase5": (),
-    "sample.MDerived2.castToBase6": (),
-    "sample.MDerived2.mderived2Method": (),
-# class sample.MDerived3:
-    "sample.MDerived3.__init__": (),
-    "sample.MDerived3.castToBase3": (),
-    "sample.MDerived3.castToMDerived1": (),
-    "sample.MDerived3.castToMDerived2": (),
-    "sample.MDerived3.mderived3Method": (),
-# class sample.MDerived4:
-    "sample.MDerived4.__init__": (),
-    "sample.MDerived4.castToBase3": (),
-    "sample.MDerived4.castToBase4": (),
-    "sample.MDerived4.justDummyMethod": (),
-    "sample.MDerived4.mderived4Method": (),
-# class sample.MDerived5:
-    "sample.MDerived5.__init__": (),
-    "sample.MDerived5.castToBase3": (),
-    "sample.MDerived5.castToBase4": (),
-    "sample.MDerived5.mderived5Method": (),
-# class sample.MapUser:
-    "sample.MapUser.__init__": [(), ('sample.MapUser',)],
-    "sample.MapUser.__copy__": (),
-    "sample.MapUser.callCreateMap": (),
-    "sample.MapUser.createMap": (),
-    "sample.MapUser.foo": (),
-    "sample.MapUser.getMap": (),
-    "sample.MapUser.passMapIntValueType": ('typing.Dict',),
-    "sample.MapUser.pointerToMap": ('typing.Dict',),
-    "sample.MapUser.referenceToMap": ('typing.Dict',),
-    "sample.MapUser.setMap": ('typing.Dict',),
-    "sample.MapUser.showMap": ('typing.Dict',),
-# class sample.ModelIndex:
-    "sample.ModelIndex.__init__": [(), ('sample.ModelIndex',)],
-    "sample.ModelIndex.__copy__": (),
-    "sample.ModelIndex.getValue": ('sample.ModelIndex',),
-    "sample.ModelIndex.setValue": ('int',),
-    "sample.ModelIndex.value": (),
-# class sample.Modifications:
-# class sample.Modifications.OverloadedModFunc:
-# class sample.Modifications.TestEnum:
-    "sample.Modifications.__init__": (),
-    "sample.Modifications.argRemoval0": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'int')],
-    "sample.Modifications.argRemoval1": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple', 'typing.Tuple', 'int')],
-    "sample.Modifications.argRemoval2": ('int', 'bool', 'typing.Tuple', 'typing.Tuple', 'int'),
-    "sample.Modifications.argRemoval3": ('int', 'typing.Tuple', 'bool', 'typing.Tuple', 'int'),
-    "sample.Modifications.argRemoval4": ('int', 'typing.Tuple', 'bool', 'typing.Tuple', 'int'),
-    "sample.Modifications.argRemoval5": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple', 'typing.Tuple', 'int')],
-    "sample.Modifications.calculateArea": ('int', 'int'),
-    "sample.Modifications.callDifferenceOfPointCoordinates": ('typing.Tuple',),
-    "sample.Modifications.defaultEnumValue": (),
-    "sample.Modifications.differenceOfPointCoordinates": ('typing.Tuple',),
-    "sample.Modifications.doublePlus": ('int', 'int'),
-    "sample.Modifications.enumValue": (),
-    "sample.Modifications.getObject": (),
-    "sample.Modifications.getSize": ('int', 'int'),
-    "sample.Modifications.increment": ('int',),
-    "sample.Modifications.invertBoolean": ('bool',),
-    "sample.Modifications.multiplyPointCoordsPlusValue": ('typing.Tuple', 'float'),
-    "sample.Modifications.name": (),
-    "sample.Modifications.nonConversionRuleForArgumentWithDefaultValue": ('object',),
-    "sample.Modifications.over": ('int', 'bool', 'typing.Tuple', 'typing.Tuple'),
-    "sample.Modifications.overloaded": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'float'), ('int', 'bool', 'int', 'int'), ('int', 'bool', 'int', 'typing.Tuple')],
-    "sample.Modifications.pointToPair": ('typing.Tuple',),
-    "sample.Modifications.power": ('int', 'int'),
-    "sample.Modifications.setEnumValue": ('sample.Modifications.TestEnum',),
-    "sample.Modifications.sumPointArray": ('int', 'typing.Sequence'),
-    "sample.Modifications.sumPointCoordinates": ('typing.Tuple',),
-    "sample.Modifications.timesTen": ('int',),
-# class sample.ModifiedConstructor:
-    "sample.ModifiedConstructor.__init__": ('int',),
-    "sample.ModifiedConstructor.retrieveValue": (),
-# class sample.NoImplicitConversion:
-    "sample.NoImplicitConversion.__init__": [('int',), ('sample.NoImplicitConversion',)],
-    "sample.NoImplicitConversion.__copy__": (),
-    "sample.NoImplicitConversion.objId": (),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByPointer": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByReference": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByValue": ('sample.NoImplicitConversion',),
-# class sample.NonDefaultCtor:
-    "sample.NonDefaultCtor.__init__": [('int',), ('sample.NonDefaultCtor',)],
-    "sample.NonDefaultCtor.__copy__": (),
-    "sample.NonDefaultCtor.callReturnMyselfVirtual": (),
-    "sample.NonDefaultCtor.returnMyself": [(), ('int',), ('int', 'sample.NonDefaultCtor')],
-    "sample.NonDefaultCtor.returnMyselfVirtual": (),
-    "sample.NonDefaultCtor.value": (),
-# class sample.ObjTypeReference:
-    "sample.ObjTypeReference.__init__": [(), ('sample.ObjTypeReference',)],
-    "sample.ObjTypeReference.justAPureVirtualFunc": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMyFirstArg": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMySecondArg": ('int', 'sample.ObjTypeReference'),
-# class sample.ObjectModel:
-# class sample.ObjectModel.MethodCalled:
-    "sample.ObjectModel.__init__": ('object',),
-    "sample.ObjectModel.data": (),
-    "sample.ObjectModel.receivesObjectTypeFamily": [('object',), ('sample.ObjectModel',)],
-    "sample.ObjectModel.setData": ('object',),
-# class sample.ObjectType:
-    "sample.ObjectType.__init__": ('object',),
-    "sample.ObjectType.callId": (),
-    "sample.ObjectType.callInvalidateEvent": ('sample.Event',),
-    "sample.ObjectType.callVirtualCreateChild": (),
-    "sample.ObjectType.callWithEnum": [('sample.Str', 'int'), ('sample.Str', 'sample.Event.EventType', 'int')],
-    "sample.ObjectType.causeEvent": ('sample.Event.EventType',),
-    "sample.ObjectType.children": (),
-    "sample.ObjectType.create": (),
-    "sample.ObjectType.createChild": ('object',),
-    "sample.ObjectType.createObjectType": (),
-    "sample.ObjectType.createWithChild": (),
-    "sample.ObjectType.deprecatedFunction": (),
-    "sample.ObjectType.destroyCppParent": (),
-    "sample.ObjectType.event": ('sample.Event',),
-    "sample.ObjectType.findChild": ('sample.Str',),
-    "sample.ObjectType.getCppParent": (),
-    "sample.ObjectType.identifier": (),
-    "sample.ObjectType.invalidateEvent": ('sample.Event',),
-    "sample.ObjectType.isLayoutType": (),
-    "sample.ObjectType.isPython": (),
-    "sample.ObjectType.killChild": ('sample.Str',),
-    "sample.ObjectType.layout": (),
-    "sample.ObjectType.nextInFocusChain": (),
-    "sample.ObjectType.objectName": (),
-    "sample.ObjectType.parent": (),
-    "sample.ObjectType.processEvent": ('typing.List', 'sample.Event'),
-    "sample.ObjectType.removeChild": ('object',),
-    "sample.ObjectType.setLayout": ('sample.ObjectTypeLayout',),
-    "sample.ObjectType.setNullObject": ('None',),
-    "sample.ObjectType.setObject": ('object',),
-    "sample.ObjectType.setObjectName": ('sample.Str',),
-    "sample.ObjectType.setObjectNameWithSize": [('bytes', 'int', 'sample.Str'), ('sample.Str', 'int')],
-    "sample.ObjectType.setObjectSplittedName": ('bytes', 'sample.Str', 'sample.Str'),
-    "sample.ObjectType.setParent": ('object',),
-    "sample.ObjectType.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeByValue:
-    "sample.ObjectTypeByValue.__init__": (),
-    "sample.ObjectTypeByValue.acceptKindOfMeAsValue": ('sample.ObjectTypeByValue',),
-    "sample.ObjectTypeByValue.acceptListOfObjectTypeByValue": ('typing.List',),
-    "sample.ObjectTypeByValue.returnSomeKindOfMe": (),
-# class sample.ObjectTypeDerived:
-    "sample.ObjectTypeDerived.__init__": (),
-    "sample.ObjectTypeDerived.event": ('sample.Event',),
-# class sample.ObjectTypeHolder:
-    "sample.ObjectTypeHolder.__init__": [('bytes',), ('sample.ObjectTypeHolder',)],
-    "sample.ObjectTypeHolder.__copy__": (),
-    "sample.ObjectTypeHolder.callPassObjectTypeAsReference": (),
-    "sample.ObjectTypeHolder.getObjecType": (),
-    "sample.ObjectTypeHolder.passObjectTypeAsReference": ('object',),
-# class sample.ObjectTypeLayout:
-    "sample.ObjectTypeLayout.__init__": (),
-    "sample.ObjectTypeLayout.addObject": ('object',),
-    "sample.ObjectTypeLayout.create": (),
-    "sample.ObjectTypeLayout.isLayoutType": (),
-    "sample.ObjectTypeLayout.objects": (),
-    "sample.ObjectTypeLayout.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeOperators:
-    "sample.ObjectTypeOperators.__init__": ('str',),
-    "sample.ObjectTypeOperators.__add__": ('str',),
-    "sample.ObjectTypeOperators.key": (),
-# class sample.ObjectTypePtrList:
-# class sample.ObjectTypePtrList.CtorEnum:
-    "sample.ObjectTypePtrList.__init__": [(), ('object',), ('sample.ObjectTypePtrList',), ('typing.Sequence',)],
-    "sample.ObjectTypePtrList.__copy__": (),
-    "sample.ObjectTypePtrList.append": ('object',),
-    "sample.ObjectTypePtrList.constructorUsed": (),
-# class sample.ObjectView:
-    "sample.ObjectView.__init__": ('sample.ObjectModel', 'object'),
-    "sample.ObjectView.displayModelData": (),
-    "sample.ObjectView.getRawModelData": (),
-    "sample.ObjectView.model": (),
-    "sample.ObjectView.modifyModelData": ('sample.Str',),
-    "sample.ObjectView.setModel": ('sample.ObjectModel',),
-# class sample.OddBoolUser:
-    "sample.OddBoolUser.__init__": [(), ('bool',), ('sample.OddBoolUser',)],
-    "sample.OddBoolUser.__copy__": (),
-    "sample.OddBoolUser.callInvertedOddBool": (),
-    "sample.OddBoolUser.getOddBool": ('sample.OddBoolUser',),
-    "sample.OddBoolUser.invertedOddBool": (),
-    "sample.OddBoolUser.oddBool": (),
-    "sample.OddBoolUser.setOddBool": ('bool',),
-# class sample.OnlyCopy:
-    "sample.OnlyCopy.__init__": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.__copy__": (),
-    "sample.OnlyCopy.getValue": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.getValueFromReference": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.value": (),
-# class sample.OtherBase:
-    "sample.OtherBase.__init__": (),
-# class sample.Overload:
-# class sample.Overload.FunctionEnum:
-# class sample.Overload.ParamEnum:
-    "sample.Overload.__init__": (),
-    "sample.Overload.acceptSequence": [(), ('int',), ('int', 'int'), ('sample.Size',), ('sample.Str', 'sample.Overload.ParamEnum'), ('typing.Sequence',)],
-    "sample.Overload.differentReturnTypes": [('sample.Overload.ParamEnum',), ('sample.Overload.ParamEnum', 'int')],
-    "sample.Overload.drawText": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple', 'sample.Str')],
-    "sample.Overload.drawText2": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple', 'sample.Str')],
-    "sample.Overload.drawText3": [('int', 'int', 'int', 'int', 'int'), ('sample.Str', 'sample.Str', 'sample.Str')],
-    "sample.Overload.drawText4": [('int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "sample.Overload.intDoubleOverloads": [('float', 'float'), ('int', 'int')],
-    "sample.Overload.intOverloads": [('int', 'int'), ('int', 'int', 'float'), ('typing.Tuple', 'float')],
-    "sample.Overload.overloaded": [(), ('sample.Size',), ('typing.Tuple',), ('typing.Tuple', 'sample.Overload.ParamEnum')],
-    "sample.Overload.singleOverload": [(), ('typing.Tuple',)],
-    "sample.Overload.strBufferOverloads": [(), ('bytes', 'int'), ('sample.Str', 'bytes', 'bool'), ('sample.Str', 'int')],
-    "sample.Overload.wrapperIntIntOverloads": [('sample.Polygon', 'int', 'int'), ('typing.Tuple', 'int', 'int')],
-# class sample.Overload2:
-    "sample.Overload2.__init__": (),
-    "sample.Overload2.doNothingInPublic": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic2": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic3": [(), ('int',)],
-# class sample.OverloadedFuncEnum:
-# class sample.PairUser:
-    "sample.PairUser.__init__": [(), ('sample.PairUser',)],
-    "sample.PairUser.__copy__": (),
-    "sample.PairUser.callCreatePair": (),
-    "sample.PairUser.createComplexPair": ('complex', 'complex'),
-    "sample.PairUser.createPair": (),
-    "sample.PairUser.getPair": (),
-    "sample.PairUser.setPair": ('typing.Tuple',),
-    "sample.PairUser.sumPair": ('typing.Tuple',),
-# class sample.Pen:
-    "sample.Pen.__init__": [(), ('sample.Color',), ('sample.Pen',), ('sample.SampleNamespace.Option',)],
-    "sample.Pen.__copy__": (),
-    "sample.Pen.ctorType": (),
-# class sample.PersistentModelIndex:
-    "sample.PersistentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.PersistentModelIndex',)],
-    "sample.PersistentModelIndex.__copy__": (),
-    "sample.PersistentModelIndex.setValue": ('int',),
-    "sample.PersistentModelIndex.value": (),
-# class sample.Photon:
-# class sample.Photon.Base:
-    "sample.Photon.Base.__init__": [('int',), ('sample.Photon.Base',)],
-    "sample.Photon.Base.__copy__": (),
-    "sample.Photon.Base.isType": ('sample.Photon.ClassType',),
-    "sample.Photon.Base.setValue": ('int',),
-    "sample.Photon.Base.type": (),
-    "sample.Photon.Base.value": (),
-# class sample.Photon.ClassType:
-# class sample.Photon.ValueDuplicator:
-    "sample.Photon.ValueDuplicator.__init__": [('int',), ('sample.Photon.ValueDuplicator',)],
-    "sample.Photon.ValueDuplicator.__copy__": (),
-    "sample.Photon.ValueDuplicator.calculate": (),
-    "sample.Photon.ValueDuplicator.classType": (),
-    "sample.Photon.ValueDuplicator.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueDuplicator.multiplicator": (),
-    "sample.Photon.ValueDuplicator.passPointerThrough": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.type": (),
-# class sample.Photon.ValueIdentity:
-    "sample.Photon.ValueIdentity.__init__": [('int',), ('sample.Photon.ValueIdentity',)],
-    "sample.Photon.ValueIdentity.__copy__": (),
-    "sample.Photon.ValueIdentity.calculate": (),
-    "sample.Photon.ValueIdentity.classType": (),
-    "sample.Photon.ValueIdentity.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueIdentity.multiplicator": (),
-    "sample.Photon.ValueIdentity.passPointerThrough": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingPointer": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingReference": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.type": (),
-    "sample.Photon.callCalculateForValueDuplicatorPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.callCalculateForValueDuplicatorReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.countValueDuplicators": ('typing.List',),
-    "sample.Photon.countValueIdentities": ('typing.List',),
-# class sample.Point:
-    "sample.Point.__init__": [('float', 'float'), ('int', 'int'), ('typing.Tuple',)],
-    "sample.Point.__add__": ('typing.Tuple',),
-    "sample.Point.__copy__": (),
-    "sample.Point.__iadd__": ('typing.Tuple',),
-    "sample.Point.__isub__": ('typing.Tuple',),
-    "sample.Point.__mul__": [('float',), ('int',)],
-    "sample.Point.__neg__": (),
-    "sample.Point.__reduce__": (),
-    "sample.Point.__repr__": (),
-    "sample.Point.__str__": (),
-    "sample.Point.__sub__": [('str',), ('typing.Tuple',)],
-    "sample.Point.copy": (),
-    "sample.Point.getConstReferenceToSelf": (),
-    "sample.Point.getSelf": (),
-    "sample.Point.midpoint": ('typing.Tuple', 'typing.Tuple'),
-    "sample.Point.setX": ('float',),
-    "sample.Point.setXAsUint": ('int',),
-    "sample.Point.setY": ('float',),
-    "sample.Point.setYAsUint": ('int',),
-    "sample.Point.show": (),
-    "sample.Point.x": (),
-    "sample.Point.y": (),
-# class sample.PointF:
-    "sample.PointF.__init__": [('float', 'float'), ('sample.PointF',), ('typing.Tuple',)],
-    "sample.PointF.__add__": ('sample.PointF',),
-    "sample.PointF.__copy__": (),
-    "sample.PointF.__iadd__": ('sample.PointF',),
-    "sample.PointF.__isub__": ('sample.PointF',),
-    "sample.PointF.__mul__": [('float',), ('int',)],
-    "sample.PointF.__neg__": (),
-    "sample.PointF.__reduce__": (),
-    "sample.PointF.__repr__": (),
-    "sample.PointF.__str__": (),
-    "sample.PointF.__sub__": ('sample.PointF',),
-    "sample.PointF.midpoint": ('sample.PointF', 'sample.PointF'),
-    "sample.PointF.setX": ('float',),
-    "sample.PointF.setY": ('float',),
-    "sample.PointF.show": (),
-    "sample.PointF.x": (),
-    "sample.PointF.y": (),
-# class sample.PointValueList:
-# class sample.PointValueList.CtorEnum:
-    "sample.PointValueList.__init__": [(), ('sample.PointValueList',), ('typing.Sequence',), ('typing.Tuple',)],
-    "sample.PointValueList.__copy__": (),
-    "sample.PointValueList.append": ('typing.Tuple',),
-    "sample.PointValueList.constructorUsed": (),
-# class sample.PointerHolder:
-    "sample.PointerHolder.__init__": [('object',), ('sample.PointerHolder',)],
-    "sample.PointerHolder.__copy__": (),
-    "sample.PointerHolder.pointer": (),
-# class sample.Polygon:
-    "sample.Polygon.__init__": [(), ('float', 'float'), ('sample.Polygon',), ('typing.List',), ('typing.Tuple',)],
-    "sample.Polygon.__copy__": (),
-    "sample.Polygon.addPoint": ('typing.Tuple',),
-    "sample.Polygon.doublePolygonScale": ('sample.Polygon',),
-    "sample.Polygon.points": (),
-    "sample.Polygon.stealOwnershipFromPython": [('sample.Polygon',), ('typing.Tuple',)],
-# class sample.PrimitiveStructPointerHolder:
-    "sample.PrimitiveStructPointerHolder.__init__": [(), ('sample.PrimitiveStructPointerHolder',)],
-    "sample.PrimitiveStructPointerHolder.__copy__": (),
-# class sample.PrivateCtor:
-    "sample.PrivateCtor.instance": (),
-    "sample.PrivateCtor.instanceCalls": (),
-# class sample.PrivateDtor:
-    "sample.PrivateDtor.instance": (),
-    "sample.PrivateDtor.instanceCalls": (),
-    "sample.PrivateDtor.protectedInstanceCalls": (),
-# class sample.ProtectedEnumClass:
-# class sample.ProtectedEnumClass.ProtectedEnum:
-# class sample.ProtectedEnumClass.PublicEnum:
-    "sample.ProtectedEnumClass.__init__": (),
-    "sample.ProtectedEnumClass.callProtectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.callPublicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-    "sample.ProtectedEnumClass.protectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.publicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-# class sample.ProtectedNonPolymorphic:
-    "sample.ProtectedNonPolymorphic.__init__": [('bytes',), ('sample.ProtectedNonPolymorphic',)],
-    "sample.ProtectedNonPolymorphic.__copy__": (),
-    "sample.ProtectedNonPolymorphic.create": (),
-    "sample.ProtectedNonPolymorphic.dataTypeName": [('int',), ('object',)],
-    "sample.ProtectedNonPolymorphic.modifiedProtectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.protectedName": (),
-    "sample.ProtectedNonPolymorphic.protectedStatic": (),
-    "sample.ProtectedNonPolymorphic.protectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphic:
-    "sample.ProtectedPolymorphic.__init__": [('bytes',), ('sample.ProtectedPolymorphic',)],
-    "sample.ProtectedPolymorphic.__copy__": (),
-    "sample.ProtectedPolymorphic.callProtectedName": (),
-    "sample.ProtectedPolymorphic.create": (),
-    "sample.ProtectedPolymorphic.protectedName": (),
-    "sample.ProtectedPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphicDaughter:
-    "sample.ProtectedPolymorphicDaughter.__init__": [('bytes',), ('sample.ProtectedPolymorphicDaughter',)],
-    "sample.ProtectedPolymorphicDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicDaughter.create": (),
-# class sample.ProtectedPolymorphicGrandDaughter:
-    "sample.ProtectedPolymorphicGrandDaughter.__init__": [('bytes',), ('sample.ProtectedPolymorphicGrandDaughter',)],
-    "sample.ProtectedPolymorphicGrandDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicGrandDaughter.create": (),
-# class sample.ProtectedProperty:
-    "sample.ProtectedProperty.__init__": [(), ('sample.ProtectedProperty',)],
-    "sample.ProtectedProperty.__copy__": (),
-# class sample.ProtectedVirtualDestructor:
-    "sample.ProtectedVirtualDestructor.__init__": (),
-    "sample.ProtectedVirtualDestructor.create": (),
-    "sample.ProtectedVirtualDestructor.dtorCalled": (),
-    "sample.ProtectedVirtualDestructor.resetDtorCounter": (),
-# class sample.Rect:
-    "sample.Rect.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',)],
-    "sample.Rect.__copy__": (),
-    "sample.Rect.bottom": (),
-    "sample.Rect.left": (),
-    "sample.Rect.right": (),
-    "sample.Rect.top": (),
-# class sample.RectF:
-    "sample.RectF.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',), ('sample.RectF',)],
-    "sample.RectF.__copy__": (),
-    "sample.RectF.bottom": (),
-    "sample.RectF.left": (),
-    "sample.RectF.right": (),
-    "sample.RectF.top": (),
-# class sample.Reference:
-    "sample.Reference.__init__": [('int',), ('sample.Reference',)],
-    "sample.Reference.__copy__": (),
-    "sample.Reference.alterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callAlterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callUsesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.callUsesReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.multiplier": (),
-    "sample.Reference.objId": (),
-    "sample.Reference.returnMyFirstArg": ('sample.Reference',),
-    "sample.Reference.returnMySecondArg": ('int', 'sample.Reference'),
-    "sample.Reference.setObjId": ('int',),
-    "sample.Reference.show": (),
-    "sample.Reference.usesConstReference": ('sample.Reference',),
-    "sample.Reference.usesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.usesReference": ('sample.Reference',),
-    "sample.Reference.usesReferenceVirtual": ('sample.Reference', 'int'),
-# class sample.ReferentModelIndex:
-    "sample.ReferentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.ReferentModelIndex',)],
-    "sample.ReferentModelIndex.__copy__": (),
-    "sample.ReferentModelIndex.setValue": ('int',),
-    "sample.ReferentModelIndex.value": (),
-# class sample.RemovedNamespace1_Enum:
-# class sample.RemovedNamespace2_Enum:
-# class sample.SampleNamespace:
-# class sample.SampleNamespace.DerivedFromNamespace:
-    "sample.SampleNamespace.DerivedFromNamespace.__init__": (),
-    "sample.SampleNamespace.DerivedFromNamespace.methodReturningTypeFromParentScope": (),
-    "sample.SampleNamespace.DerivedFromNamespace.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.InValue:
-# class sample.SampleNamespace.Option:
-# class sample.SampleNamespace.OutValue:
-# class sample.SampleNamespace.SomeClass:
-# class sample.SampleNamespace.SomeClass.ProtectedEnum:
-# class sample.SampleNamespace.SomeClass.PublicScopedEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnumClass:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.__init__": (),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass',),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__copy__": (),
-# class sample.SampleNamespace.SomeClass.SomeOtherInnerClass:
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeOtherInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.__init__": [(), ('sample.SampleNamespace.SomeClass',)],
-    "sample.SampleNamespace.SomeClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.protectedMethodReturningPublicScopedEnum": (),
-    "sample.SampleNamespace.ImInsideANamespace": ('int', 'int'),
-    "sample.SampleNamespace.doSomethingWithArray": ('bytes', 'int', 'bytes'),
-    "sample.SampleNamespace.enumArgumentWithDefaultValue": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.enumInEnumOut": ('sample.SampleNamespace.InValue',),
-    "sample.SampleNamespace.enumItemAsDefaultValueToIntArgument": ('int',),
-    "sample.SampleNamespace.forceDecisorSideA": [('object',), ('typing.Tuple', 'sample.Str', 'object')],
-    "sample.SampleNamespace.forceDecisorSideB": [('int', 'object'), ('int', 'typing.Tuple', 'sample.Str', 'object')],
-    "sample.SampleNamespace.getNumber": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.passReferenceToObjectType": [('object',), ('object', 'int')],
-    "sample.SampleNamespace.passReferenceToValueType": [('typing.Tuple',), ('typing.Tuple', 'float')],
-    "sample.SampleNamespace.powerOfTwo": ('float',),
-# class sample.SbkDate:
-    "sample.SbkDate.__init__": [('int', 'int', 'int'), ('sample.SbkDate',)],
-    "sample.SbkDate.__copy__": (),
-    "sample.SbkDate.day": (),
-    "sample.SbkDate.month": (),
-    "sample.SbkDate.toPython": (),
-    "sample.SbkDate.year": (),
-# class sample.SimpleFile:
-    "sample.SimpleFile.__init__": [('bytes',), ('sample.SimpleFile',)],
-    "sample.SimpleFile.__copy__": (),
-    "sample.SimpleFile.close": (),
-    "sample.SimpleFile.exists": [(), ('bytes',)],
-    "sample.SimpleFile.filename": (),
-    "sample.SimpleFile.open": (),
-    "sample.SimpleFile.size": (),
-# class sample.Size:
-    "sample.Size.__init__": [('bytes',), ('float', 'float'), ('sample.Size',)],
-    "sample.Size.__add__": ('sample.Size',),
-    "sample.Size.__copy__": (),
-    "sample.Size.__iadd__": ('sample.Size',),
-    "sample.Size.__imul__": ('float',),
-    "sample.Size.__isub__": ('sample.Size',),
-    "sample.Size.__mul__": ('float',),
-    "sample.Size.__sub__": ('sample.Size',),
-    "sample.Size.calculateArea": (),
-    "sample.Size.height": (),
-    "sample.Size.setHeight": ('float',),
-    "sample.Size.setWidth": ('float',),
-    "sample.Size.show": (),
-    "sample.Size.width": (),
-# class sample.SizeF:
-    "sample.SizeF.__init__": [('float', 'float'), ('sample.SizeF',)],
-    "sample.SizeF.__copy__": (),
-    "sample.SizeF.height": (),
-    "sample.SizeF.passTypedefOfUnsignedShort": ('int',),
-    "sample.SizeF.width": (),
-# class sample.SonOfMDerived1:
-    "sample.SonOfMDerived1.__init__": (),
-    "sample.SonOfMDerived1.castToMDerived1": (),
-    "sample.SonOfMDerived1.sonOfMDerived1Method": (),
-# class sample.SortedOverload:
-    "sample.SortedOverload.__init__": [(), ('sample.SortedOverload',)],
-    "sample.SortedOverload.__copy__": (),
-    "sample.SortedOverload.implicit_overload": ('sample.ImplicitBase',),
-    "sample.SortedOverload.overload": [('float',), ('int',), ('object',), ('sample.ImplicitBase',), ('sample.ImplicitTarget',), ('typing.List',)],
-    "sample.SortedOverload.overloadDeep": [('int', 'object'), ('int', 'sample.ImplicitBase')],
-    "sample.SortedOverload.pyObjOverload": [('bytes', 'int'), ('int', 'int')],
-# class sample.Str:
-    "sample.Str.__init__": [('bytes',), ('int',), ('sample.Str',)],
-    "sample.Str.__add__": ('int',),
-    "sample.Str.__copy__": (),
-    "sample.Str.__str__": (),
-    "sample.Str.append": ('sample.Str',),
-    "sample.Str.arg": ('sample.Str',),
-    "sample.Str.cstring": (),
-    "sample.Str.get_char": ('int',),
-    "sample.Str.prepend": ('sample.Str',),
-    "sample.Str.set_char": ('int', 'int'),
-    "sample.Str.show": (),
-    "sample.Str.size": (),
-    "sample.Str.toInt": ('int',),
-# class sample.StrList:
-# class sample.StrList.CtorEnum:
-    "sample.StrList.__init__": [(), ('sample.Str',), ('sample.StrList',), ('typing.List',)],
-    "sample.StrList.__copy__": (),
-    "sample.StrList.append": ('sample.Str',),
-    "sample.StrList.constructorUsed": (),
-    "sample.StrList.join": ('sample.Str',),
-# class sample.TemplatePtr:
-    "sample.TemplatePtr.__init__": (),
-    "sample.TemplatePtr.dummy_method": ('typing.List',),
-# class sample.Time:
-# class sample.Time.NumArgs:
-    "sample.Time.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Time',)],
-    "sample.Time.__copy__": (),
-    "sample.Time.hour": (),
-    "sample.Time.isNull": (),
-    "sample.Time.minute": (),
-    "sample.Time.msec": (),
-    "sample.Time.second": (),
-    "sample.Time.setTime": [(), ('int', 'int', 'int', 'int')],
-    "sample.Time.somethingCompletelyDifferent": [(), ('int', 'int', 'sample.ImplicitConv', 'object')],
-    "sample.Time.toString": (),
-# class sample.Union:
-    "sample.Union.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Union.__and__": ('sample.Data',),
-    "sample.Union.__copy__": (),
-    "sample.Union.addFilter": ('sample.Filter',),
-    "sample.Union.filters": (),
-# class sample.UnremovedNamespace:
-# class sample.UnremovedNamespace.RemovedNamespace3_Enum:
-# class sample.ValueAndVirtual:
-    "sample.ValueAndVirtual.__init__": [('int',), ('sample.ValueAndVirtual',)],
-    "sample.ValueAndVirtual.__call__": ('int', 'int'),
-    "sample.ValueAndVirtual.__copy__": (),
-    "sample.ValueAndVirtual.id": (),
-# class sample.VirtualDaughter:
-    "sample.VirtualDaughter.__init__": [(), ('sample.Str',), ('sample.VirtualDaughter',)],
-    "sample.VirtualDaughter.__copy__": (),
-# class sample.VirtualDaughter2:
-    "sample.VirtualDaughter2.__init__": (),
-    "sample.VirtualDaughter2.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualDaughter2.virtualMethod0": ('typing.Tuple', 'int', 'complex', 'bool'),
-# class sample.VirtualDtor:
-    "sample.VirtualDtor.__init__": [(), ('sample.VirtualDtor',)],
-    "sample.VirtualDtor.__copy__": (),
-    "sample.VirtualDtor.create": (),
-    "sample.VirtualDtor.dtorCalled": (),
-    "sample.VirtualDtor.resetDtorCounter": (),
-# class sample.VirtualFinalDaughter:
-    "sample.VirtualFinalDaughter.__init__": (),
-    "sample.VirtualFinalDaughter.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualFinalDaughter.virtualMethod0": ('typing.Tuple', 'int', 'complex', 'bool'),
-# class sample.VirtualMethods:
-    "sample.VirtualMethods.__init__": [('sample.Str',), ('sample.VirtualMethods',)],
-    "sample.VirtualMethods.__copy__": (),
-    "sample.VirtualMethods.callCallMe": (),
-    "sample.VirtualMethods.callCreateStr": ('bytes', 'sample.Str'),
-    "sample.VirtualMethods.callGetMargins": (),
-    "sample.VirtualMethods.callMe": (),
-    "sample.VirtualMethods.callName": (),
-    "sample.VirtualMethods.callRecursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.callStrListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.callSum0": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callVirtualMethod0": ('typing.Tuple', 'int', 'complex', 'bool'),
-    "sample.VirtualMethods.createStr": ('bytes', 'sample.Str'),
-    "sample.VirtualMethods.getMargins": (),
-    "sample.VirtualMethods.name": (),
-    "sample.VirtualMethods.recursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.setMargins": ('int', 'int', 'int', 'int'),
-    "sample.VirtualMethods.strListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.sum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualMethods.virtualMethod0": ('typing.Tuple', 'int', 'complex', 'bool'),
-# class sample.VoidHolder:
-    "sample.VoidHolder.__init__": [('int',), ('sample.VoidHolder',)],
-    "sample.VoidHolder.__copy__": (),
-    "sample.VoidHolder.gimmeMeSomeVoidPointer": (),
-    "sample.VoidHolder.takeVoidPointer": ('int',),
-    "sample.VoidHolder.voidPointer": (),
-# class sample.sample:
-# class sample.sample.sample:
-    "sample.sample.sample.__init__": [('int',), ('sample.sample.sample',)],
-    "sample.sample.sample.__copy__": (),
-    "sample.sample.sample.value": (),
-    "sample.sample.acceptDouble": ('float',),
-    "sample.sample.acceptInt": ('int',),
-    "sample.sample.acceptIntReference": ('int',),
-    "sample.sample.acceptLong": ('int',),
-    "sample.sample.acceptOddBoolReference": ('bool',),
-    "sample.sample.acceptUInt": ('int',),
-    "sample.sample.acceptULong": ('int',),
-    "sample.sample.applyHomogeneousTransform": ('typing.Tuple', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "sample.sample.cacheSize": (),
-    "sample.sample.changePStr": ('bytes',),
-    "sample.sample.convertIntegersToCppAndThenToPython": ('int', 'int'),
-    "sample.sample.convertListOfIntegersToCppAndThenToPython": ('typing.List',),
-    "sample.sample.convertObjectTypeToCppAndThenToPython": ('object', 'object'),
-    "sample.sample.convertValueTypeToCppAndThenToPython": ('typing.Tuple', 'typing.Tuple', 'typing.Tuple'),
-    "sample.sample.countCharacters": ('bytes',),
-    "sample.sample.countVarargs": ('int', 'None'),
-    "sample.sample.cppTypeIsObjectType": ('bytes',),
-    "sample.sample.cppTypeIsValueType": ('bytes',),
-    "sample.sample.createListOfPStr": ('str', 'str'),
-    "sample.sample.createPStrList": ('str', 'str'),
-    "sample.sample.createProtectedProperty": (),
-    "sample.sample.doubleLongLong": ('int',),
-    "sample.sample.doubleShort": ('int',),
-    "sample.sample.doubleUnsignedInt": ('int',),
-    "sample.sample.doubleUnsignedLongLong": ('int',),
-    "sample.sample.duplicatePStr": (),
-    "sample.sample.getConversionTypeString": ('bytes',),
-    "sample.sample.getPythonType": ('bytes',),
-    "sample.sample.gimmeComplexList": (),
-    "sample.sample.gimmeDouble": (),
-    "sample.sample.gimmeInt": (),
-    "sample.sample.makeCString": (),
-    "sample.sample.multiplyPair": ('typing.Tuple',),
-    "sample.sample.multiplyString": ('str', 'int'),
-    "sample.sample.overloadedFunc": [('float',), ('int',)],
-    "sample.sample.returnCString": (),
-    "sample.sample.returnNullObjectTypePointer": (),
-    "sample.sample.returnNullPrimitivePointer": (),
-    "sample.sample.returnNullValueTypePointer": (),
-    "sample.sample.sum2d": ('typing.List',),
-    "sample.sample.sumComplexPair": ('typing.Tuple',),
-    "sample.sample.sumDoubleArray": ('typing.Tuple',),
-    "sample.sample.sumDoubleMatrix": ('typing.Tuple',),
-    "sample.sample.sumIntArray": ('typing.Tuple',),
-    "sample.sample.sumIntMatrix": ('typing.Tuple',),
-    "sample.sample.sumproduct": ('typing.List',),
-    "sample.sample.transmuteComplexIntoPoint": ('complex',),
-    "sample.sample.transmutePointIntoComplex": ('typing.Tuple',),
-    }) if "sample" in sys.modules else None
-# Module other
-sig_dict.update({
-# class other.ExtendsNoImplicitConversion:
-    "other.ExtendsNoImplicitConversion.__init__": [('Missing("other.ExtendsNoImplicitConversion")',), ('int',)],
-    "other.ExtendsNoImplicitConversion.__copy__": (),
-    "other.ExtendsNoImplicitConversion.objId": (),
-# class other.Number:
-    "other.Number.__init__": [('int',), ('numbers.Number',)],
-    "other.Number.__copy__": (),
-    "other.Number.__mul__": ('typing.Tuple',),
-    "other.Number.fromComplex": ('complex',),
-    "other.Number.toComplex": (),
-    "other.Number.toStr": (),
-    "other.Number.value": (),
-# class other.OtherDerived:
-    "other.OtherDerived.__init__": ('int',),
-    "other.OtherDerived.className": (),
-    "other.OtherDerived.createObject": (),
-    "other.OtherDerived.getClassName": (),
-    "other.OtherDerived.pureVirtual": (),
-    "other.OtherDerived.pureVirtualReturningVoidPtr": (),
-    "other.OtherDerived.returnAnEnum": (),
-    "other.OtherDerived.unpureVirtual": (),
-    "other.OtherDerived.useEnumTypeFromOtherModule": ('sample.OverloadedFuncEnum',),
-    "other.OtherDerived.useObjectTypeFromOtherModule": ('object',),
-    "other.OtherDerived.useValueTypeFromOtherModule": [('complex',), ('sample.Event',)],
-# class other.OtherMultipleDerived:
-    "other.OtherMultipleDerived.__init__": (),
-    "other.OtherMultipleDerived.createObject": ('str',),
-    "other.OtherMultipleDerived.returnUselessClass": (),
-# class other.OtherObjectType:
-    "other.OtherObjectType.__init__": (),
-    "other.OtherObjectType.__lshift__": ('sample.Collector',),
-    }) if "other" in sys.modules else None
-# Module smart
-sig_dict.update({
-# class smart.Integer:
-    "smart.Integer.__init__": [(), ('smart.Integer',)],
-    "smart.Integer.__copy__": (),
-    "smart.Integer.printInteger": (),
-# class smart.Integer2:
-    "smart.Integer2.__init__": [(), ('int',)],
-    "smart.Integer2.__copy__": (),
-# class smart.Obj:
-    "smart.Obj.__init__": (),
-    "smart.Obj.giveSharedPtrToInteger": (),
-    "smart.Obj.giveSharedPtrToInteger2": (),
-    "smart.Obj.giveSharedPtrToObj": (),
-    "smart.Obj.giveSharedPtrToObjList": ('int',),
-    "smart.Obj.printObj": (),
-    "smart.Obj.takeInteger": ('smart.Integer',),
-    "smart.Obj.takeSharedPtrToInteger": ('smart.SharedPtr',),
-    "smart.Obj.takeSharedPtrToObj": ('smart.SharedPtr',),
-# class smart.Registry:
-    "smart.Registry.__init__": (),
-    "smart.Registry.add": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.countIntegers": (),
-    "smart.Registry.countObjects": (),
-    "smart.Registry.getInstance": (),
-    "smart.Registry.remove": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.setShouldPrint": ('bool',),
-    "smart.Registry.shouldPrint": (),
-# class smart.SharedPtr:
-# class smart.SharedPtr.__next_in_mro__:
-# class smart.SharedPtr<Integer >:
-    "smart.SharedPtr<Integer >.__copy__": (),
-    "smart.SharedPtr<Integer >.data": (),
-    "smart.SharedPtr<Integer >.useCount": (),
-# class smart.SharedPtr<Obj >:
-    "smart.SharedPtr<Obj >.__copy__": (),
-    "smart.SharedPtr<Obj >.data": (),
-    "smart.SharedPtr<Obj >.useCount": (),
-# class smart.SharedPtr<Smart::Integer2 >:
-    "smart.SharedPtr<Smart::Integer2 >.__copy__": (),
-    "smart.SharedPtr<Smart::Integer2 >.data": (),
-    "smart.SharedPtr<Smart::Integer2 >.useCount": (),
-    }) if "smart" in sys.modules else None
-# eof
diff --git a/sources/pyside6/tests/registry/exists_x86_64_suse_linux_5_14_2_ci.py b/sources/pyside6/tests/registry/exists_x86_64_suse_linux_5_14_2_ci.py
deleted file mode 100644
index 8cf131384..000000000
--- a/sources/pyside6/tests/registry/exists_x86_64_suse_linux_5_14_2_ci.py
+++ /dev/null
@@ -1,37712 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
-"""
-This file contains the simplified signatures for all functions in PySide
-for module 'exists_x86_64_suse_linux_5_14_2_ci' using
-Python 2.7.14 (default, Oct 12 2017, 15:50:02) [GCC]
-Qt 5.14.2 (x86_64-little_endian-lp64 shared (dynamic) debug build; by GCC 7.4.1 20190905 [gcc-7-branch revision 275407])
-There are no default values, no variable names and no self
-parameter. Only types are present after simplification. The
-functions 'next' resp. '__next__' are removed to make the output
-identical for Python 2 and 3. '__div__' is also removed,
-since it exists in Python 2, only.
-"""
-import sys
-sig_dict = {}
-# Module PySide2.QtCore
-sig_dict.update({
-# class PySide2.QtCore.ClassInfo:
-    "PySide2.QtCore.ClassInfo.__init__": ('typing.Dict[str, str]',),
-# class PySide2.QtCore.MetaFunction:
-    "PySide2.QtCore.MetaFunction.__call__": ('typing.Any',),
-# class PySide2.QtCore.MetaSignal:
-    "PySide2.QtCore.MetaSignal.__instancecheck__": ('object',),
-# class PySide2.QtCore.Property:
-    "PySide2.QtCore.Property.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'str', 'typing.Callable', 'bool', 'bool', 'bool', 'bool', 'bool', 'bool'),
-    "PySide2.QtCore.Property.getter": ('typing.Callable',),
-    "PySide2.QtCore.Property.read": ('typing.Callable',),
-    "PySide2.QtCore.Property.setter": ('typing.Callable',),
-    "PySide2.QtCore.Property.write": ('typing.Callable',),
-# class PySide2.QtCore.QAbstractAnimation:
-# class PySide2.QtCore.QAbstractAnimation.DeletionPolicy:
-# class PySide2.QtCore.QAbstractAnimation.Direction:
-# class PySide2.QtCore.QAbstractAnimation.State:
-    "PySide2.QtCore.QAbstractAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractAnimation.currentLoop": (),
-    "PySide2.QtCore.QAbstractAnimation.currentLoopTime": (),
-    "PySide2.QtCore.QAbstractAnimation.currentTime": (),
-    "PySide2.QtCore.QAbstractAnimation.direction": (),
-    "PySide2.QtCore.QAbstractAnimation.duration": (),
-    "PySide2.QtCore.QAbstractAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractAnimation.group": (),
-    "PySide2.QtCore.QAbstractAnimation.loopCount": (),
-    "PySide2.QtCore.QAbstractAnimation.pause": (),
-    "PySide2.QtCore.QAbstractAnimation.resume": (),
-    "PySide2.QtCore.QAbstractAnimation.setCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.setLoopCount": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.setPaused": ('bool',),
-    "PySide2.QtCore.QAbstractAnimation.start": ('PySide2.QtCore.QAbstractAnimation.DeletionPolicy',),
-    "PySide2.QtCore.QAbstractAnimation.state": (),
-    "PySide2.QtCore.QAbstractAnimation.stop": (),
-    "PySide2.QtCore.QAbstractAnimation.totalDuration": (),
-    "PySide2.QtCore.QAbstractAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QAbstractAnimation.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QAbstractAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QAbstractEventDispatcher:
-# class PySide2.QtCore.QAbstractEventDispatcher.TimerInfo:
-    "PySide2.QtCore.QAbstractEventDispatcher.TimerInfo.__init__": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QAbstractEventDispatcher.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.closingDown": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.filterNativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QAbstractEventDispatcher.flush": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.hasPendingEvents": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.instance": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QAbstractEventDispatcher.interrupt": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.processEvents": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.registerTimer": [('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject'), ('int', 'int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QAbstractEventDispatcher.registeredTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.remainingTime": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QAbstractEventDispatcher.startingUp": (),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterSocketNotifier": ('PySide2.QtCore.QSocketNotifier',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimer": ('int',),
-    "PySide2.QtCore.QAbstractEventDispatcher.unregisterTimers": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractEventDispatcher.wakeUp": (),
-# class PySide2.QtCore.QAbstractItemModel:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOption:
-# class PySide2.QtCore.QAbstractItemModel.CheckIndexOptions:
-# class PySide2.QtCore.QAbstractItemModel.LayoutChangeHint:
-    "PySide2.QtCore.QAbstractItemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginMoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.beginResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.changePersistentIndexList": ('typing.List[int]', 'typing.List[int]'),
-    "PySide2.QtCore.QAbstractItemModel.checkIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QAbstractItemModel.CheckIndexOptions'),
-    "PySide2.QtCore.QAbstractItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object')],
-    "PySide2.QtCore.QAbstractItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.decodeData": ('int', 'int', 'PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.encodeData": ('typing.List[int]', 'PySide2.QtCore.QDataStream'),
-    "PySide2.QtCore.QAbstractItemModel.endInsertColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endInsertRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endMoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveColumns": (),
-    "PySide2.QtCore.QAbstractItemModel.endRemoveRows": (),
-    "PySide2.QtCore.QAbstractItemModel.endResetModel": (),
-    "PySide2.QtCore.QAbstractItemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.hasIndex": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QAbstractItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractItemModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractItemModel.moveColumn": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRow": ('PySide2.QtCore.QModelIndex', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractItemModel.persistentIndexList": (),
-    "PySide2.QtCore.QAbstractItemModel.removeColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractItemModel.revert": (),
-    "PySide2.QtCore.QAbstractItemModel.roleNames": (),
-    "PySide2.QtCore.QAbstractItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractItemModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractItemModel.submit": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractItemModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractListModel:
-    "PySide2.QtCore.QAbstractListModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractListModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractListModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractListModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractNativeEventFilter:
-    "PySide2.QtCore.QAbstractNativeEventFilter.__init__": (),
-    "PySide2.QtCore.QAbstractNativeEventFilter.nativeEventFilter": ('PySide2.QtCore.QByteArray', 'int'),
-# class PySide2.QtCore.QAbstractProxyModel:
-    "PySide2.QtCore.QAbstractProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QAbstractProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QAbstractProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QAbstractProxyModel.resetInternalData": (),
-    "PySide2.QtCore.QAbstractProxyModel.revert": (),
-    "PySide2.QtCore.QAbstractProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QAbstractProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QAbstractProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QAbstractProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QAbstractProxyModel.sourceModel": (),
-    "PySide2.QtCore.QAbstractProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractProxyModel.submit": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDragActions": (),
-    "PySide2.QtCore.QAbstractProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QAbstractState:
-    "PySide2.QtCore.QAbstractState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractState.active": (),
-    "PySide2.QtCore.QAbstractState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.machine": (),
-    "PySide2.QtCore.QAbstractState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractState.parentState": (),
-# class PySide2.QtCore.QAbstractTableModel:
-    "PySide2.QtCore.QAbstractTableModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAbstractTableModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QAbstractTableModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QAbstractTableModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QAbstractTableModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QAbstractTransition:
-# class PySide2.QtCore.QAbstractTransition.TransitionType:
-    "PySide2.QtCore.QAbstractTransition.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QAbstractTransition.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.animations": (),
-    "PySide2.QtCore.QAbstractTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.machine": (),
-    "PySide2.QtCore.QAbstractTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAbstractTransition.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAbstractTransition.setTargetState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QAbstractTransition.setTargetStates": ('typing.Sequence[PySide2.QtCore.QAbstractState]',),
-    "PySide2.QtCore.QAbstractTransition.setTransitionType": ('PySide2.QtCore.QAbstractTransition.TransitionType',),
-    "PySide2.QtCore.QAbstractTransition.sourceState": (),
-    "PySide2.QtCore.QAbstractTransition.targetState": (),
-    "PySide2.QtCore.QAbstractTransition.targetStates": (),
-    "PySide2.QtCore.QAbstractTransition.transitionType": (),
-# class PySide2.QtCore.QAnimationGroup:
-    "PySide2.QtCore.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QAnimationGroup.addAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.animationAt": ('int',),
-    "PySide2.QtCore.QAnimationGroup.animationCount": (),
-    "PySide2.QtCore.QAnimationGroup.clear": (),
-    "PySide2.QtCore.QAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QAnimationGroup.indexOfAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.insertAnimation": ('int', 'PySide2.QtCore.QAbstractAnimation'),
-    "PySide2.QtCore.QAnimationGroup.removeAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QAnimationGroup.takeAnimation": ('int',),
-# class PySide2.QtCore.QBasicMutex:
-    "PySide2.QtCore.QBasicMutex.__init__": (),
-    "PySide2.QtCore.QBasicMutex.isRecursive": (),
-    "PySide2.QtCore.QBasicMutex.lock": (),
-    "PySide2.QtCore.QBasicMutex.tryLock": (),
-    "PySide2.QtCore.QBasicMutex.try_lock": (),
-    "PySide2.QtCore.QBasicMutex.unlock": (),
-# class PySide2.QtCore.QBasicTimer:
-    "PySide2.QtCore.QBasicTimer.__init__": [(), ('PySide2.QtCore.QBasicTimer',)],
-    "PySide2.QtCore.QBasicTimer.__copy__": (),
-    "PySide2.QtCore.QBasicTimer.isActive": (),
-    "PySide2.QtCore.QBasicTimer.start": [('int', 'PySide2.QtCore.QObject'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QBasicTimer.stop": (),
-    "PySide2.QtCore.QBasicTimer.swap": ('PySide2.QtCore.QBasicTimer',),
-    "PySide2.QtCore.QBasicTimer.timerId": (),
-# class PySide2.QtCore.QBitArray:
-    "PySide2.QtCore.QBitArray.__init__": [(), ('PySide2.QtCore.QBitArray',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.__and__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__copy__": (),
-    "PySide2.QtCore.QBitArray.__iand__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__invert__": (),
-    "PySide2.QtCore.QBitArray.__ior__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__ixor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__or__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.__xor__": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.at": ('int',),
-    "PySide2.QtCore.QBitArray.bits": (),
-    "PySide2.QtCore.QBitArray.clear": (),
-    "PySide2.QtCore.QBitArray.clearBit": ('int',),
-    "PySide2.QtCore.QBitArray.count": [(), ('bool',)],
-    "PySide2.QtCore.QBitArray.fill": [('bool', 'int'), ('bool', 'int', 'int')],
-    "PySide2.QtCore.QBitArray.fromBits": ('str', 'int'),
-    "PySide2.QtCore.QBitArray.isEmpty": (),
-    "PySide2.QtCore.QBitArray.isNull": (),
-    "PySide2.QtCore.QBitArray.resize": ('int',),
-    "PySide2.QtCore.QBitArray.setBit": [('int',), ('int', 'bool')],
-    "PySide2.QtCore.QBitArray.size": (),
-    "PySide2.QtCore.QBitArray.swap": ('PySide2.QtCore.QBitArray',),
-    "PySide2.QtCore.QBitArray.testBit": ('int',),
-    "PySide2.QtCore.QBitArray.toggleBit": ('int',),
-    "PySide2.QtCore.QBitArray.truncate": ('int',),
-# class PySide2.QtCore.QBuffer:
-    "PySide2.QtCore.QBuffer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QBuffer.atEnd": (),
-    "PySide2.QtCore.QBuffer.buffer": (),
-    "PySide2.QtCore.QBuffer.canReadLine": (),
-    "PySide2.QtCore.QBuffer.close": (),
-    "PySide2.QtCore.QBuffer.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.data": (),
-    "PySide2.QtCore.QBuffer.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QBuffer.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QBuffer.pos": (),
-    "PySide2.QtCore.QBuffer.readData": ('str', 'int'),
-    "PySide2.QtCore.QBuffer.seek": ('int',),
-    "PySide2.QtCore.QBuffer.setBuffer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QBuffer.size": (),
-    "PySide2.QtCore.QBuffer.writeData": ('str', 'int'),
-# class PySide2.QtCore.QByteArray:
-# class PySide2.QtCore.QByteArray.Base64Option:
-# class PySide2.QtCore.QByteArray.Base64Options:
-    "PySide2.QtCore.QByteArray.__init__": [(), ('PySide2.QtCore.QByteArray',), ('bytearray',), ('int', 'int'), ('str',)],
-    "PySide2.QtCore.QByteArray.__add__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',), ('str',)],
-    "PySide2.QtCore.QByteArray.__copy__": (),
-    "PySide2.QtCore.QByteArray.__iadd__": [('PySide2.QtCore.QByteArray',), ('bytearray',), ('int',)],
-    "PySide2.QtCore.QByteArray.__reduce__": (),
-    "PySide2.QtCore.QByteArray.__repr__": (),
-    "PySide2.QtCore.QByteArray.__str__": (),
-    "PySide2.QtCore.QByteArray.append": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.at": ('int',),
-    "PySide2.QtCore.QByteArray.back": (),
-    "PySide2.QtCore.QByteArray.capacity": (),
-    "PySide2.QtCore.QByteArray.cbegin": (),
-    "PySide2.QtCore.QByteArray.cend": (),
-    "PySide2.QtCore.QByteArray.chop": ('int',),
-    "PySide2.QtCore.QByteArray.chopped": ('int',),
-    "PySide2.QtCore.QByteArray.clear": (),
-    "PySide2.QtCore.QByteArray.compare": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.Qt.CaseSensitivity'), ('str', 'PySide2.QtCore.Qt.CaseSensitivity')],
-    "PySide2.QtCore.QByteArray.contains": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.count": [(), ('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.data": (),
-    "PySide2.QtCore.QByteArray.endsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.fill": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.fromBase64": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray.Base64Options')],
-    "PySide2.QtCore.QByteArray.fromHex": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.fromPercentEncoding": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.fromRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.front": (),
-    "PySide2.QtCore.QByteArray.indexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.insert": [('int', 'PySide2.QtCore.QByteArray'), ('int', 'int', 'int')],
-    "PySide2.QtCore.QByteArray.isEmpty": (),
-    "PySide2.QtCore.QByteArray.isLower": (),
-    "PySide2.QtCore.QByteArray.isNull": (),
-    "PySide2.QtCore.QByteArray.isSharedWith": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.isUpper": (),
-    "PySide2.QtCore.QByteArray.lastIndexOf": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.left": ('int',),
-    "PySide2.QtCore.QByteArray.leftJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.length": (),
-    "PySide2.QtCore.QByteArray.mid": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.number": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.prepend": [('PySide2.QtCore.QByteArray',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.remove": ('int', 'int'),
-    "PySide2.QtCore.QByteArray.repeated": ('int',),
-    "PySide2.QtCore.QByteArray.replace": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('int', 'PySide2.QtCore.QByteArray'), ('int', 'int'), ('int', 'int', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtCore.QByteArray.reserve": ('int',),
-    "PySide2.QtCore.QByteArray.resize": ('int',),
-    "PySide2.QtCore.QByteArray.right": ('int',),
-    "PySide2.QtCore.QByteArray.rightJustified": ('int', 'int', 'bool'),
-    "PySide2.QtCore.QByteArray.setNum": [('float', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtCore.QByteArray.setRawData": ('str', 'int'),
-    "PySide2.QtCore.QByteArray.shrink_to_fit": (),
-    "PySide2.QtCore.QByteArray.simplified": (),
-    "PySide2.QtCore.QByteArray.size": (),
-    "PySide2.QtCore.QByteArray.split": ('int',),
-    "PySide2.QtCore.QByteArray.squeeze": (),
-    "PySide2.QtCore.QByteArray.startsWith": [('PySide2.QtCore.QByteArray',), ('int',)],
-    "PySide2.QtCore.QByteArray.swap": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QByteArray.toBase64": [(), ('PySide2.QtCore.QByteArray.Base64Options',)],
-    "PySide2.QtCore.QByteArray.toDouble": (),
-    "PySide2.QtCore.QByteArray.toFloat": (),
-    "PySide2.QtCore.QByteArray.toHex": [(), ('int',)],
-    "PySide2.QtCore.QByteArray.toInt": ('int',),
-    "PySide2.QtCore.QByteArray.toLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toLower": (),
-    "PySide2.QtCore.QByteArray.toPercentEncoding": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtCore.QByteArray.toShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUInt": ('int',),
-    "PySide2.QtCore.QByteArray.toULong": ('int',),
-    "PySide2.QtCore.QByteArray.toULongLong": ('int',),
-    "PySide2.QtCore.QByteArray.toUShort": ('int',),
-    "PySide2.QtCore.QByteArray.toUpper": (),
-    "PySide2.QtCore.QByteArray.trimmed": (),
-    "PySide2.QtCore.QByteArray.truncate": ('int',),
-# class PySide2.QtCore.QByteArrayMatcher:
-    "PySide2.QtCore.QByteArrayMatcher.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArrayMatcher',), ('str', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.__copy__": (),
-    "PySide2.QtCore.QByteArrayMatcher.indexIn": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.QByteArrayMatcher.pattern": (),
-    "PySide2.QtCore.QByteArrayMatcher.setPattern": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QCalendar:
-# class PySide2.QtCore.QCalendar.System:
-# class PySide2.QtCore.QCalendar.YearMonthDay:
-    "PySide2.QtCore.QCalendar.YearMonthDay.__init__": [(), ('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.YearMonthDay.__copy__": (),
-    "PySide2.QtCore.QCalendar.YearMonthDay.isValid": (),
-    "PySide2.QtCore.QCalendar.__init__": [(), ('PySide2.QtCore.QCalendar.System',)],
-    "PySide2.QtCore.QCalendar.__copy__": (),
-    "PySide2.QtCore.QCalendar.availableCalendars": (),
-    "PySide2.QtCore.QCalendar.dateFromParts": [('PySide2.QtCore.QCalendar.YearMonthDay',), ('int', 'int', 'int')],
-    "PySide2.QtCore.QCalendar.dayOfWeek": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.daysInMonth": ('int', 'int'),
-    "PySide2.QtCore.QCalendar.daysInYear": ('int',),
-    "PySide2.QtCore.QCalendar.hasYearZero": (),
-    "PySide2.QtCore.QCalendar.isDateValid": ('int', 'int', 'int'),
-    "PySide2.QtCore.QCalendar.isGregorian": (),
-    "PySide2.QtCore.QCalendar.isLeapYear": ('int',),
-    "PySide2.QtCore.QCalendar.isLunar": (),
-    "PySide2.QtCore.QCalendar.isLuniSolar": (),
-    "PySide2.QtCore.QCalendar.isProleptic": (),
-    "PySide2.QtCore.QCalendar.isSolar": (),
-    "PySide2.QtCore.QCalendar.isValid": (),
-    "PySide2.QtCore.QCalendar.maximumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.maximumMonthsInYear": (),
-    "PySide2.QtCore.QCalendar.minimumDaysInMonth": (),
-    "PySide2.QtCore.QCalendar.monthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.monthsInYear": ('int',),
-    "PySide2.QtCore.QCalendar.name": (),
-    "PySide2.QtCore.QCalendar.partsFromDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QCalendar.standaloneMonthName": ('PySide2.QtCore.QLocale', 'int', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.standaloneWeekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QCalendar.weekDayName": ('PySide2.QtCore.QLocale', 'int', 'PySide2.QtCore.QLocale.FormatType'),
-# class PySide2.QtCore.QCborArray:
-    "PySide2.QtCore.QCborArray.__init__": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborArray.__add__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__copy__": (),
-    "PySide2.QtCore.QCborArray.__iadd__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.__lshift__": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.append": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.at": ('int',),
-    "PySide2.QtCore.QCborArray.clear": (),
-    "PySide2.QtCore.QCborArray.compare": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.contains": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.empty": (),
-    "PySide2.QtCore.QCborArray.first": (),
-    "PySide2.QtCore.QCborArray.fromJsonArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QCborArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCborArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QCborArray.insert": ('int', 'PySide2.QtCore.QCborValue'),
-    "PySide2.QtCore.QCborArray.isEmpty": (),
-    "PySide2.QtCore.QCborArray.last": (),
-    "PySide2.QtCore.QCborArray.pop_back": (),
-    "PySide2.QtCore.QCborArray.pop_front": (),
-    "PySide2.QtCore.QCborArray.prepend": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_back": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.push_front": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborArray.removeAt": ('int',),
-    "PySide2.QtCore.QCborArray.removeFirst": (),
-    "PySide2.QtCore.QCborArray.removeLast": (),
-    "PySide2.QtCore.QCborArray.size": (),
-    "PySide2.QtCore.QCborArray.swap": ('PySide2.QtCore.QCborArray',),
-    "PySide2.QtCore.QCborArray.takeAt": ('int',),
-    "PySide2.QtCore.QCborArray.takeFirst": (),
-    "PySide2.QtCore.QCborArray.takeLast": (),
-    "PySide2.QtCore.QCborArray.toCborValue": (),
-    "PySide2.QtCore.QCborArray.toJsonArray": (),
-    "PySide2.QtCore.QCborArray.toVariantList": (),
-# class PySide2.QtCore.QCborError:
-# class PySide2.QtCore.QCborError.Code:
-    "PySide2.QtCore.QCborError.__init__": [(), ('PySide2.QtCore.QCborError',)],
-    "PySide2.QtCore.QCborError.__copy__": (),
-    "PySide2.QtCore.QCborError.toString": (),
-# class PySide2.QtCore.QCborKnownTags:
-# class PySide2.QtCore.QCborMap:
-    "PySide2.QtCore.QCborMap.__init__": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborMap.__copy__": (),
-    "PySide2.QtCore.QCborMap.clear": (),
-    "PySide2.QtCore.QCborMap.compare": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.contains": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.empty": (),
-    "PySide2.QtCore.QCborMap.fromJsonObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QCborMap.fromVariantHash": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.fromVariantMap": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtCore.QCborMap.isEmpty": (),
-    "PySide2.QtCore.QCborMap.keys": (),
-    "PySide2.QtCore.QCborMap.remove": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.size": (),
-    "PySide2.QtCore.QCborMap.swap": ('PySide2.QtCore.QCborMap',),
-    "PySide2.QtCore.QCborMap.take": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborMap.toCborValue": (),
-    "PySide2.QtCore.QCborMap.toJsonObject": (),
-    "PySide2.QtCore.QCborMap.toVariantHash": (),
-    "PySide2.QtCore.QCborMap.toVariantMap": (),
-    "PySide2.QtCore.QCborMap.value": [('PySide2.QtCore.QCborValue',), ('int',), ('str',)],
-# class PySide2.QtCore.QCborParserError:
-    "PySide2.QtCore.QCborParserError.__init__": [(), ('PySide2.QtCore.QCborParserError',)],
-    "PySide2.QtCore.QCborParserError.__copy__": (),
-    "PySide2.QtCore.QCborParserError.errorString": (),
-# class PySide2.QtCore.QCborSimpleType:
-# class PySide2.QtCore.QCborStreamReader:
-# class PySide2.QtCore.QCborStreamReader.StringResultCode:
-# class PySide2.QtCore.QCborStreamReader.Type:
-    "PySide2.QtCore.QCborStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('bytearray', 'int'), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamReader.clear": (),
-    "PySide2.QtCore.QCborStreamReader.containerDepth": (),
-    "PySide2.QtCore.QCborStreamReader.currentOffset": (),
-    "PySide2.QtCore.QCborStreamReader.currentStringChunkSize": (),
-    "PySide2.QtCore.QCborStreamReader.device": (),
-    "PySide2.QtCore.QCborStreamReader.enterContainer": (),
-    "PySide2.QtCore.QCborStreamReader.hasNext": (),
-    "PySide2.QtCore.QCborStreamReader.isArray": (),
-    "PySide2.QtCore.QCborStreamReader.isBool": (),
-    "PySide2.QtCore.QCborStreamReader.isByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.isContainer": (),
-    "PySide2.QtCore.QCborStreamReader.isDouble": (),
-    "PySide2.QtCore.QCborStreamReader.isFalse": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat": (),
-    "PySide2.QtCore.QCborStreamReader.isFloat16": (),
-    "PySide2.QtCore.QCborStreamReader.isInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isInvalid": (),
-    "PySide2.QtCore.QCborStreamReader.isLengthKnown": (),
-    "PySide2.QtCore.QCborStreamReader.isMap": (),
-    "PySide2.QtCore.QCborStreamReader.isNegativeInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isNull": (),
-    "PySide2.QtCore.QCborStreamReader.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborStreamReader.isString": (),
-    "PySide2.QtCore.QCborStreamReader.isTag": (),
-    "PySide2.QtCore.QCborStreamReader.isTrue": (),
-    "PySide2.QtCore.QCborStreamReader.isUndefined": (),
-    "PySide2.QtCore.QCborStreamReader.isUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.isValid": (),
-    "PySide2.QtCore.QCborStreamReader.lastError": (),
-    "PySide2.QtCore.QCborStreamReader.leaveContainer": (),
-    "PySide2.QtCore.QCborStreamReader.length": (),
-    "PySide2.QtCore.QCborStreamReader.parentContainerType": (),
-    "PySide2.QtCore.QCborStreamReader.readByteArray": (),
-    "PySide2.QtCore.QCborStreamReader.readString": (),
-    "PySide2.QtCore.QCborStreamReader.reparse": (),
-    "PySide2.QtCore.QCborStreamReader.reset": (),
-    "PySide2.QtCore.QCborStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamReader.toBool": (),
-    "PySide2.QtCore.QCborStreamReader.toDouble": (),
-    "PySide2.QtCore.QCborStreamReader.toFloat": (),
-    "PySide2.QtCore.QCborStreamReader.toInteger": (),
-    "PySide2.QtCore.QCborStreamReader.toSimpleType": (),
-    "PySide2.QtCore.QCborStreamReader.toUnsignedInteger": (),
-    "PySide2.QtCore.QCborStreamReader.type": (),
-# class PySide2.QtCore.QCborStreamWriter:
-    "PySide2.QtCore.QCborStreamWriter.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QCborStreamWriter.append": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborKnownTags',), ('PySide2.QtCore.QCborSimpleType',), ('bool',), ('float',), ('int',), ('str', 'int')],
-    "PySide2.QtCore.QCborStreamWriter.appendByteString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendNull": (),
-    "PySide2.QtCore.QCborStreamWriter.appendTextString": ('str', 'int'),
-    "PySide2.QtCore.QCborStreamWriter.appendUndefined": (),
-    "PySide2.QtCore.QCborStreamWriter.device": (),
-    "PySide2.QtCore.QCborStreamWriter.endArray": (),
-    "PySide2.QtCore.QCborStreamWriter.endMap": (),
-    "PySide2.QtCore.QCborStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QCborStreamWriter.startArray": [(), ('int',)],
-    "PySide2.QtCore.QCborStreamWriter.startMap": [(), ('int',)],
-# class PySide2.QtCore.QCborStringResultByteArray:
-    "PySide2.QtCore.QCborStringResultByteArray.__init__": [(), ('PySide2.QtCore.QCborStringResultByteArray',)],
-    "PySide2.QtCore.QCborStringResultByteArray.__copy__": (),
-# class PySide2.QtCore.QCborStringResultString:
-    "PySide2.QtCore.QCborStringResultString.__init__": [(), ('PySide2.QtCore.QCborStringResultString',)],
-    "PySide2.QtCore.QCborStringResultString.__copy__": (),
-# class PySide2.QtCore.QCborValue:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOption:
-# class PySide2.QtCore.QCborValue.DiagnosticNotationOptions:
-# class PySide2.QtCore.QCborValue.EncodingOption:
-# class PySide2.QtCore.QCborValue.EncodingOptions:
-# class PySide2.QtCore.QCborValue.Type:
-    "PySide2.QtCore.QCborValue.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborKnownTags', 'PySide2.QtCore.QCborValue'), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborSimpleType',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QCborValue.Type',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QCborValue.__copy__": (),
-    "PySide2.QtCore.QCborValue.compare": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.fromCbor": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCborParserError'), ('PySide2.QtCore.QCborStreamReader',), ('bytearray', 'int', 'PySide2.QtCore.QCborParserError'), ('str', 'int', 'PySide2.QtCore.QCborParserError')],
-    "PySide2.QtCore.QCborValue.fromJsonValue": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QCborValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QCborValue.isArray": (),
-    "PySide2.QtCore.QCborValue.isBool": (),
-    "PySide2.QtCore.QCborValue.isByteArray": (),
-    "PySide2.QtCore.QCborValue.isContainer": (),
-    "PySide2.QtCore.QCborValue.isDateTime": (),
-    "PySide2.QtCore.QCborValue.isDouble": (),
-    "PySide2.QtCore.QCborValue.isFalse": (),
-    "PySide2.QtCore.QCborValue.isInteger": (),
-    "PySide2.QtCore.QCborValue.isInvalid": (),
-    "PySide2.QtCore.QCborValue.isMap": (),
-    "PySide2.QtCore.QCborValue.isNull": (),
-    "PySide2.QtCore.QCborValue.isRegularExpression": (),
-    "PySide2.QtCore.QCborValue.isSimpleType": [(), ('PySide2.QtCore.QCborSimpleType',)],
-    "PySide2.QtCore.QCborValue.isString": (),
-    "PySide2.QtCore.QCborValue.isTag": (),
-    "PySide2.QtCore.QCborValue.isTrue": (),
-    "PySide2.QtCore.QCborValue.isUndefined": (),
-    "PySide2.QtCore.QCborValue.isUrl": (),
-    "PySide2.QtCore.QCborValue.isUuid": (),
-    "PySide2.QtCore.QCborValue.swap": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.taggedValue": ('PySide2.QtCore.QCborValue',),
-    "PySide2.QtCore.QCborValue.toArray": [(), ('PySide2.QtCore.QCborArray',)],
-    "PySide2.QtCore.QCborValue.toBool": ('bool',),
-    "PySide2.QtCore.QCborValue.toByteArray": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QCborValue.toCbor": [('PySide2.QtCore.QCborStreamWriter', 'PySide2.QtCore.QCborValue.EncodingOptions'), ('PySide2.QtCore.QCborValue.EncodingOptions',)],
-    "PySide2.QtCore.QCborValue.toDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QCborValue.toDiagnosticNotation": ('PySide2.QtCore.QCborValue.DiagnosticNotationOptions',),
-    "PySide2.QtCore.QCborValue.toDouble": ('float',),
-    "PySide2.QtCore.QCborValue.toInteger": ('int',),
-    "PySide2.QtCore.QCborValue.toJsonValue": (),
-    "PySide2.QtCore.QCborValue.toMap": [(), ('PySide2.QtCore.QCborMap',)],
-    "PySide2.QtCore.QCborValue.toRegularExpression": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QCborValue.toSimpleType": ('PySide2.QtCore.QCborSimpleType',),
-    "PySide2.QtCore.QCborValue.toString": ('str',),
-    "PySide2.QtCore.QCborValue.toUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QCborValue.toUuid": ('PySide2.QtCore.QUuid',),
-    "PySide2.QtCore.QCborValue.toVariant": (),
-    "PySide2.QtCore.QCborValue.type": (),
-# class PySide2.QtCore.QChildEvent:
-    "PySide2.QtCore.QChildEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QChildEvent.added": (),
-    "PySide2.QtCore.QChildEvent.child": (),
-    "PySide2.QtCore.QChildEvent.polished": (),
-    "PySide2.QtCore.QChildEvent.removed": (),
-# class PySide2.QtCore.QCollator:
-    "PySide2.QtCore.QCollator.__init__": [(), ('PySide2.QtCore.QCollator',), ('PySide2.QtCore.QLocale',)],
-    "PySide2.QtCore.QCollator.__call__": ('str', 'str'),
-    "PySide2.QtCore.QCollator.caseSensitivity": (),
-    "PySide2.QtCore.QCollator.compare": [('str', 'int', 'str', 'int'), ('str', 'str')],
-    "PySide2.QtCore.QCollator.ignorePunctuation": (),
-    "PySide2.QtCore.QCollator.locale": (),
-    "PySide2.QtCore.QCollator.numericMode": (),
-    "PySide2.QtCore.QCollator.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QCollator.setIgnorePunctuation": ('bool',),
-    "PySide2.QtCore.QCollator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QCollator.setNumericMode": ('bool',),
-    "PySide2.QtCore.QCollator.sortKey": ('str',),
-    "PySide2.QtCore.QCollator.swap": ('PySide2.QtCore.QCollator',),
-# class PySide2.QtCore.QCollatorSortKey:
-    "PySide2.QtCore.QCollatorSortKey.__init__": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.compare": ('PySide2.QtCore.QCollatorSortKey',),
-    "PySide2.QtCore.QCollatorSortKey.swap": ('PySide2.QtCore.QCollatorSortKey',),
-# class PySide2.QtCore.QCommandLineOption:
-# class PySide2.QtCore.QCommandLineOption.Flag:
-# class PySide2.QtCore.QCommandLineOption.Flags:
-    "PySide2.QtCore.QCommandLineOption.__init__": [('PySide2.QtCore.QCommandLineOption',), ('str',), ('str', 'str', 'str', 'str'), ('typing.Sequence[str]',), ('typing.Sequence[str]', 'str', 'str', 'str')],
-    "PySide2.QtCore.QCommandLineOption.defaultValues": (),
-    "PySide2.QtCore.QCommandLineOption.description": (),
-    "PySide2.QtCore.QCommandLineOption.flags": (),
-    "PySide2.QtCore.QCommandLineOption.isHidden": (),
-    "PySide2.QtCore.QCommandLineOption.names": (),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValue": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setDefaultValues": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineOption.setDescription": ('str',),
-    "PySide2.QtCore.QCommandLineOption.setFlags": ('PySide2.QtCore.QCommandLineOption.Flags',),
-    "PySide2.QtCore.QCommandLineOption.setHidden": ('bool',),
-    "PySide2.QtCore.QCommandLineOption.setValueName": ('str',),
-    "PySide2.QtCore.QCommandLineOption.swap": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineOption.valueName": (),
-# class PySide2.QtCore.QCommandLineParser:
-# class PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode:
-# class PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode:
-    "PySide2.QtCore.QCommandLineParser.__init__": (),
-    "PySide2.QtCore.QCommandLineParser.addHelpOption": (),
-    "PySide2.QtCore.QCommandLineParser.addOption": ('PySide2.QtCore.QCommandLineOption',),
-    "PySide2.QtCore.QCommandLineParser.addOptions": ('typing.Sequence[PySide2.QtCore.QCommandLineOption]',),
-    "PySide2.QtCore.QCommandLineParser.addPositionalArgument": ('str', 'str', 'str'),
-    "PySide2.QtCore.QCommandLineParser.addVersionOption": (),
-    "PySide2.QtCore.QCommandLineParser.applicationDescription": (),
-    "PySide2.QtCore.QCommandLineParser.clearPositionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.errorText": (),
-    "PySide2.QtCore.QCommandLineParser.helpText": (),
-    "PySide2.QtCore.QCommandLineParser.isSet": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.optionNames": (),
-    "PySide2.QtCore.QCommandLineParser.parse": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCommandLineParser.positionalArguments": (),
-    "PySide2.QtCore.QCommandLineParser.process": [('PySide2.QtCore.QCoreApplication',), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCommandLineParser.setApplicationDescription": ('str',),
-    "PySide2.QtCore.QCommandLineParser.setOptionsAfterPositionalArgumentsMode": ('PySide2.QtCore.QCommandLineParser.OptionsAfterPositionalArgumentsMode',),
-    "PySide2.QtCore.QCommandLineParser.setSingleDashWordOptionMode": ('PySide2.QtCore.QCommandLineParser.SingleDashWordOptionMode',),
-    "PySide2.QtCore.QCommandLineParser.showHelp": ('int',),
-    "PySide2.QtCore.QCommandLineParser.showVersion": (),
-    "PySide2.QtCore.QCommandLineParser.unknownOptionNames": (),
-    "PySide2.QtCore.QCommandLineParser.value": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-    "PySide2.QtCore.QCommandLineParser.values": [('PySide2.QtCore.QCommandLineOption',), ('str',)],
-# class PySide2.QtCore.QConcatenateTablesProxyModel:
-    "PySide2.QtCore.QConcatenateTablesProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.addSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.canDropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QConcatenateTablesProxyModel.removeSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QConcatenateTablesProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QCoreApplication:
-    "PySide2.QtCore.QCoreApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtCore.QCoreApplication.addLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.applicationDirPath": (),
-    "PySide2.QtCore.QCoreApplication.applicationFilePath": (),
-    "PySide2.QtCore.QCoreApplication.applicationName": (),
-    "PySide2.QtCore.QCoreApplication.applicationPid": (),
-    "PySide2.QtCore.QCoreApplication.applicationVersion": (),
-    "PySide2.QtCore.QCoreApplication.arguments": (),
-    "PySide2.QtCore.QCoreApplication.closingDown": (),
-    "PySide2.QtCore.QCoreApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QCoreApplication.eventDispatcher": (),
-    "PySide2.QtCore.QCoreApplication.exec_": (),
-    "PySide2.QtCore.QCoreApplication.exit": ('int',),
-    "PySide2.QtCore.QCoreApplication.flush": (),
-    "PySide2.QtCore.QCoreApplication.hasPendingEvents": (),
-    "PySide2.QtCore.QCoreApplication.installNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.installTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.instance": (),
-    "PySide2.QtCore.QCoreApplication.isQuitLockEnabled": (),
-    "PySide2.QtCore.QCoreApplication.isSetuidAllowed": (),
-    "PySide2.QtCore.QCoreApplication.libraryPaths": (),
-    "PySide2.QtCore.QCoreApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.organizationDomain": (),
-    "PySide2.QtCore.QCoreApplication.organizationName": (),
-    "PySide2.QtCore.QCoreApplication.postEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QCoreApplication.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QCoreApplication.quit": (),
-    "PySide2.QtCore.QCoreApplication.removeLibraryPath": ('str',),
-    "PySide2.QtCore.QCoreApplication.removeNativeEventFilter": ('PySide2.QtCore.QAbstractNativeEventFilter',),
-    "PySide2.QtCore.QCoreApplication.removePostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.removeTranslator": ('PySide2.QtCore.QTranslator',),
-    "PySide2.QtCore.QCoreApplication.sendEvent": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QCoreApplication.sendPostedEvents": ('PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QCoreApplication.setApplicationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setApplicationVersion": ('str',),
-    "PySide2.QtCore.QCoreApplication.setAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute', 'bool'),
-    "PySide2.QtCore.QCoreApplication.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QCoreApplication.setLibraryPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationDomain": ('str',),
-    "PySide2.QtCore.QCoreApplication.setOrganizationName": ('str',),
-    "PySide2.QtCore.QCoreApplication.setQuitLockEnabled": ('bool',),
-    "PySide2.QtCore.QCoreApplication.setSetuidAllowed": ('bool',),
-    "PySide2.QtCore.QCoreApplication.shutdown": (),
-    "PySide2.QtCore.QCoreApplication.startingUp": (),
-    "PySide2.QtCore.QCoreApplication.testAttribute": ('PySide2.QtCore.Qt.ApplicationAttribute',),
-    "PySide2.QtCore.QCoreApplication.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QCryptographicHash:
-# class PySide2.QtCore.QCryptographicHash.Algorithm:
-    "PySide2.QtCore.QCryptographicHash.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QCryptographicHash.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QCryptographicHash.hashLength": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtCore.QCryptographicHash.reset": (),
-    "PySide2.QtCore.QCryptographicHash.result": (),
-# class PySide2.QtCore.QDataStream:
-# class PySide2.QtCore.QDataStream.ByteOrder:
-# class PySide2.QtCore.QDataStream.FloatingPointPrecision:
-# class PySide2.QtCore.QDataStream.Status:
-# class PySide2.QtCore.QDataStream.Version:
-    "PySide2.QtCore.QDataStream.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QDataStream.__lshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',), ('str',)],
-    "PySide2.QtCore.QDataStream.__rshift__": [('PySide2.QtCore.QBitArray',), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QCborArray',), ('PySide2.QtCore.QCborMap',), ('PySide2.QtCore.QCborValue',), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDateTime',), ('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRegExp',), ('PySide2.QtCore.QRegularExpression',), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('PySide2.QtCore.QTime',), ('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUuid',), ('PySide2.QtCore.QVersionNumber',)],
-    "PySide2.QtCore.QDataStream.abortTransaction": (),
-    "PySide2.QtCore.QDataStream.atEnd": (),
-    "PySide2.QtCore.QDataStream.byteOrder": (),
-    "PySide2.QtCore.QDataStream.commitTransaction": (),
-    "PySide2.QtCore.QDataStream.device": (),
-    "PySide2.QtCore.QDataStream.floatingPointPrecision": (),
-    "PySide2.QtCore.QDataStream.readBool": (),
-    "PySide2.QtCore.QDataStream.readDouble": (),
-    "PySide2.QtCore.QDataStream.readFloat": (),
-    "PySide2.QtCore.QDataStream.readInt16": (),
-    "PySide2.QtCore.QDataStream.readInt32": (),
-    "PySide2.QtCore.QDataStream.readInt64": (),
-    "PySide2.QtCore.QDataStream.readInt8": (),
-    "PySide2.QtCore.QDataStream.readQChar": (),
-    "PySide2.QtCore.QDataStream.readQString": (),
-    "PySide2.QtCore.QDataStream.readQStringList": (),
-    "PySide2.QtCore.QDataStream.readQVariant": (),
-    "PySide2.QtCore.QDataStream.readRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.readString": (),
-    "PySide2.QtCore.QDataStream.readUInt16": (),
-    "PySide2.QtCore.QDataStream.readUInt32": (),
-    "PySide2.QtCore.QDataStream.readUInt64": (),
-    "PySide2.QtCore.QDataStream.readUInt8": (),
-    "PySide2.QtCore.QDataStream.resetStatus": (),
-    "PySide2.QtCore.QDataStream.rollbackTransaction": (),
-    "PySide2.QtCore.QDataStream.setByteOrder": ('PySide2.QtCore.QDataStream.ByteOrder',),
-    "PySide2.QtCore.QDataStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QDataStream.setFloatingPointPrecision": ('PySide2.QtCore.QDataStream.FloatingPointPrecision',),
-    "PySide2.QtCore.QDataStream.setStatus": ('PySide2.QtCore.QDataStream.Status',),
-    "PySide2.QtCore.QDataStream.setVersion": ('int',),
-    "PySide2.QtCore.QDataStream.skipRawData": ('int',),
-    "PySide2.QtCore.QDataStream.startTransaction": (),
-    "PySide2.QtCore.QDataStream.status": (),
-    "PySide2.QtCore.QDataStream.unsetDevice": (),
-    "PySide2.QtCore.QDataStream.version": (),
-    "PySide2.QtCore.QDataStream.writeBool": ('bool',),
-    "PySide2.QtCore.QDataStream.writeDouble": ('float',),
-    "PySide2.QtCore.QDataStream.writeFloat": ('float',),
-    "PySide2.QtCore.QDataStream.writeInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeInt8": ('int',),
-    "PySide2.QtCore.QDataStream.writeQChar": ('str',),
-    "PySide2.QtCore.QDataStream.writeQString": ('str',),
-    "PySide2.QtCore.QDataStream.writeQStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDataStream.writeQVariant": ('typing.Any',),
-    "PySide2.QtCore.QDataStream.writeRawData": ('str', 'int'),
-    "PySide2.QtCore.QDataStream.writeString": ('str',),
-    "PySide2.QtCore.QDataStream.writeUInt16": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt32": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt64": ('int',),
-    "PySide2.QtCore.QDataStream.writeUInt8": ('int',),
-# class PySide2.QtCore.QDate:
-# class PySide2.QtCore.QDate.MonthNameType:
-    "PySide2.QtCore.QDate.__init__": [(), ('PySide2.QtCore.QDate',), ('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.__copy__": (),
-    "PySide2.QtCore.QDate.__reduce__": (),
-    "PySide2.QtCore.QDate.__repr__": (),
-    "PySide2.QtCore.QDate.addDays": ('int',),
-    "PySide2.QtCore.QDate.addMonths": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.addYears": [('int',), ('int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.currentDate": (),
-    "PySide2.QtCore.QDate.day": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfWeek": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.dayOfYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInMonth": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysInYear": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.daysTo": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDate.endOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.fromJulianDay": ('int',),
-    "PySide2.QtCore.QDate.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.getDate": (),
-    "PySide2.QtCore.QDate.isLeapYear": ('int',),
-    "PySide2.QtCore.QDate.isNull": (),
-    "PySide2.QtCore.QDate.isValid": [(), ('int', 'int', 'int')],
-    "PySide2.QtCore.QDate.longDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.longMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.month": [(), ('PySide2.QtCore.QCalendar',)],
-    "PySide2.QtCore.QDate.setDate": [('int', 'int', 'int'), ('int', 'int', 'int', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.shortDayName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.shortMonthName": ('int', 'PySide2.QtCore.QDate.MonthNameType'),
-    "PySide2.QtCore.QDate.startOfDay": [('PySide2.QtCore.QTimeZone',), ('PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDate.toJulianDay": (),
-    "PySide2.QtCore.QDate.toPython": (),
-    "PySide2.QtCore.QDate.toString": [('PySide2.QtCore.Qt.DateFormat',), ('PySide2.QtCore.Qt.DateFormat', 'PySide2.QtCore.QCalendar'), ('str',), ('str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDate.weekNumber": (),
-    "PySide2.QtCore.QDate.year": [(), ('PySide2.QtCore.QCalendar',)],
-# class PySide2.QtCore.QDateTime:
-# class PySide2.QtCore.QDateTime.YearRange:
-    "PySide2.QtCore.QDateTime.__init__": [(), ('PySide2.QtCore.QDate',), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.QTimeZone'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QTime', 'PySide2.QtCore.Qt.TimeSpec', 'int'), ('PySide2.QtCore.QDateTime',), ('int', 'int', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QDateTime.__copy__": (),
-    "PySide2.QtCore.QDateTime.__reduce__": (),
-    "PySide2.QtCore.QDateTime.__repr__": (),
-    "PySide2.QtCore.QDateTime.addDays": ('int',),
-    "PySide2.QtCore.QDateTime.addMSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addMonths": ('int',),
-    "PySide2.QtCore.QDateTime.addSecs": ('int',),
-    "PySide2.QtCore.QDateTime.addYears": ('int',),
-    "PySide2.QtCore.QDateTime.currentDateTime": (),
-    "PySide2.QtCore.QDateTime.currentDateTimeUtc": (),
-    "PySide2.QtCore.QDateTime.currentMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.currentSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.date": (),
-    "PySide2.QtCore.QDateTime.daysTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.fromMSecsSinceEpoch": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromSecsSinceEpoch": [('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QDateTime.fromTime_t": [('int',), ('int', 'PySide2.QtCore.QTimeZone'), ('int', 'PySide2.QtCore.Qt.TimeSpec', 'int')],
-    "PySide2.QtCore.QDateTime.isDaylightTime": (),
-    "PySide2.QtCore.QDateTime.isNull": (),
-    "PySide2.QtCore.QDateTime.isValid": (),
-    "PySide2.QtCore.QDateTime.msecsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.offsetFromUtc": (),
-    "PySide2.QtCore.QDateTime.secsTo": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtCore.QDateTime.setMSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.setSecsSinceEpoch": ('int',),
-    "PySide2.QtCore.QDateTime.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QDateTime.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.setTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.setTime_t": ('int',),
-    "PySide2.QtCore.QDateTime.setUtcOffset": ('int',),
-    "PySide2.QtCore.QDateTime.swap": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QDateTime.time": (),
-    "PySide2.QtCore.QDateTime.timeSpec": (),
-    "PySide2.QtCore.QDateTime.timeZone": (),
-    "PySide2.QtCore.QDateTime.timeZoneAbbreviation": (),
-    "PySide2.QtCore.QDateTime.toLocalTime": (),
-    "PySide2.QtCore.QDateTime.toMSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toOffsetFromUtc": ('int',),
-    "PySide2.QtCore.QDateTime.toPython": (),
-    "PySide2.QtCore.QDateTime.toSecsSinceEpoch": (),
-    "PySide2.QtCore.QDateTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-    "PySide2.QtCore.QDateTime.toTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtCore.QDateTime.toTimeZone": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QDateTime.toTime_t": (),
-    "PySide2.QtCore.QDateTime.toUTC": (),
-    "PySide2.QtCore.QDateTime.utcOffset": (),
-# class PySide2.QtCore.QDeadlineTimer:
-# class PySide2.QtCore.QDeadlineTimer.ForeverConstant:
-    "PySide2.QtCore.QDeadlineTimer.__init__": [('PySide2.QtCore.QDeadlineTimer',), ('PySide2.QtCore.QDeadlineTimer.ForeverConstant', 'PySide2.QtCore.Qt.TimerType'), ('PySide2.QtCore.Qt.TimerType',), ('int', 'PySide2.QtCore.Qt.TimerType')],
-    "PySide2.QtCore.QDeadlineTimer.__copy__": (),
-    "PySide2.QtCore.QDeadlineTimer.__iadd__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer.__isub__": ('int',),
-    "PySide2.QtCore.QDeadlineTimer._q_data": (),
-    "PySide2.QtCore.QDeadlineTimer.addNSecs": ('PySide2.QtCore.QDeadlineTimer', 'int'),
-    "PySide2.QtCore.QDeadlineTimer.current": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.deadline": (),
-    "PySide2.QtCore.QDeadlineTimer.deadlineNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.hasExpired": (),
-    "PySide2.QtCore.QDeadlineTimer.isForever": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTime": (),
-    "PySide2.QtCore.QDeadlineTimer.remainingTimeNSecs": (),
-    "PySide2.QtCore.QDeadlineTimer.setDeadline": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseDeadline": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setPreciseRemainingTime": ('int', 'int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setRemainingTime": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QDeadlineTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QDeadlineTimer.swap": ('PySide2.QtCore.QDeadlineTimer',),
-    "PySide2.QtCore.QDeadlineTimer.timerType": (),
-# class PySide2.QtCore.QDir:
-# class PySide2.QtCore.QDir.Filter:
-# class PySide2.QtCore.QDir.Filters:
-# class PySide2.QtCore.QDir.SortFlag:
-# class PySide2.QtCore.QDir.SortFlags:
-    "PySide2.QtCore.QDir.__init__": [('PySide2.QtCore.QDir',), ('str',), ('str', 'str', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QDir.Filters')],
-    "PySide2.QtCore.QDir.__copy__": (),
-    "PySide2.QtCore.QDir.__reduce__": (),
-    "PySide2.QtCore.QDir.absoluteFilePath": ('str',),
-    "PySide2.QtCore.QDir.absolutePath": (),
-    "PySide2.QtCore.QDir.addResourceSearchPath": ('str',),
-    "PySide2.QtCore.QDir.addSearchPath": ('str', 'str'),
-    "PySide2.QtCore.QDir.canonicalPath": (),
-    "PySide2.QtCore.QDir.cd": ('str',),
-    "PySide2.QtCore.QDir.cdUp": (),
-    "PySide2.QtCore.QDir.cleanPath": ('str',),
-    "PySide2.QtCore.QDir.count": (),
-    "PySide2.QtCore.QDir.current": (),
-    "PySide2.QtCore.QDir.currentPath": (),
-    "PySide2.QtCore.QDir.dirName": (),
-    "PySide2.QtCore.QDir.drives": (),
-    "PySide2.QtCore.QDir.entryInfoList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.entryList": [('PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags'), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags')],
-    "PySide2.QtCore.QDir.exists": [(), ('str',)],
-    "PySide2.QtCore.QDir.filePath": ('str',),
-    "PySide2.QtCore.QDir.filter": (),
-    "PySide2.QtCore.QDir.fromNativeSeparators": ('str',),
-    "PySide2.QtCore.QDir.home": (),
-    "PySide2.QtCore.QDir.homePath": (),
-    "PySide2.QtCore.QDir.isAbsolute": (),
-    "PySide2.QtCore.QDir.isAbsolutePath": ('str',),
-    "PySide2.QtCore.QDir.isEmpty": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.isReadable": (),
-    "PySide2.QtCore.QDir.isRelative": (),
-    "PySide2.QtCore.QDir.isRelativePath": ('str',),
-    "PySide2.QtCore.QDir.isRoot": (),
-    "PySide2.QtCore.QDir.listSeparator": (),
-    "PySide2.QtCore.QDir.makeAbsolute": (),
-    "PySide2.QtCore.QDir.match": [('str', 'str'), ('typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QDir.mkdir": ('str',),
-    "PySide2.QtCore.QDir.mkpath": ('str',),
-    "PySide2.QtCore.QDir.nameFilters": (),
-    "PySide2.QtCore.QDir.nameFiltersFromString": ('str',),
-    "PySide2.QtCore.QDir.path": (),
-    "PySide2.QtCore.QDir.refresh": (),
-    "PySide2.QtCore.QDir.relativeFilePath": ('str',),
-    "PySide2.QtCore.QDir.remove": ('str',),
-    "PySide2.QtCore.QDir.removeRecursively": (),
-    "PySide2.QtCore.QDir.rename": ('str', 'str'),
-    "PySide2.QtCore.QDir.rmdir": ('str',),
-    "PySide2.QtCore.QDir.rmpath": ('str',),
-    "PySide2.QtCore.QDir.root": (),
-    "PySide2.QtCore.QDir.rootPath": (),
-    "PySide2.QtCore.QDir.searchPaths": ('str',),
-    "PySide2.QtCore.QDir.separator": (),
-    "PySide2.QtCore.QDir.setCurrent": ('str',),
-    "PySide2.QtCore.QDir.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtCore.QDir.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QDir.setPath": ('str',),
-    "PySide2.QtCore.QDir.setSearchPaths": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QDir.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtCore.QDir.sorting": (),
-    "PySide2.QtCore.QDir.swap": ('PySide2.QtCore.QDir',),
-    "PySide2.QtCore.QDir.temp": (),
-    "PySide2.QtCore.QDir.tempPath": (),
-    "PySide2.QtCore.QDir.toNativeSeparators": ('str',),
-# class PySide2.QtCore.QDirIterator:
-# class PySide2.QtCore.QDirIterator.IteratorFlag:
-# class PySide2.QtCore.QDirIterator.IteratorFlags:
-    "PySide2.QtCore.QDirIterator.__init__": [('PySide2.QtCore.QDir', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'PySide2.QtCore.QDirIterator.IteratorFlags'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDirIterator.IteratorFlags')],
-    "PySide2.QtCore.QDirIterator.fileInfo": (),
-    "PySide2.QtCore.QDirIterator.fileName": (),
-    "PySide2.QtCore.QDirIterator.filePath": (),
-    "PySide2.QtCore.QDirIterator.hasNext": (),
-    "PySide2.QtCore.QDirIterator.path": (),
-# class PySide2.QtCore.QDynamicPropertyChangeEvent:
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.__init__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QDynamicPropertyChangeEvent.propertyName": (),
-# class PySide2.QtCore.QEasingCurve:
-# class PySide2.QtCore.QEasingCurve.Type:
-    "PySide2.QtCore.QEasingCurve.__init__": [('PySide2.QtCore.QEasingCurve',), ('PySide2.QtCore.QEasingCurve.Type',)],
-    "PySide2.QtCore.QEasingCurve.__copy__": (),
-    "PySide2.QtCore.QEasingCurve.addCubicBezierSegment": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QEasingCurve.addTCBSegment": ('PySide2.QtCore.QPointF', 'float', 'float', 'float'),
-    "PySide2.QtCore.QEasingCurve.amplitude": (),
-    "PySide2.QtCore.QEasingCurve.customType": (),
-    "PySide2.QtCore.QEasingCurve.overshoot": (),
-    "PySide2.QtCore.QEasingCurve.period": (),
-    "PySide2.QtCore.QEasingCurve.setAmplitude": ('float',),
-    "PySide2.QtCore.QEasingCurve.setCustomType": ('object',),
-    "PySide2.QtCore.QEasingCurve.setOvershoot": ('float',),
-    "PySide2.QtCore.QEasingCurve.setPeriod": ('float',),
-    "PySide2.QtCore.QEasingCurve.setType": ('PySide2.QtCore.QEasingCurve.Type',),
-    "PySide2.QtCore.QEasingCurve.swap": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QEasingCurve.toCubicSpline": (),
-    "PySide2.QtCore.QEasingCurve.type": (),
-    "PySide2.QtCore.QEasingCurve.valueForProgress": ('float',),
-# class PySide2.QtCore.QElapsedTimer:
-# class PySide2.QtCore.QElapsedTimer.ClockType:
-    "PySide2.QtCore.QElapsedTimer.__init__": [(), ('PySide2.QtCore.QElapsedTimer',)],
-    "PySide2.QtCore.QElapsedTimer.__copy__": (),
-    "PySide2.QtCore.QElapsedTimer.clockType": (),
-    "PySide2.QtCore.QElapsedTimer.elapsed": (),
-    "PySide2.QtCore.QElapsedTimer.hasExpired": ('int',),
-    "PySide2.QtCore.QElapsedTimer.invalidate": (),
-    "PySide2.QtCore.QElapsedTimer.isMonotonic": (),
-    "PySide2.QtCore.QElapsedTimer.isValid": (),
-    "PySide2.QtCore.QElapsedTimer.msecsSinceReference": (),
-    "PySide2.QtCore.QElapsedTimer.msecsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.nsecsElapsed": (),
-    "PySide2.QtCore.QElapsedTimer.restart": (),
-    "PySide2.QtCore.QElapsedTimer.secsTo": ('PySide2.QtCore.QElapsedTimer',),
-    "PySide2.QtCore.QElapsedTimer.start": (),
-# class PySide2.QtCore.QEvent:
-# class PySide2.QtCore.QEvent.Type:
-    "PySide2.QtCore.QEvent.__init__": [('PySide2.QtCore.QEvent',), ('PySide2.QtCore.QEvent.Type',)],
-    "PySide2.QtCore.QEvent.accept": (),
-    "PySide2.QtCore.QEvent.ignore": (),
-    "PySide2.QtCore.QEvent.isAccepted": (),
-    "PySide2.QtCore.QEvent.registerEventType": ('int',),
-    "PySide2.QtCore.QEvent.setAccepted": ('bool',),
-    "PySide2.QtCore.QEvent.spontaneous": (),
-    "PySide2.QtCore.QEvent.type": (),
-# class PySide2.QtCore.QEventLoop:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlag:
-# class PySide2.QtCore.QEventLoop.ProcessEventsFlags:
-    "PySide2.QtCore.QEventLoop.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventLoop.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventLoop.exec_": ('PySide2.QtCore.QEventLoop.ProcessEventsFlags',),
-    "PySide2.QtCore.QEventLoop.exit": ('int',),
-    "PySide2.QtCore.QEventLoop.isRunning": (),
-    "PySide2.QtCore.QEventLoop.processEvents": [('PySide2.QtCore.QEventLoop.ProcessEventsFlags',), ('PySide2.QtCore.QEventLoop.ProcessEventsFlags', 'int')],
-    "PySide2.QtCore.QEventLoop.quit": (),
-    "PySide2.QtCore.QEventLoop.wakeUp": (),
-# class PySide2.QtCore.QEventTransition:
-    "PySide2.QtCore.QEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QEventTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventSource": (),
-    "PySide2.QtCore.QEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.eventType": (),
-    "PySide2.QtCore.QEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QEventTransition.setEventSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QEventTransition.setEventType": ('PySide2.QtCore.QEvent.Type',),
-# class PySide2.QtCore.QFactoryInterface:
-    "PySide2.QtCore.QFactoryInterface.__init__": (),
-    "PySide2.QtCore.QFactoryInterface.keys": (),
-# class PySide2.QtCore.QFile:
-    "PySide2.QtCore.QFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFile.copy": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.decodeName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QFile.encodeName": ('str',),
-    "PySide2.QtCore.QFile.exists": [(), ('str',)],
-    "PySide2.QtCore.QFile.fileName": (),
-    "PySide2.QtCore.QFile.link": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.open": [('PySide2.QtCore.QIODevice.OpenMode',), ('int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtCore.QFileDevice.FileHandleFlags')],
-    "PySide2.QtCore.QFile.permissions": [(), ('str',)],
-    "PySide2.QtCore.QFile.readLink": [(), ('str',)],
-    "PySide2.QtCore.QFile.remove": [(), ('str',)],
-    "PySide2.QtCore.QFile.rename": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QFile.resize": [('int',), ('str', 'int')],
-    "PySide2.QtCore.QFile.setFileName": ('str',),
-    "PySide2.QtCore.QFile.setPermissions": [('PySide2.QtCore.QFileDevice.Permissions',), ('str', 'PySide2.QtCore.QFileDevice.Permissions')],
-    "PySide2.QtCore.QFile.size": (),
-    "PySide2.QtCore.QFile.symLinkTarget": [(), ('str',)],
-# class PySide2.QtCore.QFileDevice:
-# class PySide2.QtCore.QFileDevice.FileError:
-# class PySide2.QtCore.QFileDevice.FileHandleFlag:
-# class PySide2.QtCore.QFileDevice.FileHandleFlags:
-# class PySide2.QtCore.QFileDevice.FileTime:
-# class PySide2.QtCore.QFileDevice.MemoryMapFlags:
-# class PySide2.QtCore.QFileDevice.Permission:
-# class PySide2.QtCore.QFileDevice.Permissions:
-    "PySide2.QtCore.QFileDevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QFileDevice.atEnd": (),
-    "PySide2.QtCore.QFileDevice.close": (),
-    "PySide2.QtCore.QFileDevice.error": (),
-    "PySide2.QtCore.QFileDevice.fileName": (),
-    "PySide2.QtCore.QFileDevice.fileTime": ('PySide2.QtCore.QFileDevice.FileTime',),
-    "PySide2.QtCore.QFileDevice.flush": (),
-    "PySide2.QtCore.QFileDevice.handle": (),
-    "PySide2.QtCore.QFileDevice.isSequential": (),
-    "PySide2.QtCore.QFileDevice.map": ('int', 'int', 'PySide2.QtCore.QFileDevice.MemoryMapFlags'),
-    "PySide2.QtCore.QFileDevice.permissions": (),
-    "PySide2.QtCore.QFileDevice.pos": (),
-    "PySide2.QtCore.QFileDevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QFileDevice.resize": ('int',),
-    "PySide2.QtCore.QFileDevice.seek": ('int',),
-    "PySide2.QtCore.QFileDevice.setFileTime": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QFileDevice.FileTime'),
-    "PySide2.QtCore.QFileDevice.setPermissions": ('PySide2.QtCore.QFileDevice.Permissions',),
-    "PySide2.QtCore.QFileDevice.size": (),
-    "PySide2.QtCore.QFileDevice.unmap": ('str',),
-    "PySide2.QtCore.QFileDevice.unsetError": (),
-    "PySide2.QtCore.QFileDevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QFileInfo:
-    "PySide2.QtCore.QFileInfo.__init__": [(), ('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('PySide2.QtCore.QFileInfo',), ('str',)],
-    "PySide2.QtCore.QFileInfo.__copy__": (),
-    "PySide2.QtCore.QFileInfo.__reduce__": (),
-    "PySide2.QtCore.QFileInfo.absoluteDir": (),
-    "PySide2.QtCore.QFileInfo.absoluteFilePath": (),
-    "PySide2.QtCore.QFileInfo.absolutePath": (),
-    "PySide2.QtCore.QFileInfo.baseName": (),
-    "PySide2.QtCore.QFileInfo.birthTime": (),
-    "PySide2.QtCore.QFileInfo.bundleName": (),
-    "PySide2.QtCore.QFileInfo.caching": (),
-    "PySide2.QtCore.QFileInfo.canonicalFilePath": (),
-    "PySide2.QtCore.QFileInfo.canonicalPath": (),
-    "PySide2.QtCore.QFileInfo.completeBaseName": (),
-    "PySide2.QtCore.QFileInfo.completeSuffix": (),
-    "PySide2.QtCore.QFileInfo.created": (),
-    "PySide2.QtCore.QFileInfo.dir": (),
-    "PySide2.QtCore.QFileInfo.exists": [(), ('str',)],
-    "PySide2.QtCore.QFileInfo.fileName": (),
-    "PySide2.QtCore.QFileInfo.filePath": (),
-    "PySide2.QtCore.QFileInfo.group": (),
-    "PySide2.QtCore.QFileInfo.groupId": (),
-    "PySide2.QtCore.QFileInfo.isAbsolute": (),
-    "PySide2.QtCore.QFileInfo.isBundle": (),
-    "PySide2.QtCore.QFileInfo.isDir": (),
-    "PySide2.QtCore.QFileInfo.isExecutable": (),
-    "PySide2.QtCore.QFileInfo.isFile": (),
-    "PySide2.QtCore.QFileInfo.isHidden": (),
-    "PySide2.QtCore.QFileInfo.isNativePath": (),
-    "PySide2.QtCore.QFileInfo.isReadable": (),
-    "PySide2.QtCore.QFileInfo.isRelative": (),
-    "PySide2.QtCore.QFileInfo.isRoot": (),
-    "PySide2.QtCore.QFileInfo.isShortcut": (),
-    "PySide2.QtCore.QFileInfo.isSymLink": (),
-    "PySide2.QtCore.QFileInfo.isSymbolicLink": (),
-    "PySide2.QtCore.QFileInfo.isWritable": (),
-    "PySide2.QtCore.QFileInfo.lastModified": (),
-    "PySide2.QtCore.QFileInfo.lastRead": (),
-    "PySide2.QtCore.QFileInfo.makeAbsolute": (),
-    "PySide2.QtCore.QFileInfo.metadataChangeTime": (),
-    "PySide2.QtCore.QFileInfo.owner": (),
-    "PySide2.QtCore.QFileInfo.ownerId": (),
-    "PySide2.QtCore.QFileInfo.path": (),
-    "PySide2.QtCore.QFileInfo.readLink": (),
-    "PySide2.QtCore.QFileInfo.refresh": (),
-    "PySide2.QtCore.QFileInfo.setCaching": ('bool',),
-    "PySide2.QtCore.QFileInfo.setFile": [('PySide2.QtCore.QDir', 'str'), ('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QFileInfo.size": (),
-    "PySide2.QtCore.QFileInfo.suffix": (),
-    "PySide2.QtCore.QFileInfo.swap": ('PySide2.QtCore.QFileInfo',),
-    "PySide2.QtCore.QFileInfo.symLinkTarget": (),
-# class PySide2.QtCore.QFileSelector:
-    "PySide2.QtCore.QFileSelector.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QFileSelector.allSelectors": (),
-    "PySide2.QtCore.QFileSelector.extraSelectors": (),
-    "PySide2.QtCore.QFileSelector.select": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtCore.QFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFileSystemWatcher:
-    "PySide2.QtCore.QFileSystemWatcher.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QFileSystemWatcher.addPath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.addPaths": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QFileSystemWatcher.directories": (),
-    "PySide2.QtCore.QFileSystemWatcher.files": (),
-    "PySide2.QtCore.QFileSystemWatcher.removePath": ('str',),
-    "PySide2.QtCore.QFileSystemWatcher.removePaths": ('typing.Sequence[str]',),
-# class PySide2.QtCore.QFinalState:
-    "PySide2.QtCore.QFinalState.__init__": ('PySide2.QtCore.QState',),
-    "PySide2.QtCore.QFinalState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QFinalState.onExit": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtCore.QGenericArgument:
-    "PySide2.QtCore.QGenericArgument.__init__": [('PySide2.QtCore.QGenericArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericArgument.__copy__": (),
-    "PySide2.QtCore.QGenericArgument.data": (),
-    "PySide2.QtCore.QGenericArgument.name": (),
-# class PySide2.QtCore.QGenericReturnArgument:
-    "PySide2.QtCore.QGenericReturnArgument.__init__": [('PySide2.QtCore.QGenericReturnArgument',), ('str', 'int')],
-    "PySide2.QtCore.QGenericReturnArgument.__copy__": (),
-# class PySide2.QtCore.QHistoryState:
-# class PySide2.QtCore.QHistoryState.HistoryType:
-    "PySide2.QtCore.QHistoryState.__init__": [('PySide2.QtCore.QHistoryState.HistoryType', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtCore.QHistoryState.defaultState": (),
-    "PySide2.QtCore.QHistoryState.defaultTransition": (),
-    "PySide2.QtCore.QHistoryState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.historyType": (),
-    "PySide2.QtCore.QHistoryState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QHistoryState.setDefaultState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QHistoryState.setDefaultTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QHistoryState.setHistoryType": ('PySide2.QtCore.QHistoryState.HistoryType',),
-# class PySide2.QtCore.QIODevice:
-# class PySide2.QtCore.QIODevice.OpenMode:
-# class PySide2.QtCore.QIODevice.OpenModeFlag:
-    "PySide2.QtCore.QIODevice.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QIODevice.atEnd": (),
-    "PySide2.QtCore.QIODevice.bytesAvailable": (),
-    "PySide2.QtCore.QIODevice.bytesToWrite": (),
-    "PySide2.QtCore.QIODevice.canReadLine": (),
-    "PySide2.QtCore.QIODevice.close": (),
-    "PySide2.QtCore.QIODevice.commitTransaction": (),
-    "PySide2.QtCore.QIODevice.currentReadChannel": (),
-    "PySide2.QtCore.QIODevice.currentWriteChannel": (),
-    "PySide2.QtCore.QIODevice.errorString": (),
-    "PySide2.QtCore.QIODevice.getChar": ('str',),
-    "PySide2.QtCore.QIODevice.isOpen": (),
-    "PySide2.QtCore.QIODevice.isReadable": (),
-    "PySide2.QtCore.QIODevice.isSequential": (),
-    "PySide2.QtCore.QIODevice.isTextModeEnabled": (),
-    "PySide2.QtCore.QIODevice.isTransactionStarted": (),
-    "PySide2.QtCore.QIODevice.isWritable": (),
-    "PySide2.QtCore.QIODevice.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.openMode": (),
-    "PySide2.QtCore.QIODevice.peek": ('int',),
-    "PySide2.QtCore.QIODevice.pos": (),
-    "PySide2.QtCore.QIODevice.putChar": ('int',),
-    "PySide2.QtCore.QIODevice.read": ('int',),
-    "PySide2.QtCore.QIODevice.readAll": (),
-    "PySide2.QtCore.QIODevice.readChannelCount": (),
-    "PySide2.QtCore.QIODevice.readData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.readLine": ('int',),
-    "PySide2.QtCore.QIODevice.readLineData": ('str', 'int'),
-    "PySide2.QtCore.QIODevice.reset": (),
-    "PySide2.QtCore.QIODevice.rollbackTransaction": (),
-    "PySide2.QtCore.QIODevice.seek": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentReadChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setCurrentWriteChannel": ('int',),
-    "PySide2.QtCore.QIODevice.setErrorString": ('str',),
-    "PySide2.QtCore.QIODevice.setOpenMode": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QIODevice.setTextModeEnabled": ('bool',),
-    "PySide2.QtCore.QIODevice.size": (),
-    "PySide2.QtCore.QIODevice.skip": ('int',),
-    "PySide2.QtCore.QIODevice.startTransaction": (),
-    "PySide2.QtCore.QIODevice.ungetChar": ('int',),
-    "PySide2.QtCore.QIODevice.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QIODevice.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QIODevice.write": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QIODevice.writeChannelCount": (),
-    "PySide2.QtCore.QIODevice.writeData": ('str', 'int'),
-# class PySide2.QtCore.QIdentityProxyModel:
-    "PySide2.QtCore.QIdentityProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QIdentityProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QIdentityProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QIdentityProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QIdentityProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QIdentityProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QIdentityProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QIdentityProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QIdentityProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtCore.QItemSelection:
-    "PySide2.QtCore.QItemSelection.__init__": [(), ('PySide2.QtCore.QItemSelection',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelection.__add__": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.__copy__": (),
-    "PySide2.QtCore.QItemSelection.__iadd__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.__lshift__": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.append": [('PySide2.QtCore.QItemSelectionRange',), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.at": ('int',),
-    "PySide2.QtCore.QItemSelection.back": (),
-    "PySide2.QtCore.QItemSelection.clear": (),
-    "PySide2.QtCore.QItemSelection.constFirst": (),
-    "PySide2.QtCore.QItemSelection.constLast": (),
-    "PySide2.QtCore.QItemSelection.contains": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelection.count": [(), ('PySide2.QtCore.QItemSelectionRange',)],
-    "PySide2.QtCore.QItemSelection.detachShared": (),
-    "PySide2.QtCore.QItemSelection.empty": (),
-    "PySide2.QtCore.QItemSelection.endsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.first": (),
-    "PySide2.QtCore.QItemSelection.fromSet": ('typing.Set[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.fromVector": ('typing.List[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.front": (),
-    "PySide2.QtCore.QItemSelection.indexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.indexes": (),
-    "PySide2.QtCore.QItemSelection.insert": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.isEmpty": (),
-    "PySide2.QtCore.QItemSelection.isSharedWith": ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',),
-    "PySide2.QtCore.QItemSelection.last": (),
-    "PySide2.QtCore.QItemSelection.lastIndexOf": ('PySide2.QtCore.QItemSelectionRange', 'int'),
-    "PySide2.QtCore.QItemSelection.length": (),
-    "PySide2.QtCore.QItemSelection.merge": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelection.mid": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.move": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.pop_back": (),
-    "PySide2.QtCore.QItemSelection.pop_front": (),
-    "PySide2.QtCore.QItemSelection.prepend": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_back": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.push_front": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAll": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.removeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.removeFirst": (),
-    "PySide2.QtCore.QItemSelection.removeLast": (),
-    "PySide2.QtCore.QItemSelection.removeOne": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.replace": ('int', 'PySide2.QtCore.QItemSelectionRange'),
-    "PySide2.QtCore.QItemSelection.reserve": ('int',),
-    "PySide2.QtCore.QItemSelection.select": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelection.setSharable": ('bool',),
-    "PySide2.QtCore.QItemSelection.size": (),
-    "PySide2.QtCore.QItemSelection.split": ('PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelectionRange', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelection.startsWith": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelection.swap": [('int', 'int'), ('typing.Sequence[PySide2.QtCore.QItemSelectionRange]',)],
-    "PySide2.QtCore.QItemSelection.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QItemSelection.takeAt": ('int',),
-    "PySide2.QtCore.QItemSelection.takeFirst": (),
-    "PySide2.QtCore.QItemSelection.takeLast": (),
-    "PySide2.QtCore.QItemSelection.toSet": (),
-    "PySide2.QtCore.QItemSelection.toVector": (),
-    "PySide2.QtCore.QItemSelection.value": [('int',), ('int', 'PySide2.QtCore.QItemSelectionRange')],
-# class PySide2.QtCore.QItemSelectionModel:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlag:
-# class PySide2.QtCore.QItemSelectionModel.SelectionFlags:
-    "PySide2.QtCore.QItemSelectionModel.__init__": [('PySide2.QtCore.QAbstractItemModel',), ('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QItemSelectionModel.clear": (),
-    "PySide2.QtCore.QItemSelectionModel.clearCurrentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.clearSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.columnIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.currentIndex": (),
-    "PySide2.QtCore.QItemSelectionModel.emitSelectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtCore.QItemSelectionModel.hasSelection": (),
-    "PySide2.QtCore.QItemSelectionModel.isColumnSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isRowSelected": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.isSelected": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QItemSelectionModel.model": (),
-    "PySide2.QtCore.QItemSelectionModel.reset": (),
-    "PySide2.QtCore.QItemSelectionModel.rowIntersectsSelection": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QItemSelectionModel.select": [('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtCore.QItemSelectionModel.selectedColumns": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selectedIndexes": (),
-    "PySide2.QtCore.QItemSelectionModel.selectedRows": ('int',),
-    "PySide2.QtCore.QItemSelectionModel.selection": (),
-    "PySide2.QtCore.QItemSelectionModel.setCurrentIndex": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtCore.QItemSelectionModel.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-# class PySide2.QtCore.QItemSelectionRange:
-    "PySide2.QtCore.QItemSelectionRange.__init__": [(), ('PySide2.QtCore.QItemSelectionRange',), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.__copy__": (),
-    "PySide2.QtCore.QItemSelectionRange.bottom": (),
-    "PySide2.QtCore.QItemSelectionRange.bottomRight": (),
-    "PySide2.QtCore.QItemSelectionRange.contains": [('PySide2.QtCore.QModelIndex',), ('int', 'int', 'PySide2.QtCore.QModelIndex')],
-    "PySide2.QtCore.QItemSelectionRange.height": (),
-    "PySide2.QtCore.QItemSelectionRange.indexes": (),
-    "PySide2.QtCore.QItemSelectionRange.intersected": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.intersects": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.isEmpty": (),
-    "PySide2.QtCore.QItemSelectionRange.isValid": (),
-    "PySide2.QtCore.QItemSelectionRange.left": (),
-    "PySide2.QtCore.QItemSelectionRange.model": (),
-    "PySide2.QtCore.QItemSelectionRange.parent": (),
-    "PySide2.QtCore.QItemSelectionRange.right": (),
-    "PySide2.QtCore.QItemSelectionRange.swap": ('PySide2.QtCore.QItemSelectionRange',),
-    "PySide2.QtCore.QItemSelectionRange.top": (),
-    "PySide2.QtCore.QItemSelectionRange.topLeft": (),
-    "PySide2.QtCore.QItemSelectionRange.width": (),
-# class PySide2.QtCore.QJsonArray:
-    "PySide2.QtCore.QJsonArray.__init__": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonArray.__add__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__copy__": (),
-    "PySide2.QtCore.QJsonArray.__iadd__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.__lshift__": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.append": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.at": ('int',),
-    "PySide2.QtCore.QJsonArray.contains": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.count": (),
-    "PySide2.QtCore.QJsonArray.empty": (),
-    "PySide2.QtCore.QJsonArray.first": (),
-    "PySide2.QtCore.QJsonArray.fromStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QJsonArray.fromVariantList": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtCore.QJsonArray.insert": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.isEmpty": (),
-    "PySide2.QtCore.QJsonArray.last": (),
-    "PySide2.QtCore.QJsonArray.pop_back": (),
-    "PySide2.QtCore.QJsonArray.pop_front": (),
-    "PySide2.QtCore.QJsonArray.prepend": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_back": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.push_front": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonArray.removeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.removeFirst": (),
-    "PySide2.QtCore.QJsonArray.removeLast": (),
-    "PySide2.QtCore.QJsonArray.replace": ('int', 'PySide2.QtCore.QJsonValue'),
-    "PySide2.QtCore.QJsonArray.size": (),
-    "PySide2.QtCore.QJsonArray.swap": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonArray.takeAt": ('int',),
-    "PySide2.QtCore.QJsonArray.toVariantList": (),
-# class PySide2.QtCore.QJsonDocument:
-# class PySide2.QtCore.QJsonDocument.DataValidation:
-# class PySide2.QtCore.QJsonDocument.JsonFormat:
-    "PySide2.QtCore.QJsonDocument.__init__": [(), ('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonDocument',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonDocument.__copy__": (),
-    "PySide2.QtCore.QJsonDocument.array": (),
-    "PySide2.QtCore.QJsonDocument.fromBinaryData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromJson": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QJsonParseError'),
-    "PySide2.QtCore.QJsonDocument.fromRawData": ('str', 'int', 'PySide2.QtCore.QJsonDocument.DataValidation'),
-    "PySide2.QtCore.QJsonDocument.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonDocument.isArray": (),
-    "PySide2.QtCore.QJsonDocument.isEmpty": (),
-    "PySide2.QtCore.QJsonDocument.isNull": (),
-    "PySide2.QtCore.QJsonDocument.isObject": (),
-    "PySide2.QtCore.QJsonDocument.object": (),
-    "PySide2.QtCore.QJsonDocument.rawData": (),
-    "PySide2.QtCore.QJsonDocument.setArray": ('PySide2.QtCore.QJsonArray',),
-    "PySide2.QtCore.QJsonDocument.setObject": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    "PySide2.QtCore.QJsonDocument.swap": ('PySide2.QtCore.QJsonDocument',),
-    "PySide2.QtCore.QJsonDocument.toBinaryData": (),
-    "PySide2.QtCore.QJsonDocument.toJson": [(), ('PySide2.QtCore.QJsonDocument.JsonFormat',)],
-    "PySide2.QtCore.QJsonDocument.toVariant": (),
-# class PySide2.QtCore.QJsonParseError:
-# class PySide2.QtCore.QJsonParseError.ParseError:
-    "PySide2.QtCore.QJsonParseError.__init__": [(), ('PySide2.QtCore.QJsonParseError',)],
-    "PySide2.QtCore.QJsonParseError.__copy__": (),
-    "PySide2.QtCore.QJsonParseError.errorString": (),
-# class PySide2.QtCore.QJsonValue:
-# class PySide2.QtCore.QJsonValue.Type:
-    "PySide2.QtCore.QJsonValue.__init__": [('PySide2.QtCore.QJsonArray',), ('PySide2.QtCore.QJsonValue',), ('PySide2.QtCore.QJsonValue.Type',), ('bool',), ('float',), ('int',), ('str',), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.__copy__": (),
-    "PySide2.QtCore.QJsonValue.fromVariant": ('typing.Any',),
-    "PySide2.QtCore.QJsonValue.isArray": (),
-    "PySide2.QtCore.QJsonValue.isBool": (),
-    "PySide2.QtCore.QJsonValue.isDouble": (),
-    "PySide2.QtCore.QJsonValue.isNull": (),
-    "PySide2.QtCore.QJsonValue.isObject": (),
-    "PySide2.QtCore.QJsonValue.isString": (),
-    "PySide2.QtCore.QJsonValue.isUndefined": (),
-    "PySide2.QtCore.QJsonValue.swap": ('PySide2.QtCore.QJsonValue',),
-    "PySide2.QtCore.QJsonValue.toArray": [(), ('PySide2.QtCore.QJsonArray',)],
-    "PySide2.QtCore.QJsonValue.toBool": ('bool',),
-    "PySide2.QtCore.QJsonValue.toDouble": ('float',),
-    "PySide2.QtCore.QJsonValue.toInt": ('int',),
-    "PySide2.QtCore.QJsonValue.toObject": [(), ('typing.Dict[str, PySide2.QtCore.QJsonValue]',)],
-    "PySide2.QtCore.QJsonValue.toString": [(), ('str',)],
-    "PySide2.QtCore.QJsonValue.toVariant": (),
-    "PySide2.QtCore.QJsonValue.type": (),
-# class PySide2.QtCore.QLibraryInfo:
-# class PySide2.QtCore.QLibraryInfo.LibraryLocation:
-    "PySide2.QtCore.QLibraryInfo.build": (),
-    "PySide2.QtCore.QLibraryInfo.buildDate": (),
-    "PySide2.QtCore.QLibraryInfo.isDebugBuild": (),
-    "PySide2.QtCore.QLibraryInfo.licensedProducts": (),
-    "PySide2.QtCore.QLibraryInfo.licensee": (),
-    "PySide2.QtCore.QLibraryInfo.location": ('PySide2.QtCore.QLibraryInfo.LibraryLocation',),
-    "PySide2.QtCore.QLibraryInfo.platformPluginArguments": ('str',),
-    "PySide2.QtCore.QLibraryInfo.version": (),
-# class PySide2.QtCore.QLine:
-    "PySide2.QtCore.QLine.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QLine.__copy__": (),
-    "PySide2.QtCore.QLine.__reduce__": (),
-    "PySide2.QtCore.QLine.__repr__": (),
-    "PySide2.QtCore.QLine.center": (),
-    "PySide2.QtCore.QLine.dx": (),
-    "PySide2.QtCore.QLine.dy": (),
-    "PySide2.QtCore.QLine.isNull": (),
-    "PySide2.QtCore.QLine.p1": (),
-    "PySide2.QtCore.QLine.p2": (),
-    "PySide2.QtCore.QLine.setLine": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QLine.setP1": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setP2": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QLine.setPoints": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QLine.toTuple": (),
-    "PySide2.QtCore.QLine.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QLine.x1": (),
-    "PySide2.QtCore.QLine.x2": (),
-    "PySide2.QtCore.QLine.y1": (),
-    "PySide2.QtCore.QLine.y2": (),
-# class PySide2.QtCore.QLineF:
-# class PySide2.QtCore.QLineF.IntersectType:
-    "PySide2.QtCore.QLineF.__init__": [(), ('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QLineF.__copy__": (),
-    "PySide2.QtCore.QLineF.__reduce__": (),
-    "PySide2.QtCore.QLineF.__repr__": (),
-    "PySide2.QtCore.QLineF.angle": [(), ('PySide2.QtCore.QLineF',)],
-    "PySide2.QtCore.QLineF.angleTo": ('PySide2.QtCore.QLineF',),
-    "PySide2.QtCore.QLineF.center": (),
-    "PySide2.QtCore.QLineF.dx": (),
-    "PySide2.QtCore.QLineF.dy": (),
-    "PySide2.QtCore.QLineF.fromPolar": ('float', 'float'),
-    "PySide2.QtCore.QLineF.intersect": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.intersects": ('PySide2.QtCore.QLineF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.isNull": (),
-    "PySide2.QtCore.QLineF.length": (),
-    "PySide2.QtCore.QLineF.normalVector": (),
-    "PySide2.QtCore.QLineF.p1": (),
-    "PySide2.QtCore.QLineF.p2": (),
-    "PySide2.QtCore.QLineF.pointAt": ('float',),
-    "PySide2.QtCore.QLineF.setAngle": ('float',),
-    "PySide2.QtCore.QLineF.setLength": ('float',),
-    "PySide2.QtCore.QLineF.setLine": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QLineF.setP1": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setP2": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QLineF.setPoints": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QLineF.toLine": (),
-    "PySide2.QtCore.QLineF.toTuple": (),
-    "PySide2.QtCore.QLineF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QLineF.unitVector": (),
-    "PySide2.QtCore.QLineF.x1": (),
-    "PySide2.QtCore.QLineF.x2": (),
-    "PySide2.QtCore.QLineF.y1": (),
-    "PySide2.QtCore.QLineF.y2": (),
-# class PySide2.QtCore.QLocale:
-# class PySide2.QtCore.QLocale.Country:
-# class PySide2.QtCore.QLocale.CurrencySymbolFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormat:
-# class PySide2.QtCore.QLocale.DataSizeFormats:
-# class PySide2.QtCore.QLocale.FloatingPointPrecisionOption:
-# class PySide2.QtCore.QLocale.FormatType:
-# class PySide2.QtCore.QLocale.Language:
-# class PySide2.QtCore.QLocale.MeasurementSystem:
-# class PySide2.QtCore.QLocale.NumberOption:
-# class PySide2.QtCore.QLocale.NumberOptions:
-# class PySide2.QtCore.QLocale.QuotationStyle:
-# class PySide2.QtCore.QLocale.Script:
-    "PySide2.QtCore.QLocale.__init__": [(), ('PySide2.QtCore.QLocale',), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Country'), ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'), ('str',)],
-    "PySide2.QtCore.QLocale.__copy__": (),
-    "PySide2.QtCore.QLocale.amText": (),
-    "PySide2.QtCore.QLocale.bcp47Name": (),
-    "PySide2.QtCore.QLocale.c": (),
-    "PySide2.QtCore.QLocale.collation": (),
-    "PySide2.QtCore.QLocale.countriesForLanguage": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.country": (),
-    "PySide2.QtCore.QLocale.countryToString": ('PySide2.QtCore.QLocale.Country',),
-    "PySide2.QtCore.QLocale.createSeparatedList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QLocale.currencySymbol": ('PySide2.QtCore.QLocale.CurrencySymbolFormat',),
-    "PySide2.QtCore.QLocale.dateFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dateTimeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.dayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.decimalPoint": (),
-    "PySide2.QtCore.QLocale.exponential": (),
-    "PySide2.QtCore.QLocale.firstDayOfWeek": (),
-    "PySide2.QtCore.QLocale.formattedDataSize": ('int', 'int', 'PySide2.QtCore.QLocale.DataSizeFormats'),
-    "PySide2.QtCore.QLocale.groupSeparator": (),
-    "PySide2.QtCore.QLocale.language": (),
-    "PySide2.QtCore.QLocale.languageToString": ('PySide2.QtCore.QLocale.Language',),
-    "PySide2.QtCore.QLocale.matchingLocales": ('PySide2.QtCore.QLocale.Language', 'PySide2.QtCore.QLocale.Script', 'PySide2.QtCore.QLocale.Country'),
-    "PySide2.QtCore.QLocale.measurementSystem": (),
-    "PySide2.QtCore.QLocale.monthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.name": (),
-    "PySide2.QtCore.QLocale.nativeCountryName": (),
-    "PySide2.QtCore.QLocale.nativeLanguageName": (),
-    "PySide2.QtCore.QLocale.negativeSign": (),
-    "PySide2.QtCore.QLocale.numberOptions": (),
-    "PySide2.QtCore.QLocale.percent": (),
-    "PySide2.QtCore.QLocale.pmText": (),
-    "PySide2.QtCore.QLocale.positiveSign": (),
-    "PySide2.QtCore.QLocale.quoteString": ('str', 'PySide2.QtCore.QLocale.QuotationStyle'),
-    "PySide2.QtCore.QLocale.script": (),
-    "PySide2.QtCore.QLocale.scriptToString": ('PySide2.QtCore.QLocale.Script',),
-    "PySide2.QtCore.QLocale.setDefault": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.setNumberOptions": ('PySide2.QtCore.QLocale.NumberOptions',),
-    "PySide2.QtCore.QLocale.standaloneDayName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.standaloneMonthName": ('int', 'PySide2.QtCore.QLocale.FormatType'),
-    "PySide2.QtCore.QLocale.swap": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QLocale.system": (),
-    "PySide2.QtCore.QLocale.textDirection": (),
-    "PySide2.QtCore.QLocale.timeFormat": ('PySide2.QtCore.QLocale.FormatType',),
-    "PySide2.QtCore.QLocale.toCurrencyString": [('float', 'str'), ('float', 'str', 'int'), ('int', 'str')],
-    "PySide2.QtCore.QLocale.toDate": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDateTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toDouble": ('str',),
-    "PySide2.QtCore.QLocale.toFloat": ('str',),
-    "PySide2.QtCore.QLocale.toInt": ('str',),
-    "PySide2.QtCore.QLocale.toLong": ('str',),
-    "PySide2.QtCore.QLocale.toLongLong": ('str',),
-    "PySide2.QtCore.QLocale.toLower": ('str',),
-    "PySide2.QtCore.QLocale.toShort": ('str',),
-    "PySide2.QtCore.QLocale.toString": [('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDate', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDate', 'str'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('PySide2.QtCore.QDateTime', 'str'), ('PySide2.QtCore.QTime', 'PySide2.QtCore.QLocale.FormatType'), ('PySide2.QtCore.QTime', 'str'), ('float', 'int', 'int'), ('int',)],
-    "PySide2.QtCore.QLocale.toTime": [('str', 'PySide2.QtCore.QLocale.FormatType'), ('str', 'PySide2.QtCore.QLocale.FormatType', 'PySide2.QtCore.QCalendar'), ('str', 'str'), ('str', 'str', 'PySide2.QtCore.QCalendar')],
-    "PySide2.QtCore.QLocale.toUInt": ('str',),
-    "PySide2.QtCore.QLocale.toULong": ('str',),
-    "PySide2.QtCore.QLocale.toULongLong": ('str',),
-    "PySide2.QtCore.QLocale.toUShort": ('str',),
-    "PySide2.QtCore.QLocale.toUpper": ('str',),
-    "PySide2.QtCore.QLocale.uiLanguages": (),
-    "PySide2.QtCore.QLocale.weekdays": (),
-    "PySide2.QtCore.QLocale.zeroDigit": (),
-# class PySide2.QtCore.QLockFile:
-# class PySide2.QtCore.QLockFile.LockError:
-    "PySide2.QtCore.QLockFile.__init__": ('str',),
-    "PySide2.QtCore.QLockFile.error": (),
-    "PySide2.QtCore.QLockFile.getLockInfo": (),
-    "PySide2.QtCore.QLockFile.isLocked": (),
-    "PySide2.QtCore.QLockFile.lock": (),
-    "PySide2.QtCore.QLockFile.removeStaleLockFile": (),
-    "PySide2.QtCore.QLockFile.setStaleLockTime": ('int',),
-    "PySide2.QtCore.QLockFile.staleLockTime": (),
-    "PySide2.QtCore.QLockFile.tryLock": ('int',),
-    "PySide2.QtCore.QLockFile.unlock": (),
-# class PySide2.QtCore.QMargins:
-    "PySide2.QtCore.QMargins.__init__": [(), ('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QMargins.__add__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__copy__": (),
-    "PySide2.QtCore.QMargins.__iadd__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__isub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QMargins.__neg__": (),
-    "PySide2.QtCore.QMargins.__pos__": (),
-    "PySide2.QtCore.QMargins.__sub__": [('PySide2.QtCore.QMargins',), ('int',)],
-    "PySide2.QtCore.QMargins.bottom": (),
-    "PySide2.QtCore.QMargins.isNull": (),
-    "PySide2.QtCore.QMargins.left": (),
-    "PySide2.QtCore.QMargins.right": (),
-    "PySide2.QtCore.QMargins.setBottom": ('int',),
-    "PySide2.QtCore.QMargins.setLeft": ('int',),
-    "PySide2.QtCore.QMargins.setRight": ('int',),
-    "PySide2.QtCore.QMargins.setTop": ('int',),
-    "PySide2.QtCore.QMargins.top": (),
-# class PySide2.QtCore.QMarginsF:
-    "PySide2.QtCore.QMarginsF.__init__": [(), ('PySide2.QtCore.QMargins',), ('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QMarginsF.__add__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__copy__": (),
-    "PySide2.QtCore.QMarginsF.__iadd__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__imul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__isub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.__mul__": ('float',),
-    "PySide2.QtCore.QMarginsF.__neg__": (),
-    "PySide2.QtCore.QMarginsF.__pos__": (),
-    "PySide2.QtCore.QMarginsF.__sub__": [('PySide2.QtCore.QMarginsF',), ('float',)],
-    "PySide2.QtCore.QMarginsF.bottom": (),
-    "PySide2.QtCore.QMarginsF.isNull": (),
-    "PySide2.QtCore.QMarginsF.left": (),
-    "PySide2.QtCore.QMarginsF.right": (),
-    "PySide2.QtCore.QMarginsF.setBottom": ('float',),
-    "PySide2.QtCore.QMarginsF.setLeft": ('float',),
-    "PySide2.QtCore.QMarginsF.setRight": ('float',),
-    "PySide2.QtCore.QMarginsF.setTop": ('float',),
-    "PySide2.QtCore.QMarginsF.toMargins": (),
-    "PySide2.QtCore.QMarginsF.top": (),
-# class PySide2.QtCore.QMessageAuthenticationCode:
-    "PySide2.QtCore.QMessageAuthenticationCode.__init__": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMessageAuthenticationCode.addData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str', 'int')],
-    "PySide2.QtCore.QMessageAuthenticationCode.hash": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QCryptographicHash.Algorithm'),
-    "PySide2.QtCore.QMessageAuthenticationCode.reset": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.result": (),
-    "PySide2.QtCore.QMessageAuthenticationCode.setKey": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QMessageLogContext:
-    "PySide2.QtCore.QMessageLogContext.__init__": [(), ('str', 'int', 'str', 'str')],
-# class PySide2.QtCore.QMetaClassInfo:
-    "PySide2.QtCore.QMetaClassInfo.__init__": [(), ('PySide2.QtCore.QMetaClassInfo',)],
-    "PySide2.QtCore.QMetaClassInfo.__copy__": (),
-    "PySide2.QtCore.QMetaClassInfo.name": (),
-    "PySide2.QtCore.QMetaClassInfo.value": (),
-# class PySide2.QtCore.QMetaEnum:
-    "PySide2.QtCore.QMetaEnum.__init__": [(), ('PySide2.QtCore.QMetaEnum',)],
-    "PySide2.QtCore.QMetaEnum.__copy__": (),
-    "PySide2.QtCore.QMetaEnum.enumName": (),
-    "PySide2.QtCore.QMetaEnum.isFlag": (),
-    "PySide2.QtCore.QMetaEnum.isScoped": (),
-    "PySide2.QtCore.QMetaEnum.isValid": (),
-    "PySide2.QtCore.QMetaEnum.key": ('int',),
-    "PySide2.QtCore.QMetaEnum.keyCount": (),
-    "PySide2.QtCore.QMetaEnum.keyToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.keysToValue": ('str',),
-    "PySide2.QtCore.QMetaEnum.name": (),
-    "PySide2.QtCore.QMetaEnum.scope": (),
-    "PySide2.QtCore.QMetaEnum.value": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKey": ('int',),
-    "PySide2.QtCore.QMetaEnum.valueToKeys": ('int',),
-# class PySide2.QtCore.QMetaMethod:
-# class PySide2.QtCore.QMetaMethod.Access:
-# class PySide2.QtCore.QMetaMethod.MethodType:
-    "PySide2.QtCore.QMetaMethod.__init__": [(), ('PySide2.QtCore.QMetaMethod',)],
-    "PySide2.QtCore.QMetaMethod.__copy__": (),
-    "PySide2.QtCore.QMetaMethod.access": (),
-    "PySide2.QtCore.QMetaMethod.enclosingMetaObject": (),
-    "PySide2.QtCore.QMetaMethod.invoke": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.invokeOnGadget": [('int', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('int', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaMethod.isValid": (),
-    "PySide2.QtCore.QMetaMethod.methodIndex": (),
-    "PySide2.QtCore.QMetaMethod.methodSignature": (),
-    "PySide2.QtCore.QMetaMethod.methodType": (),
-    "PySide2.QtCore.QMetaMethod.name": (),
-    "PySide2.QtCore.QMetaMethod.parameterCount": (),
-    "PySide2.QtCore.QMetaMethod.parameterNames": (),
-    "PySide2.QtCore.QMetaMethod.parameterType": ('int',),
-    "PySide2.QtCore.QMetaMethod.parameterTypes": (),
-    "PySide2.QtCore.QMetaMethod.returnType": (),
-    "PySide2.QtCore.QMetaMethod.revision": (),
-    "PySide2.QtCore.QMetaMethod.tag": (),
-    "PySide2.QtCore.QMetaMethod.typeName": (),
-# class PySide2.QtCore.QMetaObject:
-# class PySide2.QtCore.QMetaObject.Call:
-# class PySide2.QtCore.QMetaObject.Connection:
-    "PySide2.QtCore.QMetaObject.Connection.__init__": [(), ('PySide2.QtCore.QMetaObject.Connection',)],
-    "PySide2.QtCore.QMetaObject.__init__": (),
-    "PySide2.QtCore.QMetaObject.cast": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.checkConnectArgs": [('PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QMetaMethod'), ('str', 'str')],
-    "PySide2.QtCore.QMetaObject.classInfo": ('int',),
-    "PySide2.QtCore.QMetaObject.classInfoCount": (),
-    "PySide2.QtCore.QMetaObject.classInfoOffset": (),
-    "PySide2.QtCore.QMetaObject.className": (),
-    "PySide2.QtCore.QMetaObject.connectSlotsByName": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaObject.constructor": ('int',),
-    "PySide2.QtCore.QMetaObject.constructorCount": (),
-    "PySide2.QtCore.QMetaObject.disconnect": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.disconnectOne": ('PySide2.QtCore.QObject', 'int', 'PySide2.QtCore.QObject', 'int'),
-    "PySide2.QtCore.QMetaObject.enumerator": ('int',),
-    "PySide2.QtCore.QMetaObject.enumeratorCount": (),
-    "PySide2.QtCore.QMetaObject.enumeratorOffset": (),
-    "PySide2.QtCore.QMetaObject.indexOfClassInfo": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfConstructor": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfEnumerator": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfMethod": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfProperty": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSignal": ('str',),
-    "PySide2.QtCore.QMetaObject.indexOfSlot": ('str',),
-    "PySide2.QtCore.QMetaObject.inherits": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtCore.QMetaObject.invokeMethod": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType', 'PySide2.QtCore.QGenericReturnArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument')],
-    "PySide2.QtCore.QMetaObject.method": ('int',),
-    "PySide2.QtCore.QMetaObject.methodCount": (),
-    "PySide2.QtCore.QMetaObject.methodOffset": (),
-    "PySide2.QtCore.QMetaObject.newInstance": ('PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument', 'PySide2.QtCore.QGenericArgument'),
-    "PySide2.QtCore.QMetaObject.normalizedSignature": ('str',),
-    "PySide2.QtCore.QMetaObject.normalizedType": ('str',),
-    "PySide2.QtCore.QMetaObject.property": ('int',),
-    "PySide2.QtCore.QMetaObject.propertyCount": (),
-    "PySide2.QtCore.QMetaObject.propertyOffset": (),
-    "PySide2.QtCore.QMetaObject.superClass": (),
-    "PySide2.QtCore.QMetaObject.userProperty": (),
-# class PySide2.QtCore.QMetaProperty:
-    "PySide2.QtCore.QMetaProperty.__init__": [(), ('PySide2.QtCore.QMetaProperty',)],
-    "PySide2.QtCore.QMetaProperty.__copy__": (),
-    "PySide2.QtCore.QMetaProperty.enumerator": (),
-    "PySide2.QtCore.QMetaProperty.hasNotifySignal": (),
-    "PySide2.QtCore.QMetaProperty.hasStdCppSet": (),
-    "PySide2.QtCore.QMetaProperty.isConstant": (),
-    "PySide2.QtCore.QMetaProperty.isDesignable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEditable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isEnumType": (),
-    "PySide2.QtCore.QMetaProperty.isFinal": (),
-    "PySide2.QtCore.QMetaProperty.isFlagType": (),
-    "PySide2.QtCore.QMetaProperty.isReadable": (),
-    "PySide2.QtCore.QMetaProperty.isResettable": (),
-    "PySide2.QtCore.QMetaProperty.isScriptable": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isStored": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isUser": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.isValid": (),
-    "PySide2.QtCore.QMetaProperty.isWritable": (),
-    "PySide2.QtCore.QMetaProperty.name": (),
-    "PySide2.QtCore.QMetaProperty.notifySignal": (),
-    "PySide2.QtCore.QMetaProperty.notifySignalIndex": (),
-    "PySide2.QtCore.QMetaProperty.propertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.read": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.readOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.relativePropertyIndex": (),
-    "PySide2.QtCore.QMetaProperty.reset": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QMetaProperty.resetOnGadget": ('int',),
-    "PySide2.QtCore.QMetaProperty.revision": (),
-    "PySide2.QtCore.QMetaProperty.type": (),
-    "PySide2.QtCore.QMetaProperty.typeName": (),
-    "PySide2.QtCore.QMetaProperty.userType": (),
-    "PySide2.QtCore.QMetaProperty.write": ('PySide2.QtCore.QObject', 'typing.Any'),
-    "PySide2.QtCore.QMetaProperty.writeOnGadget": ('int', 'typing.Any'),
-# class PySide2.QtCore.QMimeData:
-    "PySide2.QtCore.QMimeData.__init__": (),
-    "PySide2.QtCore.QMimeData.clear": (),
-    "PySide2.QtCore.QMimeData.colorData": (),
-    "PySide2.QtCore.QMimeData.data": ('str',),
-    "PySide2.QtCore.QMimeData.formats": (),
-    "PySide2.QtCore.QMimeData.hasColor": (),
-    "PySide2.QtCore.QMimeData.hasFormat": ('str',),
-    "PySide2.QtCore.QMimeData.hasHtml": (),
-    "PySide2.QtCore.QMimeData.hasImage": (),
-    "PySide2.QtCore.QMimeData.hasText": (),
-    "PySide2.QtCore.QMimeData.hasUrls": (),
-    "PySide2.QtCore.QMimeData.html": (),
-    "PySide2.QtCore.QMimeData.imageData": (),
-    "PySide2.QtCore.QMimeData.removeFormat": ('str',),
-    "PySide2.QtCore.QMimeData.retrieveData": ('str', 'type'),
-    "PySide2.QtCore.QMimeData.setColorData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setData": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QMimeData.setHtml": ('str',),
-    "PySide2.QtCore.QMimeData.setImageData": ('typing.Any',),
-    "PySide2.QtCore.QMimeData.setText": ('str',),
-    "PySide2.QtCore.QMimeData.setUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtCore.QMimeData.text": (),
-    "PySide2.QtCore.QMimeData.urls": (),
-# class PySide2.QtCore.QMimeDatabase:
-# class PySide2.QtCore.QMimeDatabase.MatchMode:
-    "PySide2.QtCore.QMimeDatabase.__init__": (),
-    "PySide2.QtCore.QMimeDatabase.allMimeTypes": (),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForData": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFile": [('PySide2.QtCore.QFileInfo', 'PySide2.QtCore.QMimeDatabase.MatchMode'), ('str', 'PySide2.QtCore.QMimeDatabase.MatchMode')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForFileNameAndData": [('str', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QIODevice')],
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypeForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QMimeDatabase.mimeTypesForFileName": ('str',),
-    "PySide2.QtCore.QMimeDatabase.suffixForFileName": ('str',),
-# class PySide2.QtCore.QMimeType:
-    "PySide2.QtCore.QMimeType.__init__": [(), ('PySide2.QtCore.QMimeType',)],
-    "PySide2.QtCore.QMimeType.__copy__": (),
-    "PySide2.QtCore.QMimeType.aliases": (),
-    "PySide2.QtCore.QMimeType.allAncestors": (),
-    "PySide2.QtCore.QMimeType.comment": (),
-    "PySide2.QtCore.QMimeType.filterString": (),
-    "PySide2.QtCore.QMimeType.genericIconName": (),
-    "PySide2.QtCore.QMimeType.globPatterns": (),
-    "PySide2.QtCore.QMimeType.iconName": (),
-    "PySide2.QtCore.QMimeType.inherits": ('str',),
-    "PySide2.QtCore.QMimeType.isDefault": (),
-    "PySide2.QtCore.QMimeType.isValid": (),
-    "PySide2.QtCore.QMimeType.name": (),
-    "PySide2.QtCore.QMimeType.parentMimeTypes": (),
-    "PySide2.QtCore.QMimeType.preferredSuffix": (),
-    "PySide2.QtCore.QMimeType.suffixes": (),
-    "PySide2.QtCore.QMimeType.swap": ('PySide2.QtCore.QMimeType',),
-# class PySide2.QtCore.QModelIndex:
-    "PySide2.QtCore.QModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QModelIndex.__copy__": (),
-    "PySide2.QtCore.QModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.column": (),
-    "PySide2.QtCore.QModelIndex.data": ('int',),
-    "PySide2.QtCore.QModelIndex.flags": (),
-    "PySide2.QtCore.QModelIndex.internalId": (),
-    "PySide2.QtCore.QModelIndex.internalPointer": (),
-    "PySide2.QtCore.QModelIndex.isValid": (),
-    "PySide2.QtCore.QModelIndex.model": (),
-    "PySide2.QtCore.QModelIndex.parent": (),
-    "PySide2.QtCore.QModelIndex.row": (),
-    "PySide2.QtCore.QModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QModelIndex.siblingAtColumn": ('int',),
-    "PySide2.QtCore.QModelIndex.siblingAtRow": ('int',),
-# class PySide2.QtCore.QMutex:
-# class PySide2.QtCore.QMutex.RecursionMode:
-    "PySide2.QtCore.QMutex.__init__": [(), ('PySide2.QtCore.QMutex.RecursionMode',)],
-    "PySide2.QtCore.QMutex.isRecursive": (),
-    "PySide2.QtCore.QMutex.lock": (),
-    "PySide2.QtCore.QMutex.tryLock": [(), ('int',)],
-    "PySide2.QtCore.QMutex.try_lock": (),
-    "PySide2.QtCore.QMutex.unlock": (),
-# class PySide2.QtCore.QMutexLocker:
-    "PySide2.QtCore.QMutexLocker.__init__": [('PySide2.QtCore.QBasicMutex',), ('PySide2.QtCore.QRecursiveMutex',)],
-    "PySide2.QtCore.QMutexLocker.__enter__": (),
-    "PySide2.QtCore.QMutexLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QMutexLocker.mutex": (),
-    "PySide2.QtCore.QMutexLocker.relock": (),
-    "PySide2.QtCore.QMutexLocker.unlock": (),
-# class PySide2.QtCore.QObject:
-    "PySide2.QtCore.QObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.blockSignals": ('bool',),
-    "PySide2.QtCore.QObject.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtCore.QObject.children": (),
-    "PySide2.QtCore.QObject.connect": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'), ('str', 'typing.Callable', 'PySide2.QtCore.Qt.ConnectionType')],
-    "PySide2.QtCore.QObject.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.customEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.deleteLater": (),
-    "PySide2.QtCore.QObject.disconnect": [('PySide2.QtCore.QMetaObject.Connection',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaMethod'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'typing.Callable'), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'typing.Callable')],
-    "PySide2.QtCore.QObject.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.dumpObjectInfo": (),
-    "PySide2.QtCore.QObject.dumpObjectTree": (),
-    "PySide2.QtCore.QObject.dynamicPropertyNames": (),
-    "PySide2.QtCore.QObject.emit": ('str', 'None'),
-    "PySide2.QtCore.QObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QObject.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QObject.findChild": ('type', 'str'),
-    "PySide2.QtCore.QObject.findChildren": [('type', 'PySide2.QtCore.QRegExp'), ('type', 'str')],
-    "PySide2.QtCore.QObject.inherits": ('str',),
-    "PySide2.QtCore.QObject.installEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.isSignalConnected": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtCore.QObject.isWidgetType": (),
-    "PySide2.QtCore.QObject.isWindowType": (),
-    "PySide2.QtCore.QObject.killTimer": ('int',),
-    "PySide2.QtCore.QObject.metaObject": (),
-    "PySide2.QtCore.QObject.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtCore.QObject.objectName": (),
-    "PySide2.QtCore.QObject.parent": (),
-    "PySide2.QtCore.QObject.property": ('str',),
-    "PySide2.QtCore.QObject.receivers": ('str',),
-    "PySide2.QtCore.QObject.registerUserData": (),
-    "PySide2.QtCore.QObject.removeEventFilter": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.sender": (),
-    "PySide2.QtCore.QObject.senderSignalIndex": (),
-    "PySide2.QtCore.QObject.setObjectName": ('str',),
-    "PySide2.QtCore.QObject.setParent": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QObject.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtCore.QObject.signalsBlocked": (),
-    "PySide2.QtCore.QObject.startTimer": ('int', 'PySide2.QtCore.Qt.TimerType'),
-    "PySide2.QtCore.QObject.thread": (),
-    "PySide2.QtCore.QObject.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QObject.tr": ('str', 'str', 'int'),
-# class PySide2.QtCore.QOperatingSystemVersion:
-# class PySide2.QtCore.QOperatingSystemVersion.OSType:
-    "PySide2.QtCore.QOperatingSystemVersion.__init__": [('PySide2.QtCore.QOperatingSystemVersion',), ('PySide2.QtCore.QOperatingSystemVersion.OSType', 'int', 'int', 'int')],
-    "PySide2.QtCore.QOperatingSystemVersion.__copy__": (),
-    "PySide2.QtCore.QOperatingSystemVersion.current": (),
-    "PySide2.QtCore.QOperatingSystemVersion.currentType": (),
-    "PySide2.QtCore.QOperatingSystemVersion.majorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.microVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.minorVersion": (),
-    "PySide2.QtCore.QOperatingSystemVersion.name": (),
-    "PySide2.QtCore.QOperatingSystemVersion.segmentCount": (),
-    "PySide2.QtCore.QOperatingSystemVersion.type": (),
-# class PySide2.QtCore.QParallelAnimationGroup:
-    "PySide2.QtCore.QParallelAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QParallelAnimationGroup.duration": (),
-    "PySide2.QtCore.QParallelAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QParallelAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QPauseAnimation:
-    "PySide2.QtCore.QPauseAnimation.__init__": [('PySide2.QtCore.QObject',), ('int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPauseAnimation.duration": (),
-    "PySide2.QtCore.QPauseAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPauseAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QPauseAnimation.updateCurrentTime": ('int',),
-# class PySide2.QtCore.QPersistentModelIndex:
-    "PySide2.QtCore.QPersistentModelIndex.__init__": [(), ('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QPersistentModelIndex',)],
-    "PySide2.QtCore.QPersistentModelIndex.__copy__": (),
-    "PySide2.QtCore.QPersistentModelIndex.child": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.column": (),
-    "PySide2.QtCore.QPersistentModelIndex.data": ('int',),
-    "PySide2.QtCore.QPersistentModelIndex.flags": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalId": (),
-    "PySide2.QtCore.QPersistentModelIndex.internalPointer": (),
-    "PySide2.QtCore.QPersistentModelIndex.isValid": (),
-    "PySide2.QtCore.QPersistentModelIndex.model": (),
-    "PySide2.QtCore.QPersistentModelIndex.parent": (),
-    "PySide2.QtCore.QPersistentModelIndex.row": (),
-    "PySide2.QtCore.QPersistentModelIndex.sibling": ('int', 'int'),
-    "PySide2.QtCore.QPersistentModelIndex.swap": ('PySide2.QtCore.QPersistentModelIndex',),
-# class PySide2.QtCore.QPluginLoader:
-    "PySide2.QtCore.QPluginLoader.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPluginLoader.errorString": (),
-    "PySide2.QtCore.QPluginLoader.fileName": (),
-    "PySide2.QtCore.QPluginLoader.instance": (),
-    "PySide2.QtCore.QPluginLoader.isLoaded": (),
-    "PySide2.QtCore.QPluginLoader.load": (),
-    "PySide2.QtCore.QPluginLoader.metaData": (),
-    "PySide2.QtCore.QPluginLoader.setFileName": ('str',),
-    "PySide2.QtCore.QPluginLoader.staticInstances": (),
-    "PySide2.QtCore.QPluginLoader.unload": (),
-# class PySide2.QtCore.QPoint:
-    "PySide2.QtCore.QPoint.__init__": [(), ('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QPoint.__add__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__copy__": (),
-    "PySide2.QtCore.QPoint.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__imul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__isub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.__mul__": [('float',), ('int',)],
-    "PySide2.QtCore.QPoint.__neg__": (),
-    "PySide2.QtCore.QPoint.__pos__": (),
-    "PySide2.QtCore.QPoint.__reduce__": (),
-    "PySide2.QtCore.QPoint.__repr__": (),
-    "PySide2.QtCore.QPoint.__sub__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QPoint.dotProduct": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtCore.QPoint.isNull": (),
-    "PySide2.QtCore.QPoint.manhattanLength": (),
-    "PySide2.QtCore.QPoint.setX": ('int',),
-    "PySide2.QtCore.QPoint.setY": ('int',),
-    "PySide2.QtCore.QPoint.toTuple": (),
-    "PySide2.QtCore.QPoint.transposed": (),
-    "PySide2.QtCore.QPoint.x": (),
-    "PySide2.QtCore.QPoint.y": (),
-# class PySide2.QtCore.QPointF:
-    "PySide2.QtCore.QPointF.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QPointF.__add__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__copy__": (),
-    "PySide2.QtCore.QPointF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__imul__": ('float',),
-    "PySide2.QtCore.QPointF.__isub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.__mul__": ('float',),
-    "PySide2.QtCore.QPointF.__neg__": (),
-    "PySide2.QtCore.QPointF.__pos__": (),
-    "PySide2.QtCore.QPointF.__reduce__": (),
-    "PySide2.QtCore.QPointF.__repr__": (),
-    "PySide2.QtCore.QPointF.__sub__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QPointF.dotProduct": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCore.QPointF.isNull": (),
-    "PySide2.QtCore.QPointF.manhattanLength": (),
-    "PySide2.QtCore.QPointF.setX": ('float',),
-    "PySide2.QtCore.QPointF.setY": ('float',),
-    "PySide2.QtCore.QPointF.toPoint": (),
-    "PySide2.QtCore.QPointF.toTuple": (),
-    "PySide2.QtCore.QPointF.transposed": (),
-    "PySide2.QtCore.QPointF.x": (),
-    "PySide2.QtCore.QPointF.y": (),
-# class PySide2.QtCore.QProcess:
-# class PySide2.QtCore.QProcess.ExitStatus:
-# class PySide2.QtCore.QProcess.InputChannelMode:
-# class PySide2.QtCore.QProcess.ProcessChannel:
-# class PySide2.QtCore.QProcess.ProcessChannelMode:
-# class PySide2.QtCore.QProcess.ProcessError:
-# class PySide2.QtCore.QProcess.ProcessState:
-    "PySide2.QtCore.QProcess.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QProcess.arguments": (),
-    "PySide2.QtCore.QProcess.atEnd": (),
-    "PySide2.QtCore.QProcess.bytesAvailable": (),
-    "PySide2.QtCore.QProcess.bytesToWrite": (),
-    "PySide2.QtCore.QProcess.canReadLine": (),
-    "PySide2.QtCore.QProcess.close": (),
-    "PySide2.QtCore.QProcess.closeReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.closeWriteChannel": (),
-    "PySide2.QtCore.QProcess.environment": (),
-    "PySide2.QtCore.QProcess.error": (),
-    "PySide2.QtCore.QProcess.execute": [('str',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtCore.QProcess.exitCode": (),
-    "PySide2.QtCore.QProcess.exitStatus": (),
-    "PySide2.QtCore.QProcess.inputChannelMode": (),
-    "PySide2.QtCore.QProcess.isSequential": (),
-    "PySide2.QtCore.QProcess.kill": (),
-    "PySide2.QtCore.QProcess.nullDevice": (),
-    "PySide2.QtCore.QProcess.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QProcess.pid": (),
-    "PySide2.QtCore.QProcess.processChannelMode": (),
-    "PySide2.QtCore.QProcess.processEnvironment": (),
-    "PySide2.QtCore.QProcess.processId": (),
-    "PySide2.QtCore.QProcess.program": (),
-    "PySide2.QtCore.QProcess.readAllStandardError": (),
-    "PySide2.QtCore.QProcess.readAllStandardOutput": (),
-    "PySide2.QtCore.QProcess.readChannel": (),
-    "PySide2.QtCore.QProcess.readData": ('str', 'int'),
-    "PySide2.QtCore.QProcess.setArguments": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setEnvironment": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QProcess.setInputChannelMode": ('PySide2.QtCore.QProcess.InputChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessChannelMode": ('PySide2.QtCore.QProcess.ProcessChannelMode',),
-    "PySide2.QtCore.QProcess.setProcessEnvironment": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcess.setProcessState": ('PySide2.QtCore.QProcess.ProcessState',),
-    "PySide2.QtCore.QProcess.setProgram": ('str',),
-    "PySide2.QtCore.QProcess.setReadChannel": ('PySide2.QtCore.QProcess.ProcessChannel',),
-    "PySide2.QtCore.QProcess.setStandardErrorFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardInputFile": ('str',),
-    "PySide2.QtCore.QProcess.setStandardOutputFile": ('str', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtCore.QProcess.setStandardOutputProcess": ('PySide2.QtCore.QProcess',),
-    "PySide2.QtCore.QProcess.setWorkingDirectory": ('str',),
-    "PySide2.QtCore.QProcess.setupChildProcess": (),
-    "PySide2.QtCore.QProcess.start": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'typing.Sequence[str]', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtCore.QProcess.startDetached": [(), ('str',), ('str', 'typing.Sequence[str]'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtCore.QProcess.state": (),
-    "PySide2.QtCore.QProcess.systemEnvironment": (),
-    "PySide2.QtCore.QProcess.terminate": (),
-    "PySide2.QtCore.QProcess.waitForBytesWritten": ('int',),
-    "PySide2.QtCore.QProcess.waitForFinished": ('int',),
-    "PySide2.QtCore.QProcess.waitForReadyRead": ('int',),
-    "PySide2.QtCore.QProcess.waitForStarted": ('int',),
-    "PySide2.QtCore.QProcess.workingDirectory": (),
-    "PySide2.QtCore.QProcess.writeData": ('str', 'int'),
-# class PySide2.QtCore.QProcessEnvironment:
-    "PySide2.QtCore.QProcessEnvironment.__init__": [(), ('PySide2.QtCore.QProcessEnvironment',)],
-    "PySide2.QtCore.QProcessEnvironment.__copy__": (),
-    "PySide2.QtCore.QProcessEnvironment.clear": (),
-    "PySide2.QtCore.QProcessEnvironment.contains": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.insert": [('PySide2.QtCore.QProcessEnvironment',), ('str', 'str')],
-    "PySide2.QtCore.QProcessEnvironment.isEmpty": (),
-    "PySide2.QtCore.QProcessEnvironment.keys": (),
-    "PySide2.QtCore.QProcessEnvironment.remove": ('str',),
-    "PySide2.QtCore.QProcessEnvironment.swap": ('PySide2.QtCore.QProcessEnvironment',),
-    "PySide2.QtCore.QProcessEnvironment.systemEnvironment": (),
-    "PySide2.QtCore.QProcessEnvironment.toStringList": (),
-    "PySide2.QtCore.QProcessEnvironment.value": ('str', 'str'),
-# class PySide2.QtCore.QPropertyAnimation:
-    "PySide2.QtCore.QPropertyAnimation.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QPropertyAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QPropertyAnimation.propertyName": (),
-    "PySide2.QtCore.QPropertyAnimation.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QPropertyAnimation.setTargetObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QPropertyAnimation.targetObject": (),
-    "PySide2.QtCore.QPropertyAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QPropertyAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QRandomGenerator:
-    "PySide2.QtCore.QRandomGenerator.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.bounded": [('float',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator.generate": (),
-    "PySide2.QtCore.QRandomGenerator.generate64": (),
-    "PySide2.QtCore.QRandomGenerator.generateDouble": (),
-    "PySide2.QtCore.QRandomGenerator.global_": (),
-    "PySide2.QtCore.QRandomGenerator.max": (),
-    "PySide2.QtCore.QRandomGenerator.min": (),
-    "PySide2.QtCore.QRandomGenerator.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator.seed": ('int',),
-    "PySide2.QtCore.QRandomGenerator.system": (),
-# class PySide2.QtCore.QRandomGenerator64:
-    "PySide2.QtCore.QRandomGenerator64.__init__": [('PySide2.QtCore.QRandomGenerator',), ('int',), ('int', 'int')],
-    "PySide2.QtCore.QRandomGenerator64.discard": ('int',),
-    "PySide2.QtCore.QRandomGenerator64.generate": (),
-    "PySide2.QtCore.QRandomGenerator64.global_": (),
-    "PySide2.QtCore.QRandomGenerator64.max": (),
-    "PySide2.QtCore.QRandomGenerator64.min": (),
-    "PySide2.QtCore.QRandomGenerator64.securelySeeded": (),
-    "PySide2.QtCore.QRandomGenerator64.system": (),
-# class PySide2.QtCore.QReadLocker:
-    "PySide2.QtCore.QReadLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QReadLocker.__enter__": (),
-    "PySide2.QtCore.QReadLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QReadLocker.readWriteLock": (),
-    "PySide2.QtCore.QReadLocker.relock": (),
-    "PySide2.QtCore.QReadLocker.unlock": (),
-# class PySide2.QtCore.QReadWriteLock:
-# class PySide2.QtCore.QReadWriteLock.RecursionMode:
-    "PySide2.QtCore.QReadWriteLock.__init__": ('PySide2.QtCore.QReadWriteLock.RecursionMode',),
-    "PySide2.QtCore.QReadWriteLock.lockForRead": (),
-    "PySide2.QtCore.QReadWriteLock.lockForWrite": (),
-    "PySide2.QtCore.QReadWriteLock.tryLockForRead": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.tryLockForWrite": [(), ('int',)],
-    "PySide2.QtCore.QReadWriteLock.unlock": (),
-# class PySide2.QtCore.QRect:
-    "PySide2.QtCore.QRect.__init__": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QSize'), ('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QRect.__add__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__and__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__copy__": (),
-    "PySide2.QtCore.QRect.__iadd__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__iand__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__ior__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__isub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.__or__": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.__reduce__": (),
-    "PySide2.QtCore.QRect.__repr__": (),
-    "PySide2.QtCore.QRect.__sub__": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.adjust": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.adjusted": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.bottom": (),
-    "PySide2.QtCore.QRect.bottomLeft": (),
-    "PySide2.QtCore.QRect.bottomRight": (),
-    "PySide2.QtCore.QRect.center": (),
-    "PySide2.QtCore.QRect.contains": [('PySide2.QtCore.QPoint', 'bool'), ('PySide2.QtCore.QRect', 'bool'), ('int', 'int'), ('int', 'int', 'bool')],
-    "PySide2.QtCore.QRect.getCoords": (),
-    "PySide2.QtCore.QRect.getRect": (),
-    "PySide2.QtCore.QRect.height": (),
-    "PySide2.QtCore.QRect.intersected": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.intersects": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.isEmpty": (),
-    "PySide2.QtCore.QRect.isNull": (),
-    "PySide2.QtCore.QRect.isValid": (),
-    "PySide2.QtCore.QRect.left": (),
-    "PySide2.QtCore.QRect.marginsAdded": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.marginsRemoved": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QRect.moveBottom": ('int',),
-    "PySide2.QtCore.QRect.moveBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveCenter": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveLeft": ('int',),
-    "PySide2.QtCore.QRect.moveRight": ('int',),
-    "PySide2.QtCore.QRect.moveTo": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.moveTop": ('int',),
-    "PySide2.QtCore.QRect.moveTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.moveTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.normalized": (),
-    "PySide2.QtCore.QRect.right": (),
-    "PySide2.QtCore.QRect.setBottom": ('int',),
-    "PySide2.QtCore.QRect.setBottomLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setBottomRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setCoords": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setHeight": ('int',),
-    "PySide2.QtCore.QRect.setLeft": ('int',),
-    "PySide2.QtCore.QRect.setRect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QRect.setRight": ('int',),
-    "PySide2.QtCore.QRect.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QRect.setTop": ('int',),
-    "PySide2.QtCore.QRect.setTopLeft": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setTopRight": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtCore.QRect.setWidth": ('int',),
-    "PySide2.QtCore.QRect.setX": ('int',),
-    "PySide2.QtCore.QRect.setY": ('int',),
-    "PySide2.QtCore.QRect.size": (),
-    "PySide2.QtCore.QRect.top": (),
-    "PySide2.QtCore.QRect.topLeft": (),
-    "PySide2.QtCore.QRect.topRight": (),
-    "PySide2.QtCore.QRect.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtCore.QRect.transposed": (),
-    "PySide2.QtCore.QRect.united": ('PySide2.QtCore.QRect',),
-    "PySide2.QtCore.QRect.width": (),
-    "PySide2.QtCore.QRect.x": (),
-    "PySide2.QtCore.QRect.y": (),
-# class PySide2.QtCore.QRectF:
-    "PySide2.QtCore.QRectF.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QSizeF'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtCore.QRectF.__add__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__and__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__copy__": (),
-    "PySide2.QtCore.QRectF.__iadd__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__iand__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__ior__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__isub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.__or__": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.__reduce__": (),
-    "PySide2.QtCore.QRectF.__repr__": (),
-    "PySide2.QtCore.QRectF.__sub__": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.adjust": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.adjusted": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.bottom": (),
-    "PySide2.QtCore.QRectF.bottomLeft": (),
-    "PySide2.QtCore.QRectF.bottomRight": (),
-    "PySide2.QtCore.QRectF.center": (),
-    "PySide2.QtCore.QRectF.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.getCoords": (),
-    "PySide2.QtCore.QRectF.getRect": (),
-    "PySide2.QtCore.QRectF.height": (),
-    "PySide2.QtCore.QRectF.intersected": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.intersects": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.isEmpty": (),
-    "PySide2.QtCore.QRectF.isNull": (),
-    "PySide2.QtCore.QRectF.isValid": (),
-    "PySide2.QtCore.QRectF.left": (),
-    "PySide2.QtCore.QRectF.marginsAdded": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.marginsRemoved": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QRectF.moveBottom": ('float',),
-    "PySide2.QtCore.QRectF.moveBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveCenter": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveLeft": ('float',),
-    "PySide2.QtCore.QRectF.moveRight": ('float',),
-    "PySide2.QtCore.QRectF.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.moveTop": ('float',),
-    "PySide2.QtCore.QRectF.moveTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.moveTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.normalized": (),
-    "PySide2.QtCore.QRectF.right": (),
-    "PySide2.QtCore.QRectF.setBottom": ('float',),
-    "PySide2.QtCore.QRectF.setBottomLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setBottomRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setCoords": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setHeight": ('float',),
-    "PySide2.QtCore.QRectF.setLeft": ('float',),
-    "PySide2.QtCore.QRectF.setRect": ('float', 'float', 'float', 'float'),
-    "PySide2.QtCore.QRectF.setRight": ('float',),
-    "PySide2.QtCore.QRectF.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QRectF.setTop": ('float',),
-    "PySide2.QtCore.QRectF.setTopLeft": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setTopRight": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtCore.QRectF.setWidth": ('float',),
-    "PySide2.QtCore.QRectF.setX": ('float',),
-    "PySide2.QtCore.QRectF.setY": ('float',),
-    "PySide2.QtCore.QRectF.size": (),
-    "PySide2.QtCore.QRectF.toAlignedRect": (),
-    "PySide2.QtCore.QRectF.toRect": (),
-    "PySide2.QtCore.QRectF.top": (),
-    "PySide2.QtCore.QRectF.topLeft": (),
-    "PySide2.QtCore.QRectF.topRight": (),
-    "PySide2.QtCore.QRectF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtCore.QRectF.transposed": (),
-    "PySide2.QtCore.QRectF.united": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCore.QRectF.width": (),
-    "PySide2.QtCore.QRectF.x": (),
-    "PySide2.QtCore.QRectF.y": (),
-# class PySide2.QtCore.QRecursiveMutex:
-    "PySide2.QtCore.QRecursiveMutex.__init__": (),
-# class PySide2.QtCore.QRegExp:
-# class PySide2.QtCore.QRegExp.CaretMode:
-# class PySide2.QtCore.QRegExp.PatternSyntax:
-    "PySide2.QtCore.QRegExp.__init__": [(), ('PySide2.QtCore.QRegExp',), ('str', 'PySide2.QtCore.Qt.CaseSensitivity', 'PySide2.QtCore.QRegExp.PatternSyntax')],
-    "PySide2.QtCore.QRegExp.__copy__": (),
-    "PySide2.QtCore.QRegExp.__reduce__": (),
-    "PySide2.QtCore.QRegExp.__repr__": (),
-    "PySide2.QtCore.QRegExp.cap": ('int',),
-    "PySide2.QtCore.QRegExp.captureCount": (),
-    "PySide2.QtCore.QRegExp.capturedTexts": (),
-    "PySide2.QtCore.QRegExp.caseSensitivity": (),
-    "PySide2.QtCore.QRegExp.errorString": (),
-    "PySide2.QtCore.QRegExp.escape": ('str',),
-    "PySide2.QtCore.QRegExp.exactMatch": ('str',),
-    "PySide2.QtCore.QRegExp.indexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.isEmpty": (),
-    "PySide2.QtCore.QRegExp.isMinimal": (),
-    "PySide2.QtCore.QRegExp.isValid": (),
-    "PySide2.QtCore.QRegExp.lastIndexIn": ('str', 'int', 'PySide2.QtCore.QRegExp.CaretMode'),
-    "PySide2.QtCore.QRegExp.matchedLength": (),
-    "PySide2.QtCore.QRegExp.pattern": (),
-    "PySide2.QtCore.QRegExp.patternSyntax": (),
-    "PySide2.QtCore.QRegExp.pos": ('int',),
-    "PySide2.QtCore.QRegExp.replace": ('str', 'str'),
-    "PySide2.QtCore.QRegExp.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QRegExp.setMinimal": ('bool',),
-    "PySide2.QtCore.QRegExp.setPattern": ('str',),
-    "PySide2.QtCore.QRegExp.setPatternSyntax": ('PySide2.QtCore.QRegExp.PatternSyntax',),
-    "PySide2.QtCore.QRegExp.swap": ('PySide2.QtCore.QRegExp',),
-# class PySide2.QtCore.QRegularExpression:
-# class PySide2.QtCore.QRegularExpression.MatchOption:
-# class PySide2.QtCore.QRegularExpression.MatchOptions:
-# class PySide2.QtCore.QRegularExpression.MatchType:
-# class PySide2.QtCore.QRegularExpression.PatternOption:
-# class PySide2.QtCore.QRegularExpression.PatternOptions:
-    "PySide2.QtCore.QRegularExpression.__init__": [(), ('PySide2.QtCore.QRegularExpression',), ('str', 'PySide2.QtCore.QRegularExpression.PatternOptions')],
-    "PySide2.QtCore.QRegularExpression.__copy__": (),
-    "PySide2.QtCore.QRegularExpression.anchoredPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.captureCount": (),
-    "PySide2.QtCore.QRegularExpression.errorString": (),
-    "PySide2.QtCore.QRegularExpression.escape": ('str',),
-    "PySide2.QtCore.QRegularExpression.globalMatch": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.isValid": (),
-    "PySide2.QtCore.QRegularExpression.match": ('str', 'int', 'PySide2.QtCore.QRegularExpression.MatchType', 'PySide2.QtCore.QRegularExpression.MatchOptions'),
-    "PySide2.QtCore.QRegularExpression.namedCaptureGroups": (),
-    "PySide2.QtCore.QRegularExpression.optimize": (),
-    "PySide2.QtCore.QRegularExpression.pattern": (),
-    "PySide2.QtCore.QRegularExpression.patternErrorOffset": (),
-    "PySide2.QtCore.QRegularExpression.patternOptions": (),
-    "PySide2.QtCore.QRegularExpression.setPattern": ('str',),
-    "PySide2.QtCore.QRegularExpression.setPatternOptions": ('PySide2.QtCore.QRegularExpression.PatternOptions',),
-    "PySide2.QtCore.QRegularExpression.swap": ('PySide2.QtCore.QRegularExpression',),
-    "PySide2.QtCore.QRegularExpression.wildcardToRegularExpression": ('str',),
-# class PySide2.QtCore.QRegularExpressionMatch:
-    "PySide2.QtCore.QRegularExpressionMatch.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatch',)],
-    "PySide2.QtCore.QRegularExpressionMatch.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatch.captured": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedEnd": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedLength": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedRef": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedStart": [('int',), ('str',)],
-    "PySide2.QtCore.QRegularExpressionMatch.capturedTexts": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.hasPartialMatch": (),
-    "PySide2.QtCore.QRegularExpressionMatch.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatch.lastCapturedIndex": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatch.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatch.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatch.swap": ('PySide2.QtCore.QRegularExpressionMatch',),
-# class PySide2.QtCore.QRegularExpressionMatchIterator:
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__init__": [(), ('PySide2.QtCore.QRegularExpressionMatchIterator',)],
-    "PySide2.QtCore.QRegularExpressionMatchIterator.__copy__": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.hasNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.isValid": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchOptions": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.matchType": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.peekNext": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.regularExpression": (),
-    "PySide2.QtCore.QRegularExpressionMatchIterator.swap": ('PySide2.QtCore.QRegularExpressionMatchIterator',),
-# class PySide2.QtCore.QResource:
-# class PySide2.QtCore.QResource.Compression:
-    "PySide2.QtCore.QResource.__init__": ('str', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtCore.QResource.absoluteFilePath": (),
-    "PySide2.QtCore.QResource.addSearchPath": ('str',),
-    "PySide2.QtCore.QResource.children": (),
-    "PySide2.QtCore.QResource.compressionAlgorithm": (),
-    "PySide2.QtCore.QResource.data": (),
-    "PySide2.QtCore.QResource.fileName": (),
-    "PySide2.QtCore.QResource.isCompressed": (),
-    "PySide2.QtCore.QResource.isDir": (),
-    "PySide2.QtCore.QResource.isFile": (),
-    "PySide2.QtCore.QResource.isValid": (),
-    "PySide2.QtCore.QResource.lastModified": (),
-    "PySide2.QtCore.QResource.locale": (),
-    "PySide2.QtCore.QResource.registerResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.registerResourceData": ('str', 'str'),
-    "PySide2.QtCore.QResource.searchPaths": (),
-    "PySide2.QtCore.QResource.setFileName": ('str',),
-    "PySide2.QtCore.QResource.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QResource.size": (),
-    "PySide2.QtCore.QResource.unregisterResource": ('str', 'str'),
-    "PySide2.QtCore.QResource.unregisterResourceData": ('str', 'str'),
-# class PySide2.QtCore.QRunnable:
-    "PySide2.QtCore.QRunnable.__init__": (),
-    "PySide2.QtCore.QRunnable.autoDelete": (),
-    "PySide2.QtCore.QRunnable.run": (),
-    "PySide2.QtCore.QRunnable.setAutoDelete": ('bool',),
-# class PySide2.QtCore.QSaveFile:
-    "PySide2.QtCore.QSaveFile.__init__": [('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSaveFile.cancelWriting": (),
-    "PySide2.QtCore.QSaveFile.close": (),
-    "PySide2.QtCore.QSaveFile.commit": (),
-    "PySide2.QtCore.QSaveFile.directWriteFallback": (),
-    "PySide2.QtCore.QSaveFile.fileName": (),
-    "PySide2.QtCore.QSaveFile.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtCore.QSaveFile.setDirectWriteFallback": ('bool',),
-    "PySide2.QtCore.QSaveFile.setFileName": ('str',),
-    "PySide2.QtCore.QSaveFile.writeData": ('str', 'int'),
-# class PySide2.QtCore.QSemaphore:
-    "PySide2.QtCore.QSemaphore.__init__": ('int',),
-    "PySide2.QtCore.QSemaphore.acquire": ('int',),
-    "PySide2.QtCore.QSemaphore.available": (),
-    "PySide2.QtCore.QSemaphore.release": ('int',),
-    "PySide2.QtCore.QSemaphore.tryAcquire": [('int',), ('int', 'int')],
-# class PySide2.QtCore.QSemaphoreReleaser:
-    "PySide2.QtCore.QSemaphoreReleaser.__init__": [(), ('PySide2.QtCore.QSemaphore', 'int')],
-    "PySide2.QtCore.QSemaphoreReleaser.cancel": (),
-    "PySide2.QtCore.QSemaphoreReleaser.semaphore": (),
-    "PySide2.QtCore.QSemaphoreReleaser.swap": ('PySide2.QtCore.QSemaphoreReleaser',),
-# class PySide2.QtCore.QSequentialAnimationGroup:
-    "PySide2.QtCore.QSequentialAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSequentialAnimationGroup.addPause": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.currentAnimation": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.duration": (),
-    "PySide2.QtCore.QSequentialAnimationGroup.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSequentialAnimationGroup.insertPause": ('int', 'int'),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateDirection": ('PySide2.QtCore.QAbstractAnimation.Direction',),
-    "PySide2.QtCore.QSequentialAnimationGroup.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QSettings:
-# class PySide2.QtCore.QSettings.Format:
-# class PySide2.QtCore.QSettings.Scope:
-# class PySide2.QtCore.QSettings.Status:
-    "PySide2.QtCore.QSettings.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QSettings.Scope', 'str', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QObject'), ('str', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSettings.allKeys": (),
-    "PySide2.QtCore.QSettings.applicationName": (),
-    "PySide2.QtCore.QSettings.beginGroup": ('str',),
-    "PySide2.QtCore.QSettings.beginReadArray": ('str',),
-    "PySide2.QtCore.QSettings.beginWriteArray": ('str', 'int'),
-    "PySide2.QtCore.QSettings.childGroups": (),
-    "PySide2.QtCore.QSettings.childKeys": (),
-    "PySide2.QtCore.QSettings.clear": (),
-    "PySide2.QtCore.QSettings.contains": ('str',),
-    "PySide2.QtCore.QSettings.defaultFormat": (),
-    "PySide2.QtCore.QSettings.endArray": (),
-    "PySide2.QtCore.QSettings.endGroup": (),
-    "PySide2.QtCore.QSettings.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSettings.fallbacksEnabled": (),
-    "PySide2.QtCore.QSettings.fileName": (),
-    "PySide2.QtCore.QSettings.format": (),
-    "PySide2.QtCore.QSettings.group": (),
-    "PySide2.QtCore.QSettings.iniCodec": (),
-    "PySide2.QtCore.QSettings.isAtomicSyncRequired": (),
-    "PySide2.QtCore.QSettings.isWritable": (),
-    "PySide2.QtCore.QSettings.organizationName": (),
-    "PySide2.QtCore.QSettings.remove": ('str',),
-    "PySide2.QtCore.QSettings.scope": (),
-    "PySide2.QtCore.QSettings.setArrayIndex": ('int',),
-    "PySide2.QtCore.QSettings.setAtomicSyncRequired": ('bool',),
-    "PySide2.QtCore.QSettings.setDefaultFormat": ('PySide2.QtCore.QSettings.Format',),
-    "PySide2.QtCore.QSettings.setFallbacksEnabled": ('bool',),
-    "PySide2.QtCore.QSettings.setIniCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QSettings.setPath": ('PySide2.QtCore.QSettings.Format', 'PySide2.QtCore.QSettings.Scope', 'str'),
-    "PySide2.QtCore.QSettings.setValue": ('str', 'typing.Any'),
-    "PySide2.QtCore.QSettings.status": (),
-    "PySide2.QtCore.QSettings.sync": (),
-    "PySide2.QtCore.QSettings.value": ('str', 'typing.Any', 'object'),
-# class PySide2.QtCore.QSignalBlocker:
-    "PySide2.QtCore.QSignalBlocker.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalBlocker.reblock": (),
-    "PySide2.QtCore.QSignalBlocker.unblock": (),
-# class PySide2.QtCore.QSignalMapper:
-    "PySide2.QtCore.QSignalMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.map": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCore.QSignalMapper.mapping": [('PySide2.QtCore.QObject',), ('int',), ('str',)],
-    "PySide2.QtCore.QSignalMapper.removeMappings": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalMapper.setMapping": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-# class PySide2.QtCore.QSignalTransition:
-    "PySide2.QtCore.QSignalTransition.__init__": [('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',), ('object', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QSignalTransition.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSignalTransition.senderObject": (),
-    "PySide2.QtCore.QSignalTransition.setSenderObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSignalTransition.setSignal": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QSignalTransition.signal": (),
-# class PySide2.QtCore.QSize:
-    "PySide2.QtCore.QSize.__init__": [(), ('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtCore.QSize.__add__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__copy__": (),
-    "PySide2.QtCore.QSize.__iadd__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__imul__": ('float',),
-    "PySide2.QtCore.QSize.__isub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.__mul__": ('float',),
-    "PySide2.QtCore.QSize.__reduce__": (),
-    "PySide2.QtCore.QSize.__repr__": (),
-    "PySide2.QtCore.QSize.__sub__": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.boundedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.expandedTo": ('PySide2.QtCore.QSize',),
-    "PySide2.QtCore.QSize.grownBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.height": (),
-    "PySide2.QtCore.QSize.isEmpty": (),
-    "PySide2.QtCore.QSize.isNull": (),
-    "PySide2.QtCore.QSize.isValid": (),
-    "PySide2.QtCore.QSize.scale": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSize.setHeight": ('int',),
-    "PySide2.QtCore.QSize.setWidth": ('int',),
-    "PySide2.QtCore.QSize.shrunkBy": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCore.QSize.toTuple": (),
-    "PySide2.QtCore.QSize.transpose": (),
-    "PySide2.QtCore.QSize.transposed": (),
-    "PySide2.QtCore.QSize.width": (),
-# class PySide2.QtCore.QSizeF:
-    "PySide2.QtCore.QSizeF.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtCore.QSizeF.__add__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__copy__": (),
-    "PySide2.QtCore.QSizeF.__iadd__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__imul__": ('float',),
-    "PySide2.QtCore.QSizeF.__isub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.__mul__": ('float',),
-    "PySide2.QtCore.QSizeF.__reduce__": (),
-    "PySide2.QtCore.QSizeF.__repr__": (),
-    "PySide2.QtCore.QSizeF.__sub__": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.boundedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.expandedTo": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtCore.QSizeF.grownBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.height": (),
-    "PySide2.QtCore.QSizeF.isEmpty": (),
-    "PySide2.QtCore.QSizeF.isNull": (),
-    "PySide2.QtCore.QSizeF.isValid": (),
-    "PySide2.QtCore.QSizeF.scale": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.scaled": [('PySide2.QtCore.QSizeF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtCore.QSizeF.setHeight": ('float',),
-    "PySide2.QtCore.QSizeF.setWidth": ('float',),
-    "PySide2.QtCore.QSizeF.shrunkBy": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtCore.QSizeF.toSize": (),
-    "PySide2.QtCore.QSizeF.toTuple": (),
-    "PySide2.QtCore.QSizeF.transpose": (),
-    "PySide2.QtCore.QSizeF.transposed": (),
-    "PySide2.QtCore.QSizeF.width": (),
-# class PySide2.QtCore.QSocketNotifier:
-# class PySide2.QtCore.QSocketNotifier.Type:
-    "PySide2.QtCore.QSocketNotifier.__init__": [('int', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject'), ('object', 'PySide2.QtCore.QSocketNotifier.Type', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QSocketNotifier.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QSocketNotifier.isEnabled": (),
-    "PySide2.QtCore.QSocketNotifier.setEnabled": ('bool',),
-    "PySide2.QtCore.QSocketNotifier.socket": (),
-    "PySide2.QtCore.QSocketNotifier.type": (),
-# class PySide2.QtCore.QSortFilterProxyModel:
-    "PySide2.QtCore.QSortFilterProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QSortFilterProxyModel.buddy": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.dynamicSortFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsColumn": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterAcceptsRow": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.filterCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterKeyColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegExp": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRegularExpression": (),
-    "PySide2.QtCore.QSortFilterProxyModel.filterRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidate": (),
-    "PySide2.QtCore.QSortFilterProxyModel.invalidateFilter": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isRecursiveFilteringEnabled": (),
-    "PySide2.QtCore.QSortFilterProxyModel.isSortLocaleAware": (),
-    "PySide2.QtCore.QSortFilterProxyModel.lessThan": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionFromSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapSelectionToSource": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtCore.QSortFilterProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.match": ('PySide2.QtCore.QModelIndex', 'int', 'typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtCore.QSortFilterProxyModel.mimeTypes": (),
-    "PySide2.QtCore.QSortFilterProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QSortFilterProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setDynamicSortFilter": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterFixedString": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterKeyColumn": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegExp": [('PySide2.QtCore.QRegExp',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRegularExpression": [('PySide2.QtCore.QRegularExpression',), ('str',)],
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setFilterWildcard": ('str',),
-    "PySide2.QtCore.QSortFilterProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QSortFilterProxyModel.setRecursiveFilteringEnabled": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortLocaleAware": ('bool',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSortRole": ('int',),
-    "PySide2.QtCore.QSortFilterProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QSortFilterProxyModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QSortFilterProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QSortFilterProxyModel.sortCaseSensitivity": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortColumn": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortOrder": (),
-    "PySide2.QtCore.QSortFilterProxyModel.sortRole": (),
-    "PySide2.QtCore.QSortFilterProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QSortFilterProxyModel.supportedDropActions": (),
-# class PySide2.QtCore.QStandardPaths:
-# class PySide2.QtCore.QStandardPaths.LocateOption:
-# class PySide2.QtCore.QStandardPaths.LocateOptions:
-# class PySide2.QtCore.QStandardPaths.StandardLocation:
-    "PySide2.QtCore.QStandardPaths.displayName": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.enableTestMode": ('bool',),
-    "PySide2.QtCore.QStandardPaths.findExecutable": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtCore.QStandardPaths.isTestModeEnabled": (),
-    "PySide2.QtCore.QStandardPaths.locate": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.locateAll": ('PySide2.QtCore.QStandardPaths.StandardLocation', 'str', 'PySide2.QtCore.QStandardPaths.LocateOptions'),
-    "PySide2.QtCore.QStandardPaths.setTestModeEnabled": ('bool',),
-    "PySide2.QtCore.QStandardPaths.standardLocations": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-    "PySide2.QtCore.QStandardPaths.writableLocation": ('PySide2.QtCore.QStandardPaths.StandardLocation',),
-# class PySide2.QtCore.QState:
-# class PySide2.QtCore.QState.ChildMode:
-# class PySide2.QtCore.QState.RestorePolicy:
-    "PySide2.QtCore.QState.__init__": [('PySide2.QtCore.QState',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QState')],
-    "PySide2.QtCore.QState.addTransition": [('PySide2.QtCore.QAbstractState',), ('PySide2.QtCore.QAbstractTransition',), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QAbstractState'), ('object', 'PySide2.QtCore.QAbstractState')],
-    "PySide2.QtCore.QState.assignProperty": ('PySide2.QtCore.QObject', 'str', 'typing.Any'),
-    "PySide2.QtCore.QState.childMode": (),
-    "PySide2.QtCore.QState.errorState": (),
-    "PySide2.QtCore.QState.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.initialState": (),
-    "PySide2.QtCore.QState.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QState.removeTransition": ('PySide2.QtCore.QAbstractTransition',),
-    "PySide2.QtCore.QState.setChildMode": ('PySide2.QtCore.QState.ChildMode',),
-    "PySide2.QtCore.QState.setErrorState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.setInitialState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QState.transitions": (),
-# class PySide2.QtCore.QStateMachine:
-# class PySide2.QtCore.QStateMachine.Error:
-# class PySide2.QtCore.QStateMachine.EventPriority:
-# class PySide2.QtCore.QStateMachine.SignalEvent:
-    "PySide2.QtCore.QStateMachine.SignalEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'typing.Sequence[typing.Any]'), ('PySide2.QtCore.QStateMachine.SignalEvent',)],
-    "PySide2.QtCore.QStateMachine.SignalEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.arguments": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.sender": (),
-    "PySide2.QtCore.QStateMachine.SignalEvent.signalIndex": (),
-# class PySide2.QtCore.QStateMachine.WrappedEvent:
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'), ('PySide2.QtCore.QStateMachine.WrappedEvent',)],
-    "PySide2.QtCore.QStateMachine.WrappedEvent.__copy__": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.event": (),
-    "PySide2.QtCore.QStateMachine.WrappedEvent.object": (),
-    "PySide2.QtCore.QStateMachine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QState.ChildMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStateMachine.addDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.addState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.beginMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.beginSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.cancelDelayedEvent": ('int',),
-    "PySide2.QtCore.QStateMachine.clearError": (),
-    "PySide2.QtCore.QStateMachine.configuration": (),
-    "PySide2.QtCore.QStateMachine.defaultAnimations": (),
-    "PySide2.QtCore.QStateMachine.endMicrostep": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.endSelectTransitions": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.error": (),
-    "PySide2.QtCore.QStateMachine.errorString": (),
-    "PySide2.QtCore.QStateMachine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtCore.QStateMachine.globalRestorePolicy": (),
-    "PySide2.QtCore.QStateMachine.isAnimated": (),
-    "PySide2.QtCore.QStateMachine.isRunning": (),
-    "PySide2.QtCore.QStateMachine.onEntry": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.onExit": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QStateMachine.postDelayedEvent": ('PySide2.QtCore.QEvent', 'int'),
-    "PySide2.QtCore.QStateMachine.postEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QStateMachine.EventPriority'),
-    "PySide2.QtCore.QStateMachine.removeDefaultAnimation": ('PySide2.QtCore.QAbstractAnimation',),
-    "PySide2.QtCore.QStateMachine.removeState": ('PySide2.QtCore.QAbstractState',),
-    "PySide2.QtCore.QStateMachine.setAnimated": ('bool',),
-    "PySide2.QtCore.QStateMachine.setGlobalRestorePolicy": ('PySide2.QtCore.QState.RestorePolicy',),
-    "PySide2.QtCore.QStateMachine.setRunning": ('bool',),
-    "PySide2.QtCore.QStateMachine.start": (),
-    "PySide2.QtCore.QStateMachine.stop": (),
-# class PySide2.QtCore.QStorageInfo:
-    "PySide2.QtCore.QStorageInfo.__init__": [(), ('PySide2.QtCore.QDir',), ('PySide2.QtCore.QStorageInfo',), ('str',)],
-    "PySide2.QtCore.QStorageInfo.__copy__": (),
-    "PySide2.QtCore.QStorageInfo.blockSize": (),
-    "PySide2.QtCore.QStorageInfo.bytesAvailable": (),
-    "PySide2.QtCore.QStorageInfo.bytesFree": (),
-    "PySide2.QtCore.QStorageInfo.bytesTotal": (),
-    "PySide2.QtCore.QStorageInfo.device": (),
-    "PySide2.QtCore.QStorageInfo.displayName": (),
-    "PySide2.QtCore.QStorageInfo.fileSystemType": (),
-    "PySide2.QtCore.QStorageInfo.isReadOnly": (),
-    "PySide2.QtCore.QStorageInfo.isReady": (),
-    "PySide2.QtCore.QStorageInfo.isRoot": (),
-    "PySide2.QtCore.QStorageInfo.isValid": (),
-    "PySide2.QtCore.QStorageInfo.mountedVolumes": (),
-    "PySide2.QtCore.QStorageInfo.name": (),
-    "PySide2.QtCore.QStorageInfo.refresh": (),
-    "PySide2.QtCore.QStorageInfo.root": (),
-    "PySide2.QtCore.QStorageInfo.rootPath": (),
-    "PySide2.QtCore.QStorageInfo.setPath": ('str',),
-    "PySide2.QtCore.QStorageInfo.subvolume": (),
-    "PySide2.QtCore.QStorageInfo.swap": ('PySide2.QtCore.QStorageInfo',),
-# class PySide2.QtCore.QStringListModel:
-    "PySide2.QtCore.QStringListModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QStringListModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QStringListModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QStringListModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtCore.QStringListModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QStringListModel.setStringList": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QStringListModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QStringListModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QStringListModel.stringList": (),
-    "PySide2.QtCore.QStringListModel.supportedDropActions": (),
-# class PySide2.QtCore.QSysInfo:
-# class PySide2.QtCore.QSysInfo.Endian:
-# class PySide2.QtCore.QSysInfo.Sizes:
-    "PySide2.QtCore.QSysInfo.__init__": (),
-    "PySide2.QtCore.QSysInfo.bootUniqueId": (),
-    "PySide2.QtCore.QSysInfo.buildAbi": (),
-    "PySide2.QtCore.QSysInfo.buildCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.currentCpuArchitecture": (),
-    "PySide2.QtCore.QSysInfo.kernelType": (),
-    "PySide2.QtCore.QSysInfo.kernelVersion": (),
-    "PySide2.QtCore.QSysInfo.machineHostName": (),
-    "PySide2.QtCore.QSysInfo.machineUniqueId": (),
-    "PySide2.QtCore.QSysInfo.prettyProductName": (),
-    "PySide2.QtCore.QSysInfo.productType": (),
-    "PySide2.QtCore.QSysInfo.productVersion": (),
-# class PySide2.QtCore.QSystemSemaphore:
-# class PySide2.QtCore.QSystemSemaphore.AccessMode:
-# class PySide2.QtCore.QSystemSemaphore.SystemSemaphoreError:
-    "PySide2.QtCore.QSystemSemaphore.__init__": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-    "PySide2.QtCore.QSystemSemaphore.acquire": (),
-    "PySide2.QtCore.QSystemSemaphore.error": (),
-    "PySide2.QtCore.QSystemSemaphore.errorString": (),
-    "PySide2.QtCore.QSystemSemaphore.key": (),
-    "PySide2.QtCore.QSystemSemaphore.release": ('int',),
-    "PySide2.QtCore.QSystemSemaphore.setKey": ('str', 'int', 'PySide2.QtCore.QSystemSemaphore.AccessMode'),
-# class PySide2.QtCore.QTemporaryDir:
-    "PySide2.QtCore.QTemporaryDir.__init__": [(), ('str',)],
-    "PySide2.QtCore.QTemporaryDir.autoRemove": (),
-    "PySide2.QtCore.QTemporaryDir.errorString": (),
-    "PySide2.QtCore.QTemporaryDir.filePath": ('str',),
-    "PySide2.QtCore.QTemporaryDir.isValid": (),
-    "PySide2.QtCore.QTemporaryDir.path": (),
-    "PySide2.QtCore.QTemporaryDir.remove": (),
-    "PySide2.QtCore.QTemporaryDir.setAutoRemove": ('bool',),
-# class PySide2.QtCore.QTemporaryFile:
-    "PySide2.QtCore.QTemporaryFile.__init__": [(), ('PySide2.QtCore.QObject',), ('str',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCore.QTemporaryFile.autoRemove": (),
-    "PySide2.QtCore.QTemporaryFile.createLocalFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.createNativeFile": [('PySide2.QtCore.QFile',), ('str',)],
-    "PySide2.QtCore.QTemporaryFile.fileName": (),
-    "PySide2.QtCore.QTemporaryFile.fileTemplate": (),
-    "PySide2.QtCore.QTemporaryFile.open": [(), ('PySide2.QtCore.QIODevice.OpenMode',)],
-    "PySide2.QtCore.QTemporaryFile.rename": ('str',),
-    "PySide2.QtCore.QTemporaryFile.setAutoRemove": ('bool',),
-    "PySide2.QtCore.QTemporaryFile.setFileTemplate": ('str',),
-# class PySide2.QtCore.QTextBoundaryFinder:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReason:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryReasons:
-# class PySide2.QtCore.QTextBoundaryFinder.BoundaryType:
-    "PySide2.QtCore.QTextBoundaryFinder.__init__": [(), ('PySide2.QtCore.QTextBoundaryFinder',), ('PySide2.QtCore.QTextBoundaryFinder.BoundaryType', 'str')],
-    "PySide2.QtCore.QTextBoundaryFinder.__copy__": (),
-    "PySide2.QtCore.QTextBoundaryFinder.boundaryReasons": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isAtBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.isValid": (),
-    "PySide2.QtCore.QTextBoundaryFinder.position": (),
-    "PySide2.QtCore.QTextBoundaryFinder.setPosition": ('int',),
-    "PySide2.QtCore.QTextBoundaryFinder.string": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toEnd": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toNextBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toPreviousBoundary": (),
-    "PySide2.QtCore.QTextBoundaryFinder.toStart": (),
-    "PySide2.QtCore.QTextBoundaryFinder.type": (),
-# class PySide2.QtCore.QTextCodec:
-# class PySide2.QtCore.QTextCodec.ConversionFlag:
-# class PySide2.QtCore.QTextCodec.ConversionFlags:
-# class PySide2.QtCore.QTextCodec.ConverterState:
-    "PySide2.QtCore.QTextCodec.ConverterState.__init__": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.__init__": (),
-    "PySide2.QtCore.QTextCodec.aliases": (),
-    "PySide2.QtCore.QTextCodec.availableCodecs": (),
-    "PySide2.QtCore.QTextCodec.availableMibs": (),
-    "PySide2.QtCore.QTextCodec.canEncode": ('str',),
-    "PySide2.QtCore.QTextCodec.codecForHtml": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.codecForLocale": (),
-    "PySide2.QtCore.QTextCodec.codecForMib": ('int',),
-    "PySide2.QtCore.QTextCodec.codecForName": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QTextCodec.codecForUtfText": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QTextCodec')],
-    "PySide2.QtCore.QTextCodec.convertToUnicode": ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState'),
-    "PySide2.QtCore.QTextCodec.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextCodec.makeDecoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.makeEncoder": ('PySide2.QtCore.QTextCodec.ConversionFlags',),
-    "PySide2.QtCore.QTextCodec.mibEnum": (),
-    "PySide2.QtCore.QTextCodec.name": (),
-    "PySide2.QtCore.QTextCodec.setCodecForLocale": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtCore.QTextCodec.toUnicode": [('PySide2.QtCore.QByteArray',), ('str',), ('str', 'int', 'PySide2.QtCore.QTextCodec.ConverterState')],
-# class PySide2.QtCore.QTextDecoder:
-    "PySide2.QtCore.QTextDecoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextDecoder.hasFailure": (),
-    "PySide2.QtCore.QTextDecoder.needsMoreData": (),
-    "PySide2.QtCore.QTextDecoder.toUnicode": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtCore.QTextEncoder:
-    "PySide2.QtCore.QTextEncoder.__init__": [('PySide2.QtCore.QTextCodec',), ('PySide2.QtCore.QTextCodec', 'PySide2.QtCore.QTextCodec.ConversionFlags')],
-    "PySide2.QtCore.QTextEncoder.fromUnicode": ('str',),
-    "PySide2.QtCore.QTextEncoder.hasFailure": (),
-# class PySide2.QtCore.QTextStream:
-# class PySide2.QtCore.QTextStream.FieldAlignment:
-# class PySide2.QtCore.QTextStream.NumberFlag:
-# class PySide2.QtCore.QTextStream.NumberFlags:
-# class PySide2.QtCore.QTextStream.RealNumberNotation:
-# class PySide2.QtCore.QTextStream.Status:
-    "PySide2.QtCore.QTextStream.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice.OpenMode'), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QTextStream.__lshift__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QTextStreamManipulator',), ('float',), ('int',), ('str',)],
-    "PySide2.QtCore.QTextStream.__rshift__": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTextStream.atEnd": (),
-    "PySide2.QtCore.QTextStream.autoDetectUnicode": (),
-    "PySide2.QtCore.QTextStream.codec": (),
-    "PySide2.QtCore.QTextStream.device": (),
-    "PySide2.QtCore.QTextStream.fieldAlignment": (),
-    "PySide2.QtCore.QTextStream.fieldWidth": (),
-    "PySide2.QtCore.QTextStream.flush": (),
-    "PySide2.QtCore.QTextStream.generateByteOrderMark": (),
-    "PySide2.QtCore.QTextStream.integerBase": (),
-    "PySide2.QtCore.QTextStream.locale": (),
-    "PySide2.QtCore.QTextStream.numberFlags": (),
-    "PySide2.QtCore.QTextStream.padChar": (),
-    "PySide2.QtCore.QTextStream.pos": (),
-    "PySide2.QtCore.QTextStream.read": ('int',),
-    "PySide2.QtCore.QTextStream.readAll": (),
-    "PySide2.QtCore.QTextStream.readLine": ('int',),
-    "PySide2.QtCore.QTextStream.realNumberNotation": (),
-    "PySide2.QtCore.QTextStream.realNumberPrecision": (),
-    "PySide2.QtCore.QTextStream.reset": (),
-    "PySide2.QtCore.QTextStream.resetStatus": (),
-    "PySide2.QtCore.QTextStream.seek": ('int',),
-    "PySide2.QtCore.QTextStream.setAutoDetectUnicode": ('bool',),
-    "PySide2.QtCore.QTextStream.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QTextStream.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QTextStream.setFieldAlignment": ('PySide2.QtCore.QTextStream.FieldAlignment',),
-    "PySide2.QtCore.QTextStream.setFieldWidth": ('int',),
-    "PySide2.QtCore.QTextStream.setGenerateByteOrderMark": ('bool',),
-    "PySide2.QtCore.QTextStream.setIntegerBase": ('int',),
-    "PySide2.QtCore.QTextStream.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCore.QTextStream.setNumberFlags": ('PySide2.QtCore.QTextStream.NumberFlags',),
-    "PySide2.QtCore.QTextStream.setPadChar": ('str',),
-    "PySide2.QtCore.QTextStream.setRealNumberNotation": ('PySide2.QtCore.QTextStream.RealNumberNotation',),
-    "PySide2.QtCore.QTextStream.setRealNumberPrecision": ('int',),
-    "PySide2.QtCore.QTextStream.setStatus": ('PySide2.QtCore.QTextStream.Status',),
-    "PySide2.QtCore.QTextStream.skipWhiteSpace": (),
-    "PySide2.QtCore.QTextStream.status": (),
-    "PySide2.QtCore.QTextStream.string": (),
-# class PySide2.QtCore.QTextStreamManipulator:
-    "PySide2.QtCore.QTextStreamManipulator.__copy__": (),
-    "PySide2.QtCore.QTextStreamManipulator.exec_": ('PySide2.QtCore.QTextStream',),
-# class PySide2.QtCore.QThread:
-# class PySide2.QtCore.QThread.Priority:
-    "PySide2.QtCore.QThread.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThread.currentThread": (),
-    "PySide2.QtCore.QThread.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QThread.eventDispatcher": (),
-    "PySide2.QtCore.QThread.exec_": (),
-    "PySide2.QtCore.QThread.exit": ('int',),
-    "PySide2.QtCore.QThread.idealThreadCount": (),
-    "PySide2.QtCore.QThread.isFinished": (),
-    "PySide2.QtCore.QThread.isInterruptionRequested": (),
-    "PySide2.QtCore.QThread.isRunning": (),
-    "PySide2.QtCore.QThread.loopLevel": (),
-    "PySide2.QtCore.QThread.msleep": ('int',),
-    "PySide2.QtCore.QThread.priority": (),
-    "PySide2.QtCore.QThread.quit": (),
-    "PySide2.QtCore.QThread.requestInterruption": (),
-    "PySide2.QtCore.QThread.run": (),
-    "PySide2.QtCore.QThread.setEventDispatcher": ('PySide2.QtCore.QAbstractEventDispatcher',),
-    "PySide2.QtCore.QThread.setPriority": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.setStackSize": ('int',),
-    "PySide2.QtCore.QThread.setTerminationEnabled": ('bool',),
-    "PySide2.QtCore.QThread.sleep": ('int',),
-    "PySide2.QtCore.QThread.stackSize": (),
-    "PySide2.QtCore.QThread.start": ('PySide2.QtCore.QThread.Priority',),
-    "PySide2.QtCore.QThread.terminate": (),
-    "PySide2.QtCore.QThread.usleep": ('int',),
-    "PySide2.QtCore.QThread.wait": ('int',),
-    "PySide2.QtCore.QThread.yieldCurrentThread": (),
-# class PySide2.QtCore.QThreadPool:
-    "PySide2.QtCore.QThreadPool.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QThreadPool.activeThreadCount": (),
-    "PySide2.QtCore.QThreadPool.cancel": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.clear": (),
-    "PySide2.QtCore.QThreadPool.expiryTimeout": (),
-    "PySide2.QtCore.QThreadPool.globalInstance": (),
-    "PySide2.QtCore.QThreadPool.maxThreadCount": (),
-    "PySide2.QtCore.QThreadPool.releaseThread": (),
-    "PySide2.QtCore.QThreadPool.reserveThread": (),
-    "PySide2.QtCore.QThreadPool.setExpiryTimeout": ('int',),
-    "PySide2.QtCore.QThreadPool.setMaxThreadCount": ('int',),
-    "PySide2.QtCore.QThreadPool.setStackSize": ('int',),
-    "PySide2.QtCore.QThreadPool.stackSize": (),
-    "PySide2.QtCore.QThreadPool.start": ('PySide2.QtCore.QRunnable', 'int'),
-    "PySide2.QtCore.QThreadPool.tryStart": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.tryTake": ('PySide2.QtCore.QRunnable',),
-    "PySide2.QtCore.QThreadPool.waitForDone": ('int',),
-# class PySide2.QtCore.QTime:
-    "PySide2.QtCore.QTime.__init__": [(), ('PySide2.QtCore.QTime',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.__copy__": (),
-    "PySide2.QtCore.QTime.__reduce__": (),
-    "PySide2.QtCore.QTime.__repr__": (),
-    "PySide2.QtCore.QTime.addMSecs": ('int',),
-    "PySide2.QtCore.QTime.addSecs": ('int',),
-    "PySide2.QtCore.QTime.currentTime": (),
-    "PySide2.QtCore.QTime.elapsed": (),
-    "PySide2.QtCore.QTime.fromMSecsSinceStartOfDay": ('int',),
-    "PySide2.QtCore.QTime.fromString": [('str', 'PySide2.QtCore.Qt.DateFormat'), ('str', 'str')],
-    "PySide2.QtCore.QTime.hour": (),
-    "PySide2.QtCore.QTime.isNull": (),
-    "PySide2.QtCore.QTime.isValid": [(), ('int', 'int', 'int', 'int')],
-    "PySide2.QtCore.QTime.minute": (),
-    "PySide2.QtCore.QTime.msec": (),
-    "PySide2.QtCore.QTime.msecsSinceStartOfDay": (),
-    "PySide2.QtCore.QTime.msecsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.restart": (),
-    "PySide2.QtCore.QTime.second": (),
-    "PySide2.QtCore.QTime.secsTo": ('PySide2.QtCore.QTime',),
-    "PySide2.QtCore.QTime.setHMS": ('int', 'int', 'int', 'int'),
-    "PySide2.QtCore.QTime.start": (),
-    "PySide2.QtCore.QTime.toPython": (),
-    "PySide2.QtCore.QTime.toString": [('PySide2.QtCore.Qt.DateFormat',), ('str',)],
-# class PySide2.QtCore.QTimeLine:
-# class PySide2.QtCore.QTimeLine.CurveShape:
-# class PySide2.QtCore.QTimeLine.Direction:
-# class PySide2.QtCore.QTimeLine.State:
-    "PySide2.QtCore.QTimeLine.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCore.QTimeLine.currentFrame": (),
-    "PySide2.QtCore.QTimeLine.currentTime": (),
-    "PySide2.QtCore.QTimeLine.currentValue": (),
-    "PySide2.QtCore.QTimeLine.curveShape": (),
-    "PySide2.QtCore.QTimeLine.direction": (),
-    "PySide2.QtCore.QTimeLine.duration": (),
-    "PySide2.QtCore.QTimeLine.easingCurve": (),
-    "PySide2.QtCore.QTimeLine.endFrame": (),
-    "PySide2.QtCore.QTimeLine.frameForTime": ('int',),
-    "PySide2.QtCore.QTimeLine.loopCount": (),
-    "PySide2.QtCore.QTimeLine.resume": (),
-    "PySide2.QtCore.QTimeLine.setCurrentTime": ('int',),
-    "PySide2.QtCore.QTimeLine.setCurveShape": ('PySide2.QtCore.QTimeLine.CurveShape',),
-    "PySide2.QtCore.QTimeLine.setDirection": ('PySide2.QtCore.QTimeLine.Direction',),
-    "PySide2.QtCore.QTimeLine.setDuration": ('int',),
-    "PySide2.QtCore.QTimeLine.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QTimeLine.setEndFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setFrameRange": ('int', 'int'),
-    "PySide2.QtCore.QTimeLine.setLoopCount": ('int',),
-    "PySide2.QtCore.QTimeLine.setPaused": ('bool',),
-    "PySide2.QtCore.QTimeLine.setStartFrame": ('int',),
-    "PySide2.QtCore.QTimeLine.setUpdateInterval": ('int',),
-    "PySide2.QtCore.QTimeLine.start": (),
-    "PySide2.QtCore.QTimeLine.startFrame": (),
-    "PySide2.QtCore.QTimeLine.state": (),
-    "PySide2.QtCore.QTimeLine.stop": (),
-    "PySide2.QtCore.QTimeLine.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimeLine.toggleDirection": (),
-    "PySide2.QtCore.QTimeLine.updateInterval": (),
-    "PySide2.QtCore.QTimeLine.valueForTime": ('int',),
-# class PySide2.QtCore.QTimeZone:
-# class PySide2.QtCore.QTimeZone.NameType:
-# class PySide2.QtCore.QTimeZone.OffsetData:
-    "PySide2.QtCore.QTimeZone.OffsetData.__init__": [(), ('PySide2.QtCore.QTimeZone.OffsetData',)],
-    "PySide2.QtCore.QTimeZone.OffsetData.__copy__": (),
-# class PySide2.QtCore.QTimeZone.TimeType:
-    "PySide2.QtCore.QTimeZone.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'int', 'str', 'str', 'PySide2.QtCore.QLocale.Country', 'str'), ('PySide2.QtCore.QTimeZone',), ('int',)],
-    "PySide2.QtCore.QTimeZone.__copy__": (),
-    "PySide2.QtCore.QTimeZone.abbreviation": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.availableTimeZoneIds": [(), ('PySide2.QtCore.QLocale.Country',), ('int',)],
-    "PySide2.QtCore.QTimeZone.comment": (),
-    "PySide2.QtCore.QTimeZone.country": (),
-    "PySide2.QtCore.QTimeZone.daylightTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.displayName": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale'), ('PySide2.QtCore.QTimeZone.TimeType', 'PySide2.QtCore.QTimeZone.NameType', 'PySide2.QtCore.QLocale')],
-    "PySide2.QtCore.QTimeZone.hasDaylightTime": (),
-    "PySide2.QtCore.QTimeZone.hasTransitions": (),
-    "PySide2.QtCore.QTimeZone.ianaIdToWindowsId": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.id": (),
-    "PySide2.QtCore.QTimeZone.isDaylightTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.isTimeZoneIdAvailable": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QTimeZone.isValid": (),
-    "PySide2.QtCore.QTimeZone.nextTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetData": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.offsetFromUtc": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.previousTransition": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.standardTimeOffset": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtCore.QTimeZone.swap": ('PySide2.QtCore.QTimeZone',),
-    "PySide2.QtCore.QTimeZone.systemTimeZone": (),
-    "PySide2.QtCore.QTimeZone.systemTimeZoneId": (),
-    "PySide2.QtCore.QTimeZone.transitions": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtCore.QTimeZone.utc": (),
-    "PySide2.QtCore.QTimeZone.windowsIdToDefaultIanaId": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-    "PySide2.QtCore.QTimeZone.windowsIdToIanaIds": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QLocale.Country')],
-# class PySide2.QtCore.QTimer:
-    "PySide2.QtCore.QTimer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTimer.interval": (),
-    "PySide2.QtCore.QTimer.isActive": (),
-    "PySide2.QtCore.QTimer.isSingleShot": (),
-    "PySide2.QtCore.QTimer.killTimer": ('int',),
-    "PySide2.QtCore.QTimer.remainingTime": (),
-    "PySide2.QtCore.QTimer.setInterval": ('int',),
-    "PySide2.QtCore.QTimer.setSingleShot": ('bool',),
-    "PySide2.QtCore.QTimer.setTimerType": ('PySide2.QtCore.Qt.TimerType',),
-    "PySide2.QtCore.QTimer.singleShot": [('int', 'PySide2.QtCore.QObject', 'str'), ('int', 'PySide2.QtCore.Qt.TimerType', 'PySide2.QtCore.QObject', 'str'), ('int', 'typing.Callable')],
-    "PySide2.QtCore.QTimer.start": [(), ('int',)],
-    "PySide2.QtCore.QTimer.stop": (),
-    "PySide2.QtCore.QTimer.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtCore.QTimer.timerId": (),
-    "PySide2.QtCore.QTimer.timerType": (),
-# class PySide2.QtCore.QTimerEvent:
-    "PySide2.QtCore.QTimerEvent.__init__": ('int',),
-    "PySide2.QtCore.QTimerEvent.timerId": (),
-# class PySide2.QtCore.QTranslator:
-    "PySide2.QtCore.QTranslator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTranslator.isEmpty": (),
-    "PySide2.QtCore.QTranslator.load": [('PySide2.QtCore.QLocale', 'str', 'str', 'str', 'str'), ('str', 'int', 'str'), ('str', 'str', 'str', 'str')],
-    "PySide2.QtCore.QTranslator.translate": ('str', 'str', 'str', 'int'),
-# class PySide2.QtCore.QTransposeProxyModel:
-    "PySide2.QtCore.QTransposeProxyModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QTransposeProxyModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapFromSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.mapToSource": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.moveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.moveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtCore.QTransposeProxyModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtCore.QTransposeProxyModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtCore.QTransposeProxyModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtCore.QTransposeProxyModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtCore.QTransposeProxyModel.setSourceModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCore.QTransposeProxyModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtCore.QTransposeProxyModel.span": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtCore.QUrl:
-# class PySide2.QtCore.QUrl.ComponentFormattingOption:
-# class PySide2.QtCore.QUrl.FormattingOptions:
-# class PySide2.QtCore.QUrl.ParsingMode:
-# class PySide2.QtCore.QUrl.UrlFormattingOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOption:
-# class PySide2.QtCore.QUrl.UserInputResolutionOptions:
-    "PySide2.QtCore.QUrl.__init__": [(), ('PySide2.QtCore.QUrl',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.__copy__": (),
-    "PySide2.QtCore.QUrl.__reduce__": (),
-    "PySide2.QtCore.QUrl.__repr__": (),
-    "PySide2.QtCore.QUrl.adjusted": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.authority": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.clear": (),
-    "PySide2.QtCore.QUrl.errorString": (),
-    "PySide2.QtCore.QUrl.fileName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fragment": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.fromAce": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromEncoded": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromLocalFile": ('str',),
-    "PySide2.QtCore.QUrl.fromPercentEncoding": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUrl.fromStringList": ('typing.Sequence[str]', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.fromUserInput": [('str',), ('str', 'str', 'PySide2.QtCore.QUrl.UserInputResolutionOptions')],
-    "PySide2.QtCore.QUrl.hasFragment": (),
-    "PySide2.QtCore.QUrl.hasQuery": (),
-    "PySide2.QtCore.QUrl.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.idnWhitelist": (),
-    "PySide2.QtCore.QUrl.isEmpty": (),
-    "PySide2.QtCore.QUrl.isLocalFile": (),
-    "PySide2.QtCore.QUrl.isParentOf": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.isRelative": (),
-    "PySide2.QtCore.QUrl.isValid": (),
-    "PySide2.QtCore.QUrl.matches": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.password": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.path": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.port": ('int',),
-    "PySide2.QtCore.QUrl.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.resolved": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.scheme": (),
-    "PySide2.QtCore.QUrl.setAuthority": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setFragment": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setIdnWhitelist": ('typing.Sequence[str]',),
-    "PySide2.QtCore.QUrl.setPassword": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPath": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setPort": ('int',),
-    "PySide2.QtCore.QUrl.setQuery": [('PySide2.QtCore.QUrlQuery',), ('str', 'PySide2.QtCore.QUrl.ParsingMode')],
-    "PySide2.QtCore.QUrl.setScheme": ('str',),
-    "PySide2.QtCore.QUrl.setUrl": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserInfo": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.setUserName": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtCore.QUrl.swap": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtCore.QUrl.toAce": ('str',),
-    "PySide2.QtCore.QUrl.toDisplayString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toEncoded": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toLocalFile": (),
-    "PySide2.QtCore.QUrl.toPercentEncoding": ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtCore.QUrl.toString": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.toStringList": ('typing.Sequence[PySide2.QtCore.QUrl]', 'PySide2.QtCore.QUrl.FormattingOptions'),
-    "PySide2.QtCore.QUrl.topLevelDomain": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.url": ('PySide2.QtCore.QUrl.FormattingOptions',),
-    "PySide2.QtCore.QUrl.userInfo": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrl.userName": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUrlQuery:
-    "PySide2.QtCore.QUrlQuery.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrlQuery',), ('str',)],
-    "PySide2.QtCore.QUrlQuery.__copy__": (),
-    "PySide2.QtCore.QUrlQuery.addQueryItem": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.allQueryItemValues": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.clear": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.defaultQueryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.hasQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.isEmpty": (),
-    "PySide2.QtCore.QUrlQuery.query": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryItemValue": ('str', 'PySide2.QtCore.QUrl.ComponentFormattingOption'),
-    "PySide2.QtCore.QUrlQuery.queryItems": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtCore.QUrlQuery.queryPairDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.queryValueDelimiter": (),
-    "PySide2.QtCore.QUrlQuery.removeAllQueryItems": ('str',),
-    "PySide2.QtCore.QUrlQuery.removeQueryItem": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQuery": ('str',),
-    "PySide2.QtCore.QUrlQuery.setQueryDelimiters": ('str', 'str'),
-    "PySide2.QtCore.QUrlQuery.setQueryItems": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtCore.QUrlQuery.swap": ('PySide2.QtCore.QUrlQuery',),
-    "PySide2.QtCore.QUrlQuery.toString": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-# class PySide2.QtCore.QUuid:
-# class PySide2.QtCore.QUuid.StringFormat:
-# class PySide2.QtCore.QUuid.Variant:
-# class PySide2.QtCore.QUuid.Version:
-    "PySide2.QtCore.QUuid.__init__": [(), ('PySide2.QtCore.QByteArray',), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'), ('str',)],
-    "PySide2.QtCore.QUuid.__copy__": (),
-    "PySide2.QtCore.QUuid.__reduce__": (),
-    "PySide2.QtCore.QUuid.__repr__": (),
-    "PySide2.QtCore.QUuid.createUuid": (),
-    "PySide2.QtCore.QUuid.createUuidV3": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.createUuidV5": [('PySide2.QtCore.QUuid', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QUuid', 'str')],
-    "PySide2.QtCore.QUuid.fromRfc4122": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtCore.QUuid.isNull": (),
-    "PySide2.QtCore.QUuid.toByteArray": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.toRfc4122": (),
-    "PySide2.QtCore.QUuid.toString": [(), ('PySide2.QtCore.QUuid.StringFormat',)],
-    "PySide2.QtCore.QUuid.variant": (),
-    "PySide2.QtCore.QUuid.version": (),
-# class PySide2.QtCore.QVariantAnimation:
-    "PySide2.QtCore.QVariantAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCore.QVariantAnimation.currentValue": (),
-    "PySide2.QtCore.QVariantAnimation.duration": (),
-    "PySide2.QtCore.QVariantAnimation.easingCurve": (),
-    "PySide2.QtCore.QVariantAnimation.endValue": (),
-    "PySide2.QtCore.QVariantAnimation.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtCore.QVariantAnimation.interpolated": ('typing.Any', 'typing.Any', 'float'),
-    "PySide2.QtCore.QVariantAnimation.keyValueAt": ('float',),
-    "PySide2.QtCore.QVariantAnimation.keyValues": (),
-    "PySide2.QtCore.QVariantAnimation.setDuration": ('int',),
-    "PySide2.QtCore.QVariantAnimation.setEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCore.QVariantAnimation.setEndValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.setKeyValueAt": ('float', 'typing.Any'),
-    "PySide2.QtCore.QVariantAnimation.setKeyValues": ('typing.List[typing.Tuple]',),
-    "PySide2.QtCore.QVariantAnimation.setStartValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.startValue": (),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentTime": ('int',),
-    "PySide2.QtCore.QVariantAnimation.updateCurrentValue": ('typing.Any',),
-    "PySide2.QtCore.QVariantAnimation.updateState": ('PySide2.QtCore.QAbstractAnimation.State', 'PySide2.QtCore.QAbstractAnimation.State'),
-# class PySide2.QtCore.QVersionNumber:
-    "PySide2.QtCore.QVersionNumber.__init__": [(), ('int',), ('int', 'int'), ('int', 'int', 'int'), ('typing.List[int]',)],
-    "PySide2.QtCore.QVersionNumber.__copy__": (),
-    "PySide2.QtCore.QVersionNumber.commonPrefix": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.compare": ('PySide2.QtCore.QVersionNumber', 'PySide2.QtCore.QVersionNumber'),
-    "PySide2.QtCore.QVersionNumber.fromString": ('str',),
-    "PySide2.QtCore.QVersionNumber.isNormalized": (),
-    "PySide2.QtCore.QVersionNumber.isNull": (),
-    "PySide2.QtCore.QVersionNumber.isPrefixOf": ('PySide2.QtCore.QVersionNumber',),
-    "PySide2.QtCore.QVersionNumber.majorVersion": (),
-    "PySide2.QtCore.QVersionNumber.microVersion": (),
-    "PySide2.QtCore.QVersionNumber.minorVersion": (),
-    "PySide2.QtCore.QVersionNumber.normalized": (),
-    "PySide2.QtCore.QVersionNumber.segmentAt": ('int',),
-    "PySide2.QtCore.QVersionNumber.segmentCount": (),
-    "PySide2.QtCore.QVersionNumber.segments": (),
-    "PySide2.QtCore.QVersionNumber.toString": (),
-# class PySide2.QtCore.QWaitCondition:
-    "PySide2.QtCore.QWaitCondition.__init__": (),
-    "PySide2.QtCore.QWaitCondition.notify_all": (),
-    "PySide2.QtCore.QWaitCondition.notify_one": (),
-    "PySide2.QtCore.QWaitCondition.wait": [('PySide2.QtCore.QMutex', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QMutex', 'int'), ('PySide2.QtCore.QReadWriteLock', 'PySide2.QtCore.QDeadlineTimer'), ('PySide2.QtCore.QReadWriteLock', 'int')],
-    "PySide2.QtCore.QWaitCondition.wakeAll": (),
-    "PySide2.QtCore.QWaitCondition.wakeOne": (),
-# class PySide2.QtCore.QWriteLocker:
-    "PySide2.QtCore.QWriteLocker.__init__": ('PySide2.QtCore.QReadWriteLock',),
-    "PySide2.QtCore.QWriteLocker.__enter__": (),
-    "PySide2.QtCore.QWriteLocker.__exit__": ('object', 'object', 'object'),
-    "PySide2.QtCore.QWriteLocker.readWriteLock": (),
-    "PySide2.QtCore.QWriteLocker.relock": (),
-    "PySide2.QtCore.QWriteLocker.unlock": (),
-# class PySide2.QtCore.QXmlStreamAttribute:
-    "PySide2.QtCore.QXmlStreamAttribute.__init__": [(), ('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttribute.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttribute.isDefault": (),
-    "PySide2.QtCore.QXmlStreamAttribute.name": (),
-    "PySide2.QtCore.QXmlStreamAttribute.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamAttribute.prefix": (),
-    "PySide2.QtCore.QXmlStreamAttribute.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamAttribute.value": (),
-# class PySide2.QtCore.QXmlStreamAttributes:
-    "PySide2.QtCore.QXmlStreamAttributes.__init__": [(), ('PySide2.QtCore.QXmlStreamAttributes',)],
-    "PySide2.QtCore.QXmlStreamAttributes.__add__": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.__copy__": (),
-    "PySide2.QtCore.QXmlStreamAttributes.__iadd__": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.__lshift__": [('PySide2.QtCore.QXmlStreamAttribute',), ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',)],
-    "PySide2.QtCore.QXmlStreamAttributes.append": [('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.at": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.back": (),
-    "PySide2.QtCore.QXmlStreamAttributes.capacity": (),
-    "PySide2.QtCore.QXmlStreamAttributes.clear": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constData": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.constLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.contains": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.count": [(), ('PySide2.QtCore.QXmlStreamAttribute',)],
-    "PySide2.QtCore.QXmlStreamAttributes.data": (),
-    "PySide2.QtCore.QXmlStreamAttributes.empty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.endsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.fill": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.first": (),
-    "PySide2.QtCore.QXmlStreamAttributes.front": (),
-    "PySide2.QtCore.QXmlStreamAttributes.hasAttribute": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamAttributes.indexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.insert": [('int', 'PySide2.QtCore.QXmlStreamAttribute'), ('int', 'int', 'PySide2.QtCore.QXmlStreamAttribute')],
-    "PySide2.QtCore.QXmlStreamAttributes.isEmpty": (),
-    "PySide2.QtCore.QXmlStreamAttributes.isSharedWith": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.last": (),
-    "PySide2.QtCore.QXmlStreamAttributes.lastIndexOf": ('PySide2.QtCore.QXmlStreamAttribute', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.length": (),
-    "PySide2.QtCore.QXmlStreamAttributes.mid": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.move": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.prepend": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.remove": [('int',), ('int', 'int')],
-    "PySide2.QtCore.QXmlStreamAttributes.removeAll": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.removeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.removeOne": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.replace": ('int', 'PySide2.QtCore.QXmlStreamAttribute'),
-    "PySide2.QtCore.QXmlStreamAttributes.reserve": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.resize": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.setSharable": ('bool',),
-    "PySide2.QtCore.QXmlStreamAttributes.shrink_to_fit": (),
-    "PySide2.QtCore.QXmlStreamAttributes.size": (),
-    "PySide2.QtCore.QXmlStreamAttributes.squeeze": (),
-    "PySide2.QtCore.QXmlStreamAttributes.startsWith": ('PySide2.QtCore.QXmlStreamAttribute',),
-    "PySide2.QtCore.QXmlStreamAttributes.swap": ('typing.List[PySide2.QtCore.QXmlStreamAttribute]',),
-    "PySide2.QtCore.QXmlStreamAttributes.swapItemsAt": ('int', 'int'),
-    "PySide2.QtCore.QXmlStreamAttributes.takeAt": ('int',),
-    "PySide2.QtCore.QXmlStreamAttributes.takeFirst": (),
-    "PySide2.QtCore.QXmlStreamAttributes.takeLast": (),
-    "PySide2.QtCore.QXmlStreamAttributes.value": [('str',), ('str', 'str')],
-# class PySide2.QtCore.QXmlStreamEntityDeclaration:
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamEntityDeclaration',)],
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.notationName": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.systemId": (),
-    "PySide2.QtCore.QXmlStreamEntityDeclaration.value": (),
-# class PySide2.QtCore.QXmlStreamEntityResolver:
-    "PySide2.QtCore.QXmlStreamEntityResolver.__init__": (),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveEntity": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamEntityResolver.resolveUndeclaredEntity": ('str',),
-# class PySide2.QtCore.QXmlStreamNamespaceDeclaration:
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamNamespaceDeclaration.prefix": (),
-# class PySide2.QtCore.QXmlStreamNotationDeclaration:
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__init__": [(), ('PySide2.QtCore.QXmlStreamNotationDeclaration',)],
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.__copy__": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.name": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.publicId": (),
-    "PySide2.QtCore.QXmlStreamNotationDeclaration.systemId": (),
-# class PySide2.QtCore.QXmlStreamReader:
-# class PySide2.QtCore.QXmlStreamReader.Error:
-# class PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour:
-# class PySide2.QtCore.QXmlStreamReader.TokenType:
-    "PySide2.QtCore.QXmlStreamReader.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addData": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclaration": ('PySide2.QtCore.QXmlStreamNamespaceDeclaration',),
-    "PySide2.QtCore.QXmlStreamReader.addExtraNamespaceDeclarations": ('typing.List[PySide2.QtCore.QXmlStreamNamespaceDeclaration]',),
-    "PySide2.QtCore.QXmlStreamReader.atEnd": (),
-    "PySide2.QtCore.QXmlStreamReader.attributes": (),
-    "PySide2.QtCore.QXmlStreamReader.characterOffset": (),
-    "PySide2.QtCore.QXmlStreamReader.clear": (),
-    "PySide2.QtCore.QXmlStreamReader.columnNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.device": (),
-    "PySide2.QtCore.QXmlStreamReader.documentEncoding": (),
-    "PySide2.QtCore.QXmlStreamReader.documentVersion": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdName": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdPublicId": (),
-    "PySide2.QtCore.QXmlStreamReader.dtdSystemId": (),
-    "PySide2.QtCore.QXmlStreamReader.entityDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.entityResolver": (),
-    "PySide2.QtCore.QXmlStreamReader.error": (),
-    "PySide2.QtCore.QXmlStreamReader.errorString": (),
-    "PySide2.QtCore.QXmlStreamReader.hasError": (),
-    "PySide2.QtCore.QXmlStreamReader.isCDATA": (),
-    "PySide2.QtCore.QXmlStreamReader.isCharacters": (),
-    "PySide2.QtCore.QXmlStreamReader.isComment": (),
-    "PySide2.QtCore.QXmlStreamReader.isDTD": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isEndElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isEntityReference": (),
-    "PySide2.QtCore.QXmlStreamReader.isProcessingInstruction": (),
-    "PySide2.QtCore.QXmlStreamReader.isStandaloneDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartDocument": (),
-    "PySide2.QtCore.QXmlStreamReader.isStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.isWhitespace": (),
-    "PySide2.QtCore.QXmlStreamReader.lineNumber": (),
-    "PySide2.QtCore.QXmlStreamReader.name": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceProcessing": (),
-    "PySide2.QtCore.QXmlStreamReader.namespaceUri": (),
-    "PySide2.QtCore.QXmlStreamReader.notationDeclarations": (),
-    "PySide2.QtCore.QXmlStreamReader.prefix": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionData": (),
-    "PySide2.QtCore.QXmlStreamReader.processingInstructionTarget": (),
-    "PySide2.QtCore.QXmlStreamReader.qualifiedName": (),
-    "PySide2.QtCore.QXmlStreamReader.raiseError": ('str',),
-    "PySide2.QtCore.QXmlStreamReader.readElementText": ('PySide2.QtCore.QXmlStreamReader.ReadElementTextBehaviour',),
-    "PySide2.QtCore.QXmlStreamReader.readNext": (),
-    "PySide2.QtCore.QXmlStreamReader.readNextStartElement": (),
-    "PySide2.QtCore.QXmlStreamReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamReader.setEntityResolver": ('PySide2.QtCore.QXmlStreamEntityResolver',),
-    "PySide2.QtCore.QXmlStreamReader.setNamespaceProcessing": ('bool',),
-    "PySide2.QtCore.QXmlStreamReader.skipCurrentElement": (),
-    "PySide2.QtCore.QXmlStreamReader.text": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenString": (),
-    "PySide2.QtCore.QXmlStreamReader.tokenType": (),
-# class PySide2.QtCore.QXmlStreamWriter:
-    "PySide2.QtCore.QXmlStreamWriter.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtCore.QXmlStreamWriter.autoFormatting": (),
-    "PySide2.QtCore.QXmlStreamWriter.autoFormattingIndent": (),
-    "PySide2.QtCore.QXmlStreamWriter.codec": (),
-    "PySide2.QtCore.QXmlStreamWriter.device": (),
-    "PySide2.QtCore.QXmlStreamWriter.hasError": (),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormatting": ('bool',),
-    "PySide2.QtCore.QXmlStreamWriter.setAutoFormattingIndent": ('int',),
-    "PySide2.QtCore.QXmlStreamWriter.setCodec": [('PySide2.QtCore.QTextCodec',), ('str',)],
-    "PySide2.QtCore.QXmlStreamWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtCore.QXmlStreamWriter.writeAttribute": [('PySide2.QtCore.QXmlStreamAttribute',), ('str', 'str'), ('str', 'str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeAttributes": ('PySide2.QtCore.QXmlStreamAttributes',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCDATA": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCharacters": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeComment": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeCurrentToken": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDTD": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeDefaultNamespace": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeEmptyElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeEndDocument": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEndElement": (),
-    "PySide2.QtCore.QXmlStreamWriter.writeEntityReference": ('str',),
-    "PySide2.QtCore.QXmlStreamWriter.writeNamespace": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeProcessingInstruction": ('str', 'str'),
-    "PySide2.QtCore.QXmlStreamWriter.writeStartDocument": [(), ('str',), ('str', 'bool')],
-    "PySide2.QtCore.QXmlStreamWriter.writeStartElement": [('str',), ('str', 'str')],
-    "PySide2.QtCore.QXmlStreamWriter.writeTextElement": [('str', 'str'), ('str', 'str', 'str')],
-# class PySide2.QtCore.Qt:
-# class PySide2.QtCore.Qt.Alignment:
-# class PySide2.QtCore.Qt.AlignmentFlag:
-# class PySide2.QtCore.Qt.AnchorPoint:
-# class PySide2.QtCore.Qt.ApplicationAttribute:
-# class PySide2.QtCore.Qt.ApplicationState:
-# class PySide2.QtCore.Qt.ApplicationStates:
-# class PySide2.QtCore.Qt.ArrowType:
-# class PySide2.QtCore.Qt.AspectRatioMode:
-# class PySide2.QtCore.Qt.Axis:
-# class PySide2.QtCore.Qt.BGMode:
-# class PySide2.QtCore.Qt.BrushStyle:
-# class PySide2.QtCore.Qt.CaseSensitivity:
-# class PySide2.QtCore.Qt.CheckState:
-# class PySide2.QtCore.Qt.ChecksumType:
-# class PySide2.QtCore.Qt.ClipOperation:
-# class PySide2.QtCore.Qt.ConnectionType:
-# class PySide2.QtCore.Qt.ContextMenuPolicy:
-# class PySide2.QtCore.Qt.CoordinateSystem:
-# class PySide2.QtCore.Qt.Corner:
-# class PySide2.QtCore.Qt.CursorMoveStyle:
-# class PySide2.QtCore.Qt.CursorShape:
-# class PySide2.QtCore.Qt.DateFormat:
-# class PySide2.QtCore.Qt.DayOfWeek:
-# class PySide2.QtCore.Qt.DockWidgetArea:
-# class PySide2.QtCore.Qt.DockWidgetAreaSizes:
-# class PySide2.QtCore.Qt.DockWidgetAreas:
-# class PySide2.QtCore.Qt.DropAction:
-# class PySide2.QtCore.Qt.DropActions:
-# class PySide2.QtCore.Qt.Edge:
-# class PySide2.QtCore.Qt.Edges:
-# class PySide2.QtCore.Qt.EnterKeyType:
-# class PySide2.QtCore.Qt.EventPriority:
-# class PySide2.QtCore.Qt.FillRule:
-# class PySide2.QtCore.Qt.FindChildOption:
-# class PySide2.QtCore.Qt.FindChildOptions:
-# class PySide2.QtCore.Qt.FocusPolicy:
-# class PySide2.QtCore.Qt.FocusReason:
-# class PySide2.QtCore.Qt.GestureFlag:
-# class PySide2.QtCore.Qt.GestureFlags:
-# class PySide2.QtCore.Qt.GestureState:
-# class PySide2.QtCore.Qt.GestureType:
-# class PySide2.QtCore.Qt.GlobalColor:
-# class PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy:
-# class PySide2.QtCore.Qt.HitTestAccuracy:
-# class PySide2.QtCore.Qt.ImageConversionFlag:
-# class PySide2.QtCore.Qt.ImageConversionFlags:
-# class PySide2.QtCore.Qt.InputMethodHint:
-# class PySide2.QtCore.Qt.InputMethodHints:
-# class PySide2.QtCore.Qt.InputMethodQueries:
-# class PySide2.QtCore.Qt.InputMethodQuery:
-# class PySide2.QtCore.Qt.ItemDataRole:
-# class PySide2.QtCore.Qt.ItemFlag:
-# class PySide2.QtCore.Qt.ItemFlags:
-# class PySide2.QtCore.Qt.ItemSelectionMode:
-# class PySide2.QtCore.Qt.ItemSelectionOperation:
-# class PySide2.QtCore.Qt.Key:
-# class PySide2.QtCore.Qt.KeyboardModifier:
-# class PySide2.QtCore.Qt.KeyboardModifiers:
-# class PySide2.QtCore.Qt.LayoutDirection:
-# class PySide2.QtCore.Qt.MaskMode:
-# class PySide2.QtCore.Qt.MatchFlag:
-# class PySide2.QtCore.Qt.MatchFlags:
-# class PySide2.QtCore.Qt.Modifier:
-# class PySide2.QtCore.Qt.MouseButton:
-# class PySide2.QtCore.Qt.MouseButtons:
-# class PySide2.QtCore.Qt.MouseEventFlag:
-# class PySide2.QtCore.Qt.MouseEventFlags:
-# class PySide2.QtCore.Qt.MouseEventSource:
-# class PySide2.QtCore.Qt.NativeGestureType:
-# class PySide2.QtCore.Qt.NavigationMode:
-# class PySide2.QtCore.Qt.Orientation:
-# class PySide2.QtCore.Qt.Orientations:
-# class PySide2.QtCore.Qt.PenCapStyle:
-# class PySide2.QtCore.Qt.PenJoinStyle:
-# class PySide2.QtCore.Qt.PenStyle:
-# class PySide2.QtCore.Qt.ScreenOrientation:
-# class PySide2.QtCore.Qt.ScreenOrientations:
-# class PySide2.QtCore.Qt.ScrollBarPolicy:
-# class PySide2.QtCore.Qt.ScrollPhase:
-# class PySide2.QtCore.Qt.ShortcutContext:
-# class PySide2.QtCore.Qt.SizeHint:
-# class PySide2.QtCore.Qt.SizeMode:
-# class PySide2.QtCore.Qt.SortOrder:
-# class PySide2.QtCore.Qt.SplitBehavior:
-# class PySide2.QtCore.Qt.SplitBehaviorFlags:
-# class PySide2.QtCore.Qt.TabFocusBehavior:
-# class PySide2.QtCore.Qt.TextElideMode:
-# class PySide2.QtCore.Qt.TextFlag:
-# class PySide2.QtCore.Qt.TextFormat:
-# class PySide2.QtCore.Qt.TextInteractionFlag:
-# class PySide2.QtCore.Qt.TextInteractionFlags:
-# class PySide2.QtCore.Qt.TileRule:
-# class PySide2.QtCore.Qt.TimeSpec:
-# class PySide2.QtCore.Qt.TimerType:
-# class PySide2.QtCore.Qt.ToolBarArea:
-# class PySide2.QtCore.Qt.ToolBarAreaSizes:
-# class PySide2.QtCore.Qt.ToolBarAreas:
-# class PySide2.QtCore.Qt.ToolButtonStyle:
-# class PySide2.QtCore.Qt.TouchPointState:
-# class PySide2.QtCore.Qt.TouchPointStates:
-# class PySide2.QtCore.Qt.TransformationMode:
-# class PySide2.QtCore.Qt.UIEffect:
-# class PySide2.QtCore.Qt.WhiteSpaceMode:
-# class PySide2.QtCore.Qt.WidgetAttribute:
-# class PySide2.QtCore.Qt.WindowFlags:
-# class PySide2.QtCore.Qt.WindowFrameSection:
-# class PySide2.QtCore.Qt.WindowModality:
-# class PySide2.QtCore.Qt.WindowState:
-# class PySide2.QtCore.Qt.WindowStates:
-# class PySide2.QtCore.Qt.WindowType:
-# class PySide2.QtCore.QtMsgType:
-# class PySide2.QtCore.Signal:
-    "PySide2.QtCore.Signal.__init__": ('type', 'str', 'str'),
-# class PySide2.QtCore.SignalInstance:
-    "PySide2.QtCore.SignalInstance.connect": ('object', 'type'),
-    "PySide2.QtCore.SignalInstance.disconnect": ('object',),
-    "PySide2.QtCore.SignalInstance.emit": ('typing.Any',),
-# class PySide2.QtCore.Slot:
-    "PySide2.QtCore.Slot.__init__": ('type', 'str', 'str'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP": ('object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP3": ('object', 'object', 'object'),
-    "PySide2.QtCore.Slot.QT_TRANSLATE_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP": ('object',),
-    "PySide2.QtCore.Slot.QT_TR_NOOP_UTF8": ('object',),
-    "PySide2.QtCore.Slot.SIGNAL": ('str',),
-    "PySide2.QtCore.Slot.SLOT": ('str',),
-    "PySide2.QtCore.Slot.__moduleShutdown": (),
-    "PySide2.QtCore.Slot.qAbs": ('float',),
-    "PySide2.QtCore.Slot.qAcos": ('float',),
-    "PySide2.QtCore.Slot.qAddPostRoutine": ('object',),
-    "PySide2.QtCore.Slot.qAsin": ('float',),
-    "PySide2.QtCore.Slot.qAtan": ('float',),
-    "PySide2.QtCore.Slot.qAtan2": ('float', 'float'),
-    "PySide2.QtCore.Slot.qChecksum": ('str', 'int'),
-    "PySide2.QtCore.Slot.qCompress": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtCore.Slot.qCritical": ('str',),
-    "PySide2.QtCore.Slot.qDebug": ('str',),
-    "PySide2.QtCore.Slot.qExp": ('float',),
-    "PySide2.QtCore.Slot.qFabs": ('float',),
-    "PySide2.QtCore.Slot.qFastCos": ('float',),
-    "PySide2.QtCore.Slot.qFastSin": ('float',),
-    "PySide2.QtCore.Slot.qFatal": ('str',),
-    "PySide2.QtCore.Slot.qFuzzyCompare": ('float', 'float'),
-    "PySide2.QtCore.Slot.qFuzzyIsNull": ('float',),
-    "PySide2.QtCore.Slot.qInstallMessageHandler": ('object',),
-    "PySide2.QtCore.Slot.qIsFinite": ('float',),
-    "PySide2.QtCore.Slot.qIsInf": ('float',),
-    "PySide2.QtCore.Slot.qIsNaN": ('float',),
-    "PySide2.QtCore.Slot.qIsNull": ('float',),
-    "PySide2.QtCore.Slot.qRegisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qTan": ('float',),
-    "PySide2.QtCore.Slot.qUncompress": [('PySide2.QtCore.QByteArray',), ('str', 'int')],
-    "PySide2.QtCore.Slot.qUnregisterResourceData": ('int', 'str', 'str', 'str'),
-    "PySide2.QtCore.Slot.qVersion": (),
-    "PySide2.QtCore.Slot.qWarning": ('str',),
-    "PySide2.QtCore.Slot.qrand": (),
-    "PySide2.QtCore.Slot.qsrand": ('int',),
-    "PySide2.QtCore.Slot.qtTrId": ('str', 'int'),
-    }) if "PySide2.QtCore" in sys.modules else None
-# Module PySide2.QtGui
-sig_dict.update({
-# class PySide2.QtGui.QAbstractOpenGLFunctions:
-    "PySide2.QtGui.QAbstractOpenGLFunctions.__init__": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.isInitialized": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.owningContext": (),
-    "PySide2.QtGui.QAbstractOpenGLFunctions.setOwningContext": ('PySide2.QtGui.QOpenGLContext',),
-# class PySide2.QtGui.QAbstractTextDocumentLayout:
-# class PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext.__copy__": (),
-# class PySide2.QtGui.QAbstractTextDocumentLayout.Selection:
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__init__": [(), ('PySide2.QtGui.QAbstractTextDocumentLayout.Selection',)],
-    "PySide2.QtGui.QAbstractTextDocumentLayout.Selection.__copy__": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.anchorAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.blockWithMarkerAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.document": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.documentSize": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.drawInlineObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.format": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.formatIndex": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.handlerForObject": ('int',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.imageAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.pageCount": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.paintDevice": (),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.positionInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.registerHandler": ('int', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.resizeInlineObject": ('PySide2.QtGui.QTextInlineObject', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.setPaintDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QAbstractTextDocumentLayout.unregisterHandler": ('int', 'PySide2.QtCore.QObject'),
-# class PySide2.QtGui.QAccessible:
-# class PySide2.QtGui.QAccessible.Event:
-# class PySide2.QtGui.QAccessible.InterfaceType:
-# class PySide2.QtGui.QAccessible.Relation:
-# class PySide2.QtGui.QAccessible.RelationFlag:
-# class PySide2.QtGui.QAccessible.Role:
-# class PySide2.QtGui.QAccessible.State:
-    "PySide2.QtGui.QAccessible.State.__init__": [(), ('PySide2.QtGui.QAccessible.State',)],
-    "PySide2.QtGui.QAccessible.State.__copy__": (),
-# class PySide2.QtGui.QAccessible.Text:
-# class PySide2.QtGui.QAccessible.TextBoundaryType:
-    "PySide2.QtGui.QAccessible.__copy__": (),
-    "PySide2.QtGui.QAccessible.accessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.cleanup": (),
-    "PySide2.QtGui.QAccessible.deleteAccessibleInterface": ('int',),
-    "PySide2.QtGui.QAccessible.isActive": (),
-    "PySide2.QtGui.QAccessible.qAccessibleTextBoundaryHelper": ('PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessible.queryAccessibleInterface": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.registerAccessibleInterface": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.setActive": ('bool',),
-    "PySide2.QtGui.QAccessible.setRootObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessible.uniqueId": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessible.updateAccessibility": ('PySide2.QtGui.QAccessibleEvent',),
-# class PySide2.QtGui.QAccessibleEditableTextInterface:
-    "PySide2.QtGui.QAccessibleEditableTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.deleteText": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.insertText": ('int', 'str'),
-    "PySide2.QtGui.QAccessibleEditableTextInterface.replaceText": ('int', 'int', 'str'),
-# class PySide2.QtGui.QAccessibleEvent:
-    "PySide2.QtGui.QAccessibleEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.Event'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.Event')],
-    "PySide2.QtGui.QAccessibleEvent.accessibleInterface": (),
-    "PySide2.QtGui.QAccessibleEvent.child": (),
-    "PySide2.QtGui.QAccessibleEvent.object": (),
-    "PySide2.QtGui.QAccessibleEvent.setChild": ('int',),
-    "PySide2.QtGui.QAccessibleEvent.type": (),
-    "PySide2.QtGui.QAccessibleEvent.uniqueId": (),
-# class PySide2.QtGui.QAccessibleInterface:
-    "PySide2.QtGui.QAccessibleInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleInterface.backgroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.child": ('int',),
-    "PySide2.QtGui.QAccessibleInterface.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.childCount": (),
-    "PySide2.QtGui.QAccessibleInterface.editableTextInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.focusChild": (),
-    "PySide2.QtGui.QAccessibleInterface.foregroundColor": (),
-    "PySide2.QtGui.QAccessibleInterface.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtGui.QAccessibleInterface.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtGui.QAccessibleInterface.isValid": (),
-    "PySide2.QtGui.QAccessibleInterface.object": (),
-    "PySide2.QtGui.QAccessibleInterface.parent": (),
-    "PySide2.QtGui.QAccessibleInterface.rect": (),
-    "PySide2.QtGui.QAccessibleInterface.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtGui.QAccessibleInterface.role": (),
-    "PySide2.QtGui.QAccessibleInterface.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-    "PySide2.QtGui.QAccessibleInterface.state": (),
-    "PySide2.QtGui.QAccessibleInterface.tableCellInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtGui.QAccessibleInterface.textInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.valueInterface": (),
-    "PySide2.QtGui.QAccessibleInterface.virtual_hook": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleInterface.window": (),
-# class PySide2.QtGui.QAccessibleObject:
-    "PySide2.QtGui.QAccessibleObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QAccessibleObject.childAt": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleObject.isValid": (),
-    "PySide2.QtGui.QAccessibleObject.object": (),
-    "PySide2.QtGui.QAccessibleObject.rect": (),
-    "PySide2.QtGui.QAccessibleObject.setText": ('PySide2.QtGui.QAccessible.Text', 'str'),
-# class PySide2.QtGui.QAccessibleStateChangeEvent:
-    "PySide2.QtGui.QAccessibleStateChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessible.State'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessible.State')],
-    "PySide2.QtGui.QAccessibleStateChangeEvent.changedStates": (),
-# class PySide2.QtGui.QAccessibleTableCellInterface:
-    "PySide2.QtGui.QAccessibleTableCellInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.columnIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.isSelected": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowExtent": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowHeaderCells": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.rowIndex": (),
-    "PySide2.QtGui.QAccessibleTableCellInterface.table": (),
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent:
-# class PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType:
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType'), ('PySide2.QtGui.QAccessibleInterface', 'PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType')],
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.firstRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastColumn": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.lastRow": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.modelChangeType": (),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setFirstRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastColumn": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setLastRow": ('int',),
-    "PySide2.QtGui.QAccessibleTableModelChangeEvent.setModelChangeType": ('PySide2.QtGui.QAccessibleTableModelChangeEvent.ModelChangeType',),
-# class PySide2.QtGui.QAccessibleTextCursorEvent:
-    "PySide2.QtGui.QAccessibleTextCursorEvent.__init__": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int')],
-    "PySide2.QtGui.QAccessibleTextCursorEvent.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextCursorEvent.setCursorPosition": ('int',),
-# class PySide2.QtGui.QAccessibleTextInsertEvent:
-    "PySide2.QtGui.QAccessibleTextInsertEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextInsertEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextInsertEvent.textInserted": (),
-# class PySide2.QtGui.QAccessibleTextInterface:
-    "PySide2.QtGui.QAccessibleTextInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleTextInterface.addSelection": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.attributes": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.characterCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.characterRect": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.cursorPosition": (),
-    "PySide2.QtGui.QAccessibleTextInterface.offsetAtPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QAccessibleTextInterface.removeSelection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.scrollToSubstring": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.selection": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.selectionCount": (),
-    "PySide2.QtGui.QAccessibleTextInterface.setCursorPosition": ('int',),
-    "PySide2.QtGui.QAccessibleTextInterface.setSelection": ('int', 'int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.text": ('int', 'int'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAfterOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textAtOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-    "PySide2.QtGui.QAccessibleTextInterface.textBeforeOffset": ('int', 'PySide2.QtGui.QAccessible.TextBoundaryType'),
-# class PySide2.QtGui.QAccessibleTextRemoveEvent:
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str')],
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextRemoveEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleTextSelectionEvent:
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'int'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'int')],
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionEnd": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.selectionStart": (),
-    "PySide2.QtGui.QAccessibleTextSelectionEvent.setSelection": ('int', 'int'),
-# class PySide2.QtGui.QAccessibleTextUpdateEvent:
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.__init__": [('PySide2.QtCore.QObject', 'int', 'str', 'str'), ('PySide2.QtGui.QAccessibleInterface', 'int', 'str', 'str')],
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.changePosition": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textInserted": (),
-    "PySide2.QtGui.QAccessibleTextUpdateEvent.textRemoved": (),
-# class PySide2.QtGui.QAccessibleValueChangeEvent:
-    "PySide2.QtGui.QAccessibleValueChangeEvent.__init__": [('PySide2.QtCore.QObject', 'typing.Any'), ('PySide2.QtGui.QAccessibleInterface', 'typing.Any')],
-    "PySide2.QtGui.QAccessibleValueChangeEvent.setValue": ('typing.Any',),
-    "PySide2.QtGui.QAccessibleValueChangeEvent.value": (),
-# class PySide2.QtGui.QAccessibleValueInterface:
-    "PySide2.QtGui.QAccessibleValueInterface.__init__": (),
-    "PySide2.QtGui.QAccessibleValueInterface.currentValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.maximumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumStepSize": (),
-    "PySide2.QtGui.QAccessibleValueInterface.minimumValue": (),
-    "PySide2.QtGui.QAccessibleValueInterface.setCurrentValue": ('typing.Any',),
-# class PySide2.QtGui.QActionEvent:
-# class PySide2.QtGui.QBackingStore:
-    "PySide2.QtGui.QBackingStore.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QBackingStore.beginPaint": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.endPaint": (),
-    "PySide2.QtGui.QBackingStore.flush": ('PySide2.QtGui.QRegion', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QBackingStore.hasStaticContents": (),
-    "PySide2.QtGui.QBackingStore.paintDevice": (),
-    "PySide2.QtGui.QBackingStore.resize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QBackingStore.scroll": ('PySide2.QtGui.QRegion', 'int', 'int'),
-    "PySide2.QtGui.QBackingStore.setStaticContents": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QBackingStore.size": (),
-    "PySide2.QtGui.QBackingStore.staticContents": (),
-    "PySide2.QtGui.QBackingStore.window": (),
-# class PySide2.QtGui.QBitmap:
-    "PySide2.QtGui.QBitmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str')],
-    "PySide2.QtGui.QBitmap.__copy__": (),
-    "PySide2.QtGui.QBitmap.clear": (),
-    "PySide2.QtGui.QBitmap.fromData": ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QImage.Format'),
-    "PySide2.QtGui.QBitmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QBitmap.swap": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBitmap.transformed": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform',)],
-# class PySide2.QtGui.QBrush:
-    "PySide2.QtGui.QBrush.__init__": [(), ('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.Qt.GlobalColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QBrush',), ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QPixmap'), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',)],
-    "PySide2.QtGui.QBrush.__copy__": (),
-    "PySide2.QtGui.QBrush.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QBrush.color": (),
-    "PySide2.QtGui.QBrush.gradient": (),
-    "PySide2.QtGui.QBrush.isOpaque": (),
-    "PySide2.QtGui.QBrush.matrix": (),
-    "PySide2.QtGui.QBrush.setColor": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',)],
-    "PySide2.QtGui.QBrush.setMatrix": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QBrush.setStyle": ('PySide2.QtCore.Qt.BrushStyle',),
-    "PySide2.QtGui.QBrush.setTexture": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QBrush.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QBrush.setTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QBrush.style": (),
-    "PySide2.QtGui.QBrush.swap": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QBrush.texture": (),
-    "PySide2.QtGui.QBrush.textureImage": (),
-    "PySide2.QtGui.QBrush.transform": (),
-# class PySide2.QtGui.QClipboard:
-# class PySide2.QtGui.QClipboard.Mode:
-    "PySide2.QtGui.QClipboard.clear": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.image": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.mimeData": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.ownsClipboard": (),
-    "PySide2.QtGui.QClipboard.ownsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.ownsSelection": (),
-    "PySide2.QtGui.QClipboard.pixmap": ('PySide2.QtGui.QClipboard.Mode',),
-    "PySide2.QtGui.QClipboard.setImage": ('PySide2.QtGui.QImage', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.setText": ('str', 'PySide2.QtGui.QClipboard.Mode'),
-    "PySide2.QtGui.QClipboard.supportsFindBuffer": (),
-    "PySide2.QtGui.QClipboard.supportsSelection": (),
-    "PySide2.QtGui.QClipboard.text": [('PySide2.QtGui.QClipboard.Mode',), ('str', 'PySide2.QtGui.QClipboard.Mode')],
-# class PySide2.QtGui.QCloseEvent:
-    "PySide2.QtGui.QCloseEvent.__init__": (),
-# class PySide2.QtGui.QColor:
-# class PySide2.QtGui.QColor.NameFormat:
-# class PySide2.QtGui.QColor.Spec:
-    "PySide2.QtGui.QColor.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor.Spec', 'int', 'int', 'int', 'int', 'int'), ('int',), ('int', 'int', 'int', 'int'), ('str',), ('typing.Any',)],
-    "PySide2.QtGui.QColor.__copy__": (),
-    "PySide2.QtGui.QColor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__reduce__": (),
-    "PySide2.QtGui.QColor.__repr__": (),
-    "PySide2.QtGui.QColor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColor.__setstate__": ('object',),
-    "PySide2.QtGui.QColor.__str__": (),
-    "PySide2.QtGui.QColor.alpha": (),
-    "PySide2.QtGui.QColor.alphaF": (),
-    "PySide2.QtGui.QColor.black": (),
-    "PySide2.QtGui.QColor.blackF": (),
-    "PySide2.QtGui.QColor.blue": (),
-    "PySide2.QtGui.QColor.blueF": (),
-    "PySide2.QtGui.QColor.colorNames": (),
-    "PySide2.QtGui.QColor.convertTo": ('PySide2.QtGui.QColor.Spec',),
-    "PySide2.QtGui.QColor.cyan": (),
-    "PySide2.QtGui.QColor.cyanF": (),
-    "PySide2.QtGui.QColor.dark": ('int',),
-    "PySide2.QtGui.QColor.darker": ('int',),
-    "PySide2.QtGui.QColor.fromCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.fromHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.fromRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.fromRgba": ('int',),
-    "PySide2.QtGui.QColor.fromRgba64": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.getCmyk": (),
-    "PySide2.QtGui.QColor.getCmykF": (),
-    "PySide2.QtGui.QColor.getHsl": (),
-    "PySide2.QtGui.QColor.getHslF": (),
-    "PySide2.QtGui.QColor.getHsv": (),
-    "PySide2.QtGui.QColor.getHsvF": (),
-    "PySide2.QtGui.QColor.getRgb": (),
-    "PySide2.QtGui.QColor.getRgbF": (),
-    "PySide2.QtGui.QColor.green": (),
-    "PySide2.QtGui.QColor.greenF": (),
-    "PySide2.QtGui.QColor.hslHue": (),
-    "PySide2.QtGui.QColor.hslHueF": (),
-    "PySide2.QtGui.QColor.hslSaturation": (),
-    "PySide2.QtGui.QColor.hslSaturationF": (),
-    "PySide2.QtGui.QColor.hsvHue": (),
-    "PySide2.QtGui.QColor.hsvHueF": (),
-    "PySide2.QtGui.QColor.hsvSaturation": (),
-    "PySide2.QtGui.QColor.hsvSaturationF": (),
-    "PySide2.QtGui.QColor.hue": (),
-    "PySide2.QtGui.QColor.hueF": (),
-    "PySide2.QtGui.QColor.isValid": (),
-    "PySide2.QtGui.QColor.isValidColor": ('str',),
-    "PySide2.QtGui.QColor.light": ('int',),
-    "PySide2.QtGui.QColor.lighter": ('int',),
-    "PySide2.QtGui.QColor.lightness": (),
-    "PySide2.QtGui.QColor.lightnessF": (),
-    "PySide2.QtGui.QColor.magenta": (),
-    "PySide2.QtGui.QColor.magentaF": (),
-    "PySide2.QtGui.QColor.name": [(), ('PySide2.QtGui.QColor.NameFormat',)],
-    "PySide2.QtGui.QColor.red": (),
-    "PySide2.QtGui.QColor.redF": (),
-    "PySide2.QtGui.QColor.rgb": (),
-    "PySide2.QtGui.QColor.rgba": (),
-    "PySide2.QtGui.QColor.saturation": (),
-    "PySide2.QtGui.QColor.saturationF": (),
-    "PySide2.QtGui.QColor.setAlpha": ('int',),
-    "PySide2.QtGui.QColor.setAlphaF": ('float',),
-    "PySide2.QtGui.QColor.setBlue": ('int',),
-    "PySide2.QtGui.QColor.setBlueF": ('float',),
-    "PySide2.QtGui.QColor.setCmyk": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setCmykF": ('float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setGreen": ('int',),
-    "PySide2.QtGui.QColor.setGreenF": ('float',),
-    "PySide2.QtGui.QColor.setHsl": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHslF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setHsv": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QColor.setHsvF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setNamedColor": ('str',),
-    "PySide2.QtGui.QColor.setRed": ('int',),
-    "PySide2.QtGui.QColor.setRedF": ('float',),
-    "PySide2.QtGui.QColor.setRgb": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QColor.setRgbF": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QColor.setRgba": ('int',),
-    "PySide2.QtGui.QColor.spec": (),
-    "PySide2.QtGui.QColor.toCmyk": (),
-    "PySide2.QtGui.QColor.toExtendedRgb": (),
-    "PySide2.QtGui.QColor.toHsl": (),
-    "PySide2.QtGui.QColor.toHsv": (),
-    "PySide2.QtGui.QColor.toRgb": (),
-    "PySide2.QtGui.QColor.toTuple": (),
-    "PySide2.QtGui.QColor.value": (),
-    "PySide2.QtGui.QColor.valueF": (),
-    "PySide2.QtGui.QColor.yellow": (),
-    "PySide2.QtGui.QColor.yellowF": (),
-# class PySide2.QtGui.QColorSpace:
-# class PySide2.QtGui.QColorSpace.NamedColorSpace:
-# class PySide2.QtGui.QColorSpace.Primaries:
-# class PySide2.QtGui.QColorSpace.TransferFunction:
-    "PySide2.QtGui.QColorSpace.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace',), ('PySide2.QtGui.QColorSpace.NamedColorSpace',), ('PySide2.QtGui.QColorSpace.Primaries', 'PySide2.QtGui.QColorSpace.TransferFunction', 'float'), ('PySide2.QtGui.QColorSpace.Primaries', 'float')],
-    "PySide2.QtGui.QColorSpace.__copy__": (),
-    "PySide2.QtGui.QColorSpace.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QColorSpace.fromIccProfile": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QColorSpace.gamma": (),
-    "PySide2.QtGui.QColorSpace.iccProfile": (),
-    "PySide2.QtGui.QColorSpace.isValid": (),
-    "PySide2.QtGui.QColorSpace.primaries": (),
-    "PySide2.QtGui.QColorSpace.setPrimaries": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QColorSpace.Primaries',)],
-    "PySide2.QtGui.QColorSpace.setTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-    "PySide2.QtGui.QColorSpace.swap": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QColorSpace.transferFunction": (),
-    "PySide2.QtGui.QColorSpace.withTransferFunction": ('PySide2.QtGui.QColorSpace.TransferFunction', 'float'),
-# class PySide2.QtGui.QConicalGradient:
-    "PySide2.QtGui.QConicalGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QConicalGradient',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QConicalGradient.__copy__": (),
-    "PySide2.QtGui.QConicalGradient.angle": (),
-    "PySide2.QtGui.QConicalGradient.center": (),
-    "PySide2.QtGui.QConicalGradient.setAngle": ('float',),
-    "PySide2.QtGui.QConicalGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-# class PySide2.QtGui.QContextMenuEvent:
-# class PySide2.QtGui.QContextMenuEvent.Reason:
-    "PySide2.QtGui.QContextMenuEvent.__init__": [('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QContextMenuEvent.Reason', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QContextMenuEvent.globalPos": (),
-    "PySide2.QtGui.QContextMenuEvent.globalX": (),
-    "PySide2.QtGui.QContextMenuEvent.global""Y": (),
-    "PySide2.QtGui.QContextMenuEvent.pos": (),
-    "PySide2.QtGui.QContextMenuEvent.reason": (),
-    "PySide2.QtGui.QContextMenuEvent.x": (),
-    "PySide2.QtGui.QContextMenuEvent.y": (),
-# class PySide2.QtGui.QCursor:
-    "PySide2.QtGui.QCursor.__init__": [(), ('PySide2.QtCore.Qt.CursorShape',), ('PySide2.QtGui.QBitmap', 'PySide2.QtGui.QBitmap', 'int', 'int'), ('PySide2.QtGui.QCursor',), ('PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QCursor.__copy__": (),
-    "PySide2.QtGui.QCursor.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QCursor.bitmap": (),
-    "PySide2.QtGui.QCursor.hotSpot": (),
-    "PySide2.QtGui.QCursor.mask": (),
-    "PySide2.QtGui.QCursor.pixmap": (),
-    "PySide2.QtGui.QCursor.pos": [(), ('PySide2.QtGui.QScreen',)],
-    "PySide2.QtGui.QCursor.setPos": [('PySide2.QtCore.QPoint',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QScreen', 'int', 'int'), ('int', 'int')],
-    "PySide2.QtGui.QCursor.setShape": ('PySide2.QtCore.Qt.CursorShape',),
-    "PySide2.QtGui.QCursor.shape": (),
-    "PySide2.QtGui.QCursor.swap": ('PySide2.QtGui.QCursor',),
-# class PySide2.QtGui.QDesktopServices:
-    "PySide2.QtGui.QDesktopServices.__init__": (),
-    "PySide2.QtGui.QDesktopServices.openUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QDesktopServices.setUrlHandler": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtGui.QDesktopServices.unsetUrlHandler": ('str',),
-# class PySide2.QtGui.QDoubleValidator:
-# class PySide2.QtGui.QDoubleValidator.Notation:
-    "PySide2.QtGui.QDoubleValidator.__init__": [('PySide2.QtCore.QObject',), ('float', 'float', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QDoubleValidator.bottom": (),
-    "PySide2.QtGui.QDoubleValidator.decimals": (),
-    "PySide2.QtGui.QDoubleValidator.notation": (),
-    "PySide2.QtGui.QDoubleValidator.setBottom": ('float',),
-    "PySide2.QtGui.QDoubleValidator.setDecimals": ('int',),
-    "PySide2.QtGui.QDoubleValidator.setNotation": ('PySide2.QtGui.QDoubleValidator.Notation',),
-    "PySide2.QtGui.QDoubleValidator.setRange": ('float', 'float', 'int'),
-    "PySide2.QtGui.QDoubleValidator.setTop": ('float',),
-    "PySide2.QtGui.QDoubleValidator.top": (),
-    "PySide2.QtGui.QDoubleValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QDrag:
-    "PySide2.QtGui.QDrag.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QDrag.cancel": (),
-    "PySide2.QtGui.QDrag.defaultAction": (),
-    "PySide2.QtGui.QDrag.dragCursor": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDrag.exec_": [('PySide2.QtCore.Qt.DropActions',), ('PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.Qt.DropAction')],
-    "PySide2.QtGui.QDrag.hotSpot": (),
-    "PySide2.QtGui.QDrag.mimeData": (),
-    "PySide2.QtGui.QDrag.pixmap": (),
-    "PySide2.QtGui.QDrag.setDragCursor": ('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtGui.QDrag.setHotSpot": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QDrag.setMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtGui.QDrag.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QDrag.source": (),
-    "PySide2.QtGui.QDrag.start": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtGui.QDrag.supportedActions": (),
-    "PySide2.QtGui.QDrag.target": (),
-# class PySide2.QtGui.QDragEnterEvent:
-    "PySide2.QtGui.QDragEnterEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-# class PySide2.QtGui.QDragLeaveEvent:
-    "PySide2.QtGui.QDragLeaveEvent.__init__": (),
-# class PySide2.QtGui.QDragMoveEvent:
-    "PySide2.QtGui.QDragMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDragMoveEvent.accept": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QDragMoveEvent.answerRect": (),
-    "PySide2.QtGui.QDragMoveEvent.ignore": [(), ('PySide2.QtCore.QRect',)],
-# class PySide2.QtGui.QDropEvent:
-    "PySide2.QtGui.QDropEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.DropActions', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QEvent.Type'),
-    "PySide2.QtGui.QDropEvent.acceptProposedAction": (),
-    "PySide2.QtGui.QDropEvent.dropAction": (),
-    "PySide2.QtGui.QDropEvent.keyboardModifiers": (),
-    "PySide2.QtGui.QDropEvent.mimeData": (),
-    "PySide2.QtGui.QDropEvent.mouseButtons": (),
-    "PySide2.QtGui.QDropEvent.pos": (),
-    "PySide2.QtGui.QDropEvent.posF": (),
-    "PySide2.QtGui.QDropEvent.possibleActions": (),
-    "PySide2.QtGui.QDropEvent.proposedAction": (),
-    "PySide2.QtGui.QDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtGui.QDropEvent.source": (),
-# class PySide2.QtGui.QEnterEvent:
-    "PySide2.QtGui.QEnterEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QEnterEvent.globalPos": (),
-    "PySide2.QtGui.QEnterEvent.globalX": (),
-    "PySide2.QtGui.QEnterEvent.global""Y": (),
-    "PySide2.QtGui.QEnterEvent.localPos": (),
-    "PySide2.QtGui.QEnterEvent.pos": (),
-    "PySide2.QtGui.QEnterEvent.screenPos": (),
-    "PySide2.QtGui.QEnterEvent.windowPos": (),
-    "PySide2.QtGui.QEnterEvent.x": (),
-    "PySide2.QtGui.QEnterEvent.y": (),
-# class PySide2.QtGui.QExposeEvent:
-    "PySide2.QtGui.QExposeEvent.__init__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QExposeEvent.region": (),
-# class PySide2.QtGui.QFileOpenEvent:
-    "PySide2.QtGui.QFileOpenEvent.__init__": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtGui.QFileOpenEvent.file": (),
-    "PySide2.QtGui.QFileOpenEvent.openFile": ('PySide2.QtCore.QFile', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtGui.QFileOpenEvent.url": (),
-# class PySide2.QtGui.QFocusEvent:
-    "PySide2.QtGui.QFocusEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtGui.QFocusEvent.gotFocus": (),
-    "PySide2.QtGui.QFocusEvent.lostFocus": (),
-    "PySide2.QtGui.QFocusEvent.reason": (),
-# class PySide2.QtGui.QFont:
-# class PySide2.QtGui.QFont.Capitalization:
-# class PySide2.QtGui.QFont.HintingPreference:
-# class PySide2.QtGui.QFont.SpacingType:
-# class PySide2.QtGui.QFont.Stretch:
-# class PySide2.QtGui.QFont.Style:
-# class PySide2.QtGui.QFont.StyleHint:
-# class PySide2.QtGui.QFont.StyleStrategy:
-# class PySide2.QtGui.QFont.Weight:
-    "PySide2.QtGui.QFont.__init__": [(), ('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('str', 'int', 'int', 'bool')],
-    "PySide2.QtGui.QFont.__copy__": (),
-    "PySide2.QtGui.QFont.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QFont.bold": (),
-    "PySide2.QtGui.QFont.cacheStatistics": (),
-    "PySide2.QtGui.QFont.capitalization": (),
-    "PySide2.QtGui.QFont.cleanup": (),
-    "PySide2.QtGui.QFont.defaultFamily": (),
-    "PySide2.QtGui.QFont.exactMatch": (),
-    "PySide2.QtGui.QFont.families": (),
-    "PySide2.QtGui.QFont.family": (),
-    "PySide2.QtGui.QFont.fixedPitch": (),
-    "PySide2.QtGui.QFont.fromString": ('str',),
-    "PySide2.QtGui.QFont.hintingPreference": (),
-    "PySide2.QtGui.QFont.initialize": (),
-    "PySide2.QtGui.QFont.insertSubstitution": ('str', 'str'),
-    "PySide2.QtGui.QFont.insertSubstitutions": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtGui.QFont.isCopyOf": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.italic": (),
-    "PySide2.QtGui.QFont.kerning": (),
-    "PySide2.QtGui.QFont.key": (),
-    "PySide2.QtGui.QFont.lastResortFamily": (),
-    "PySide2.QtGui.QFont.lastResortFont": (),
-    "PySide2.QtGui.QFont.letterSpacing": (),
-    "PySide2.QtGui.QFont.letterSpacingType": (),
-    "PySide2.QtGui.QFont.overline": (),
-    "PySide2.QtGui.QFont.pixelSize": (),
-    "PySide2.QtGui.QFont.pointSize": (),
-    "PySide2.QtGui.QFont.pointSizeF": (),
-    "PySide2.QtGui.QFont.rawMode": (),
-    "PySide2.QtGui.QFont.rawName": (),
-    "PySide2.QtGui.QFont.removeSubstitutions": ('str',),
-    "PySide2.QtGui.QFont.resolve": [(), ('PySide2.QtGui.QFont',), ('int',)],
-    "PySide2.QtGui.QFont.setBold": ('bool',),
-    "PySide2.QtGui.QFont.setCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QFont.setFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QFont.setFamily": ('str',),
-    "PySide2.QtGui.QFont.setFixedPitch": ('bool',),
-    "PySide2.QtGui.QFont.setHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QFont.setItalic": ('bool',),
-    "PySide2.QtGui.QFont.setKerning": ('bool',),
-    "PySide2.QtGui.QFont.setLetterSpacing": ('PySide2.QtGui.QFont.SpacingType', 'float'),
-    "PySide2.QtGui.QFont.setOverline": ('bool',),
-    "PySide2.QtGui.QFont.setPixelSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSize": ('int',),
-    "PySide2.QtGui.QFont.setPointSizeF": ('float',),
-    "PySide2.QtGui.QFont.setRawMode": ('bool',),
-    "PySide2.QtGui.QFont.setRawName": ('str',),
-    "PySide2.QtGui.QFont.setStretch": ('int',),
-    "PySide2.QtGui.QFont.setStrikeOut": ('bool',),
-    "PySide2.QtGui.QFont.setStyle": ('PySide2.QtGui.QFont.Style',),
-    "PySide2.QtGui.QFont.setStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QFont.setStyleName": ('str',),
-    "PySide2.QtGui.QFont.setStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QFont.setUnderline": ('bool',),
-    "PySide2.QtGui.QFont.setWeight": ('int',),
-    "PySide2.QtGui.QFont.setWordSpacing": ('float',),
-    "PySide2.QtGui.QFont.stretch": (),
-    "PySide2.QtGui.QFont.strikeOut": (),
-    "PySide2.QtGui.QFont.style": (),
-    "PySide2.QtGui.QFont.styleHint": (),
-    "PySide2.QtGui.QFont.styleName": (),
-    "PySide2.QtGui.QFont.styleStrategy": (),
-    "PySide2.QtGui.QFont.substitute": ('str',),
-    "PySide2.QtGui.QFont.substitutes": ('str',),
-    "PySide2.QtGui.QFont.substitutions": (),
-    "PySide2.QtGui.QFont.swap": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QFont.toString": (),
-    "PySide2.QtGui.QFont.underline": (),
-    "PySide2.QtGui.QFont.weight": (),
-    "PySide2.QtGui.QFont.wordSpacing": (),
-# class PySide2.QtGui.QFontDatabase:
-# class PySide2.QtGui.QFontDatabase.SystemFont:
-# class PySide2.QtGui.QFontDatabase.WritingSystem:
-    "PySide2.QtGui.QFontDatabase.__init__": [(), ('PySide2.QtGui.QFontDatabase',)],
-    "PySide2.QtGui.QFontDatabase.__copy__": (),
-    "PySide2.QtGui.QFontDatabase.addApplicationFont": ('str',),
-    "PySide2.QtGui.QFontDatabase.addApplicationFontFromData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QFontDatabase.applicationFontFamilies": ('int',),
-    "PySide2.QtGui.QFontDatabase.bold": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.families": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.font": ('str', 'str', 'int'),
-    "PySide2.QtGui.QFontDatabase.hasFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isBitmapScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isFixedPitch": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isPrivateFamily": ('str',),
-    "PySide2.QtGui.QFontDatabase.isScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.isSmoothlyScalable": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.italic": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.pointSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.removeAllApplicationFonts": (),
-    "PySide2.QtGui.QFontDatabase.removeApplicationFont": ('int',),
-    "PySide2.QtGui.QFontDatabase.smoothSizes": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.standardSizes": (),
-    "PySide2.QtGui.QFontDatabase.styleString": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontDatabase.styles": ('str',),
-    "PySide2.QtGui.QFontDatabase.supportsThreadedFontRendering": (),
-    "PySide2.QtGui.QFontDatabase.systemFont": ('PySide2.QtGui.QFontDatabase.SystemFont',),
-    "PySide2.QtGui.QFontDatabase.weight": ('str', 'str'),
-    "PySide2.QtGui.QFontDatabase.writingSystemName": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystemSample": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtGui.QFontDatabase.writingSystems": [(), ('str',)],
-# class PySide2.QtGui.QFontInfo:
-    "PySide2.QtGui.QFontInfo.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFontInfo',)],
-    "PySide2.QtGui.QFontInfo.__copy__": (),
-    "PySide2.QtGui.QFontInfo.bold": (),
-    "PySide2.QtGui.QFontInfo.exactMatch": (),
-    "PySide2.QtGui.QFontInfo.family": (),
-    "PySide2.QtGui.QFontInfo.fixedPitch": (),
-    "PySide2.QtGui.QFontInfo.italic": (),
-    "PySide2.QtGui.QFontInfo.overline": (),
-    "PySide2.QtGui.QFontInfo.pixelSize": (),
-    "PySide2.QtGui.QFontInfo.pointSize": (),
-    "PySide2.QtGui.QFontInfo.pointSizeF": (),
-    "PySide2.QtGui.QFontInfo.rawMode": (),
-    "PySide2.QtGui.QFontInfo.strikeOut": (),
-    "PySide2.QtGui.QFontInfo.style": (),
-    "PySide2.QtGui.QFontInfo.styleHint": (),
-    "PySide2.QtGui.QFontInfo.styleName": (),
-    "PySide2.QtGui.QFontInfo.swap": ('PySide2.QtGui.QFontInfo',),
-    "PySide2.QtGui.QFontInfo.underline": (),
-    "PySide2.QtGui.QFontInfo.weight": (),
-# class PySide2.QtGui.QFontMetrics:
-    "PySide2.QtGui.QFontMetrics.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',)],
-    "PySide2.QtGui.QFontMetrics.__copy__": (),
-    "PySide2.QtGui.QFontMetrics.ascent": (),
-    "PySide2.QtGui.QFontMetrics.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetrics.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('int', 'int', 'int', 'int', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetrics.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.capHeight": (),
-    "PySide2.QtGui.QFontMetrics.charWidth": ('str', 'int'),
-    "PySide2.QtGui.QFontMetrics.descent": (),
-    "PySide2.QtGui.QFontMetrics.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'int', 'int'),
-    "PySide2.QtGui.QFontMetrics.fontDpi": (),
-    "PySide2.QtGui.QFontMetrics.height": (),
-    "PySide2.QtGui.QFontMetrics.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetrics.inFont": ('str',),
-    "PySide2.QtGui.QFontMetrics.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetrics.leading": (),
-    "PySide2.QtGui.QFontMetrics.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.lineSpacing": (),
-    "PySide2.QtGui.QFontMetrics.lineWidth": (),
-    "PySide2.QtGui.QFontMetrics.maxWidth": (),
-    "PySide2.QtGui.QFontMetrics.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetrics.minRightBearing": (),
-    "PySide2.QtGui.QFontMetrics.overlinePos": (),
-    "PySide2.QtGui.QFontMetrics.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetrics.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetrics.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetrics.swap": ('PySide2.QtGui.QFontMetrics',),
-    "PySide2.QtGui.QFontMetrics.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetrics.underlinePos": (),
-    "PySide2.QtGui.QFontMetrics.width": [('str', 'int'), ('str', 'int', 'int')],
-    "PySide2.QtGui.QFontMetrics.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetrics.xHeight": (),
-# class PySide2.QtGui.QFontMetricsF:
-    "PySide2.QtGui.QFontMetricsF.__init__": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice'), ('PySide2.QtGui.QFontMetrics',), ('PySide2.QtGui.QFontMetricsF',)],
-    "PySide2.QtGui.QFontMetricsF.__copy__": (),
-    "PySide2.QtGui.QFontMetricsF.ascent": (),
-    "PySide2.QtGui.QFontMetricsF.averageCharWidth": (),
-    "PySide2.QtGui.QFontMetricsF.boundingRect": [('PySide2.QtCore.QRectF', 'int', 'str', 'int', 'shibokensupport.typing27.Sequence'), ('str',)],
-    "PySide2.QtGui.QFontMetricsF.boundingRectChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.capHeight": (),
-    "PySide2.QtGui.QFontMetricsF.descent": (),
-    "PySide2.QtGui.QFontMetricsF.elidedText": ('str', 'PySide2.QtCore.Qt.TextElideMode', 'float', 'int'),
-    "PySide2.QtGui.QFontMetricsF.fontDpi": (),
-    "PySide2.QtGui.QFontMetricsF.height": (),
-    "PySide2.QtGui.QFontMetricsF.horizontalAdvance": [('str',), ('str', 'int')],
-    "PySide2.QtGui.QFontMetricsF.inFont": ('str',),
-    "PySide2.QtGui.QFontMetricsF.inFontUcs4": ('int',),
-    "PySide2.QtGui.QFontMetricsF.leading": (),
-    "PySide2.QtGui.QFontMetricsF.leftBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.lineSpacing": (),
-    "PySide2.QtGui.QFontMetricsF.lineWidth": (),
-    "PySide2.QtGui.QFontMetricsF.maxWidth": (),
-    "PySide2.QtGui.QFontMetricsF.minLeftBearing": (),
-    "PySide2.QtGui.QFontMetricsF.minRightBearing": (),
-    "PySide2.QtGui.QFontMetricsF.overlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.rightBearing": ('str',),
-    "PySide2.QtGui.QFontMetricsF.size": ('int', 'str', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QFontMetricsF.strikeOutPos": (),
-    "PySide2.QtGui.QFontMetricsF.swap": ('PySide2.QtGui.QFontMetricsF',),
-    "PySide2.QtGui.QFontMetricsF.tightBoundingRect": ('str',),
-    "PySide2.QtGui.QFontMetricsF.underlinePos": (),
-    "PySide2.QtGui.QFontMetricsF.width": ('str',),
-    "PySide2.QtGui.QFontMetricsF.widthChar": ('str',),
-    "PySide2.QtGui.QFontMetricsF.xHeight": (),
-# class PySide2.QtGui.QGradient:
-# class PySide2.QtGui.QGradient.CoordinateMode:
-# class PySide2.QtGui.QGradient.InterpolationMode:
-# class PySide2.QtGui.QGradient.Preset:
-# class PySide2.QtGui.QGradient.Spread:
-# class PySide2.QtGui.QGradient.Type:
-    "PySide2.QtGui.QGradient.__init__": [(), ('PySide2.QtGui.QGradient',), ('PySide2.QtGui.QGradient.Preset',)],
-    "PySide2.QtGui.QGradient.__copy__": (),
-    "PySide2.QtGui.QGradient.coordinateMode": (),
-    "PySide2.QtGui.QGradient.interpolationMode": (),
-    "PySide2.QtGui.QGradient.setColorAt": ('float', 'PySide2.QtGui.QColor'),
-    "PySide2.QtGui.QGradient.setCoordinateMode": ('PySide2.QtGui.QGradient.CoordinateMode',),
-    "PySide2.QtGui.QGradient.setInterpolationMode": ('PySide2.QtGui.QGradient.InterpolationMode',),
-    "PySide2.QtGui.QGradient.setSpread": ('PySide2.QtGui.QGradient.Spread',),
-    "PySide2.QtGui.QGradient.setStops": ('typing.List[typing.Tuple]',),
-    "PySide2.QtGui.QGradient.spread": (),
-    "PySide2.QtGui.QGradient.stops": (),
-    "PySide2.QtGui.QGradient.type": (),
-# class PySide2.QtGui.QGuiApplication:
-    "PySide2.QtGui.QGuiApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QGuiApplication.allWindows": (),
-    "PySide2.QtGui.QGuiApplication.applicationDisplayName": (),
-    "PySide2.QtGui.QGuiApplication.applicationState": (),
-    "PySide2.QtGui.QGuiApplication.changeOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.clipboard": (),
-    "PySide2.QtGui.QGuiApplication.desktopFileName": (),
-    "PySide2.QtGui.QGuiApplication.desktopSettingsAware": (),
-    "PySide2.QtGui.QGuiApplication.devicePixelRatio": (),
-    "PySide2.QtGui.QGuiApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QGuiApplication.exec_": (),
-    "PySide2.QtGui.QGuiApplication.focusObject": (),
-    "PySide2.QtGui.QGuiApplication.focusWindow": (),
-    "PySide2.QtGui.QGuiApplication.font": (),
-    "PySide2.QtGui.QGuiApplication.highDpiScaleFactorRoundingPolicy": (),
-    "PySide2.QtGui.QGuiApplication.inputMethod": (),
-    "PySide2.QtGui.QGuiApplication.isFallbackSessionManagementEnabled": (),
-    "PySide2.QtGui.QGuiApplication.isLeftToRight": (),
-    "PySide2.QtGui.QGuiApplication.isRightToLeft": (),
-    "PySide2.QtGui.QGuiApplication.isSavingSession": (),
-    "PySide2.QtGui.QGuiApplication.isSessionRestored": (),
-    "PySide2.QtGui.QGuiApplication.keyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.layoutDirection": (),
-    "PySide2.QtGui.QGuiApplication.modalWindow": (),
-    "PySide2.QtGui.QGuiApplication.mouseButtons": (),
-    "PySide2.QtGui.QGuiApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtGui.QGuiApplication.overrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.palette": (),
-    "PySide2.QtGui.QGuiApplication.platformName": (),
-    "PySide2.QtGui.QGuiApplication.primaryScreen": (),
-    "PySide2.QtGui.QGuiApplication.queryKeyboardModifiers": (),
-    "PySide2.QtGui.QGuiApplication.quitOnLastWindowClosed": (),
-    "PySide2.QtGui.QGuiApplication.restoreOverrideCursor": (),
-    "PySide2.QtGui.QGuiApplication.screenAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.screens": (),
-    "PySide2.QtGui.QGuiApplication.sessionId": (),
-    "PySide2.QtGui.QGuiApplication.sessionKey": (),
-    "PySide2.QtGui.QGuiApplication.setApplicationDisplayName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopFileName": ('str',),
-    "PySide2.QtGui.QGuiApplication.setDesktopSettingsAware": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFallbackSessionManagementEnabled": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QGuiApplication.setHighDpiScaleFactorRoundingPolicy": ('PySide2.QtCore.Qt.HighDpiScaleFactorRoundingPolicy',),
-    "PySide2.QtGui.QGuiApplication.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QGuiApplication.setOverrideCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QGuiApplication.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QGuiApplication.setQuitOnLastWindowClosed": ('bool',),
-    "PySide2.QtGui.QGuiApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QGuiApplication.styleHints": (),
-    "PySide2.QtGui.QGuiApplication.sync": (),
-    "PySide2.QtGui.QGuiApplication.topLevelAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QGuiApplication.topLevelWindows": (),
-    "PySide2.QtGui.QGuiApplication.windowIcon": (),
-# class PySide2.QtGui.QHelpEvent:
-    "PySide2.QtGui.QHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QHelpEvent.globalPos": (),
-    "PySide2.QtGui.QHelpEvent.globalX": (),
-    "PySide2.QtGui.QHelpEvent.global""Y": (),
-    "PySide2.QtGui.QHelpEvent.pos": (),
-    "PySide2.QtGui.QHelpEvent.x": (),
-    "PySide2.QtGui.QHelpEvent.y": (),
-# class PySide2.QtGui.QHideEvent:
-    "PySide2.QtGui.QHideEvent.__init__": (),
-# class PySide2.QtGui.QHoverEvent:
-    "PySide2.QtGui.QHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QHoverEvent.oldPos": (),
-    "PySide2.QtGui.QHoverEvent.oldPosF": (),
-    "PySide2.QtGui.QHoverEvent.pos": (),
-    "PySide2.QtGui.QHoverEvent.posF": (),
-# class PySide2.QtGui.QIcon:
-# class PySide2.QtGui.QIcon.Mode:
-# class PySide2.QtGui.QIcon.State:
-    "PySide2.QtGui.QIcon.__init__": [(), ('PySide2.QtGui.QIcon',), ('PySide2.QtGui.QIconEngine',), ('PySide2.QtGui.QPixmap',), ('str',)],
-    "PySide2.QtGui.QIcon.__copy__": (),
-    "PySide2.QtGui.QIcon.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIcon.actualSize": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIcon.cacheKey": (),
-    "PySide2.QtGui.QIcon.fallbackSearchPaths": (),
-    "PySide2.QtGui.QIcon.fallbackThemeName": (),
-    "PySide2.QtGui.QIcon.fromTheme": [('str',), ('str', 'PySide2.QtGui.QIcon')],
-    "PySide2.QtGui.QIcon.hasThemeIcon": ('str',),
-    "PySide2.QtGui.QIcon.isMask": (),
-    "PySide2.QtGui.QIcon.isNull": (),
-    "PySide2.QtGui.QIcon.name": (),
-    "PySide2.QtGui.QIcon.paint": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QPainter', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.pixmap": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('PySide2.QtGui.QWindow', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'), ('int', 'int', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State')],
-    "PySide2.QtGui.QIcon.setFallbackSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.setFallbackThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setIsMask": ('bool',),
-    "PySide2.QtGui.QIcon.setThemeName": ('str',),
-    "PySide2.QtGui.QIcon.setThemeSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QIcon.swap": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QIcon.themeName": (),
-    "PySide2.QtGui.QIcon.themeSearchPaths": (),
-# class PySide2.QtGui.QIconDragEvent:
-    "PySide2.QtGui.QIconDragEvent.__init__": (),
-# class PySide2.QtGui.QIconEngine:
-# class PySide2.QtGui.QIconEngine.AvailableSizesArgument:
-    "PySide2.QtGui.QIconEngine.AvailableSizesArgument.__init__": (),
-# class PySide2.QtGui.QIconEngine.IconEngineHook:
-    "PySide2.QtGui.QIconEngine.__init__": [(), ('PySide2.QtGui.QIconEngine',)],
-    "PySide2.QtGui.QIconEngine.actualSize": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addFile": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.addPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.availableSizes": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.clone": (),
-    "PySide2.QtGui.QIconEngine.iconName": (),
-    "PySide2.QtGui.QIconEngine.isNull": (),
-    "PySide2.QtGui.QIconEngine.key": (),
-    "PySide2.QtGui.QIconEngine.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.pixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State'),
-    "PySide2.QtGui.QIconEngine.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QIconEngine.scaledPixmap": ('PySide2.QtCore.QSize', 'PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QIcon.State', 'float'),
-    "PySide2.QtGui.QIconEngine.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QImage:
-# class PySide2.QtGui.QImage.Format:
-# class PySide2.QtGui.QImage.InvertMode:
-    "PySide2.QtGui.QImage.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QImage.Format'), ('PySide2.QtGui.QImage',), ('int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format'), ('str', 'int', 'int', 'int', 'PySide2.QtGui.QImage.Format', 'typing.Callable', 'int'), ('str', 'str'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QImage.__copy__": (),
-    "PySide2.QtGui.QImage.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QImage.allGray": (),
-    "PySide2.QtGui.QImage.alphaChannel": (),
-    "PySide2.QtGui.QImage.bitPlaneCount": (),
-    "PySide2.QtGui.QImage.bits": (),
-    "PySide2.QtGui.QImage.byteCount": (),
-    "PySide2.QtGui.QImage.bytesPerLine": (),
-    "PySide2.QtGui.QImage.cacheKey": (),
-    "PySide2.QtGui.QImage.color": ('int',),
-    "PySide2.QtGui.QImage.colorCount": (),
-    "PySide2.QtGui.QImage.colorSpace": (),
-    "PySide2.QtGui.QImage.colorTable": (),
-    "PySide2.QtGui.QImage.constBits": (),
-    "PySide2.QtGui.QImage.constScanLine": ('int',),
-    "PySide2.QtGui.QImage.convertTo": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.convertToFormat": [('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QImage.convertToFormat_helper": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertToFormat_inplace": ('PySide2.QtGui.QImage.Format', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QImage.convertedToColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QImage.createAlphaMask": ('PySide2.QtCore.Qt.ImageConversionFlags',),
-    "PySide2.QtGui.QImage.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QImage.createMaskFromColor": ('int', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QImage.depth": (),
-    "PySide2.QtGui.QImage.devType": (),
-    "PySide2.QtGui.QImage.devicePixelRatio": (),
-    "PySide2.QtGui.QImage.dotsPerMeterX": (),
-    "PySide2.QtGui.QImage.dotsPerMeterY": (),
-    "PySide2.QtGui.QImage.fill": [('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QColor',), ('int',)],
-    "PySide2.QtGui.QImage.format": (),
-    "PySide2.QtGui.QImage.fromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.hasAlphaChannel": (),
-    "PySide2.QtGui.QImage.height": (),
-    "PySide2.QtGui.QImage.invertPixels": ('PySide2.QtGui.QImage.InvertMode',),
-    "PySide2.QtGui.QImage.isGrayscale": (),
-    "PySide2.QtGui.QImage.isNull": (),
-    "PySide2.QtGui.QImage.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QImage.loadFromData": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtGui.QImage.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QImage.mirrored": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_helper": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.mirrored_inplace": ('bool', 'bool'),
-    "PySide2.QtGui.QImage.offset": (),
-    "PySide2.QtGui.QImage.paintEngine": (),
-    "PySide2.QtGui.QImage.pixel": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelColor": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.pixelFormat": (),
-    "PySide2.QtGui.QImage.pixelIndex": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.rect": (),
-    "PySide2.QtGui.QImage.reinterpretAsFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.rgbSwapped": (),
-    "PySide2.QtGui.QImage.rgbSwapped_helper": (),
-    "PySide2.QtGui.QImage.rgbSwapped_inplace": (),
-    "PySide2.QtGui.QImage.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QImage.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QImage.scanLine": ('int',),
-    "PySide2.QtGui.QImage.setAlphaChannel": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.setColor": ('int', 'int'),
-    "PySide2.QtGui.QImage.setColorCount": ('int',),
-    "PySide2.QtGui.QImage.setColorSpace": ('PySide2.QtGui.QColorSpace',),
-    "PySide2.QtGui.QImage.setColorTable": ('typing.List[int]',),
-    "PySide2.QtGui.QImage.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QImage.setDotsPerMeterX": ('int',),
-    "PySide2.QtGui.QImage.setDotsPerMeterY": ('int',),
-    "PySide2.QtGui.QImage.setOffset": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QImage.setPixel": [('PySide2.QtCore.QPoint', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QImage.setPixelColor": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QImage.setText": ('str', 'str'),
-    "PySide2.QtGui.QImage.size": (),
-    "PySide2.QtGui.QImage.sizeInBytes": (),
-    "PySide2.QtGui.QImage.smoothScaled": ('int', 'int'),
-    "PySide2.QtGui.QImage.swap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImage.text": ('str',),
-    "PySide2.QtGui.QImage.textKeys": (),
-    "PySide2.QtGui.QImage.toImageFormat": ('PySide2.QtGui.QPixelFormat',),
-    "PySide2.QtGui.QImage.toPixelFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtGui.QImage.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QImage.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QImage.valid": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QImage.width": (),
-# class PySide2.QtGui.QImageIOHandler:
-# class PySide2.QtGui.QImageIOHandler.ImageOption:
-# class PySide2.QtGui.QImageIOHandler.Transformation:
-# class PySide2.QtGui.QImageIOHandler.Transformations:
-    "PySide2.QtGui.QImageIOHandler.__init__": (),
-    "PySide2.QtGui.QImageIOHandler.canRead": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageNumber": (),
-    "PySide2.QtGui.QImageIOHandler.currentImageRect": (),
-    "PySide2.QtGui.QImageIOHandler.device": (),
-    "PySide2.QtGui.QImageIOHandler.format": (),
-    "PySide2.QtGui.QImageIOHandler.imageCount": (),
-    "PySide2.QtGui.QImageIOHandler.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageIOHandler.jumpToNextImage": (),
-    "PySide2.QtGui.QImageIOHandler.loopCount": (),
-    "PySide2.QtGui.QImageIOHandler.name": (),
-    "PySide2.QtGui.QImageIOHandler.nextImageDelay": (),
-    "PySide2.QtGui.QImageIOHandler.option": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.read": ('PySide2.QtGui.QImage',),
-    "PySide2.QtGui.QImageIOHandler.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageIOHandler.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageIOHandler.setOption": ('PySide2.QtGui.QImageIOHandler.ImageOption', 'typing.Any'),
-    "PySide2.QtGui.QImageIOHandler.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageIOHandler.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QImageReader:
-# class PySide2.QtGui.QImageReader.ImageReaderError:
-    "PySide2.QtGui.QImageReader.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageReader.autoDetectImageFormat": (),
-    "PySide2.QtGui.QImageReader.autoTransform": (),
-    "PySide2.QtGui.QImageReader.backgroundColor": (),
-    "PySide2.QtGui.QImageReader.canRead": (),
-    "PySide2.QtGui.QImageReader.clipRect": (),
-    "PySide2.QtGui.QImageReader.currentImageNumber": (),
-    "PySide2.QtGui.QImageReader.currentImageRect": (),
-    "PySide2.QtGui.QImageReader.decideFormatFromContent": (),
-    "PySide2.QtGui.QImageReader.device": (),
-    "PySide2.QtGui.QImageReader.error": (),
-    "PySide2.QtGui.QImageReader.errorString": (),
-    "PySide2.QtGui.QImageReader.fileName": (),
-    "PySide2.QtGui.QImageReader.format": (),
-    "PySide2.QtGui.QImageReader.gamma": (),
-    "PySide2.QtGui.QImageReader.imageCount": (),
-    "PySide2.QtGui.QImageReader.imageFormat": [(), ('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QImageReader.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.jumpToImage": ('int',),
-    "PySide2.QtGui.QImageReader.jumpToNextImage": (),
-    "PySide2.QtGui.QImageReader.loopCount": (),
-    "PySide2.QtGui.QImageReader.nextImageDelay": (),
-    "PySide2.QtGui.QImageReader.quality": (),
-    "PySide2.QtGui.QImageReader.read": (),
-    "PySide2.QtGui.QImageReader.scaledClipRect": (),
-    "PySide2.QtGui.QImageReader.scaledSize": (),
-    "PySide2.QtGui.QImageReader.setAutoDetectImageFormat": ('bool',),
-    "PySide2.QtGui.QImageReader.setAutoTransform": ('bool',),
-    "PySide2.QtGui.QImageReader.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QImageReader.setClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setDecideFormatFromContent": ('bool',),
-    "PySide2.QtGui.QImageReader.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageReader.setFileName": ('str',),
-    "PySide2.QtGui.QImageReader.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageReader.setGamma": ('float',),
-    "PySide2.QtGui.QImageReader.setQuality": ('int',),
-    "PySide2.QtGui.QImageReader.setScaledClipRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QImageReader.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QImageReader.size": (),
-    "PySide2.QtGui.QImageReader.subType": (),
-    "PySide2.QtGui.QImageReader.supportedImageFormats": (),
-    "PySide2.QtGui.QImageReader.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageReader.supportedSubTypes": (),
-    "PySide2.QtGui.QImageReader.supportsAnimation": (),
-    "PySide2.QtGui.QImageReader.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageReader.text": ('str',),
-    "PySide2.QtGui.QImageReader.textKeys": (),
-    "PySide2.QtGui.QImageReader.transformation": (),
-# class PySide2.QtGui.QImageWriter:
-# class PySide2.QtGui.QImageWriter.ImageWriterError:
-    "PySide2.QtGui.QImageWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QImageWriter.canWrite": (),
-    "PySide2.QtGui.QImageWriter.compression": (),
-    "PySide2.QtGui.QImageWriter.description": (),
-    "PySide2.QtGui.QImageWriter.device": (),
-    "PySide2.QtGui.QImageWriter.error": (),
-    "PySide2.QtGui.QImageWriter.errorString": (),
-    "PySide2.QtGui.QImageWriter.fileName": (),
-    "PySide2.QtGui.QImageWriter.format": (),
-    "PySide2.QtGui.QImageWriter.gamma": (),
-    "PySide2.QtGui.QImageWriter.imageFormatsForMimeType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.optimizedWrite": (),
-    "PySide2.QtGui.QImageWriter.progressiveScanWrite": (),
-    "PySide2.QtGui.QImageWriter.quality": (),
-    "PySide2.QtGui.QImageWriter.setCompression": ('int',),
-    "PySide2.QtGui.QImageWriter.setDescription": ('str',),
-    "PySide2.QtGui.QImageWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QImageWriter.setFileName": ('str',),
-    "PySide2.QtGui.QImageWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setGamma": ('float',),
-    "PySide2.QtGui.QImageWriter.setOptimizedWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setProgressiveScanWrite": ('bool',),
-    "PySide2.QtGui.QImageWriter.setQuality": ('int',),
-    "PySide2.QtGui.QImageWriter.setSubType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QImageWriter.setText": ('str', 'str'),
-    "PySide2.QtGui.QImageWriter.setTransformation": ('PySide2.QtGui.QImageIOHandler.Transformations',),
-    "PySide2.QtGui.QImageWriter.subType": (),
-    "PySide2.QtGui.QImageWriter.supportedImageFormats": (),
-    "PySide2.QtGui.QImageWriter.supportedMimeTypes": (),
-    "PySide2.QtGui.QImageWriter.supportedSubTypes": (),
-    "PySide2.QtGui.QImageWriter.supportsOption": ('PySide2.QtGui.QImageIOHandler.ImageOption',),
-    "PySide2.QtGui.QImageWriter.transformation": (),
-    "PySide2.QtGui.QImageWriter.write": ('PySide2.QtGui.QImage',),
-# class PySide2.QtGui.QInputEvent:
-    "PySide2.QtGui.QInputEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtGui.QInputEvent.modifiers": (),
-    "PySide2.QtGui.QInputEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtGui.QInputEvent.setTimestamp": ('int',),
-    "PySide2.QtGui.QInputEvent.timestamp": (),
-# class PySide2.QtGui.QInputMethod:
-# class PySide2.QtGui.QInputMethod.Action:
-    "PySide2.QtGui.QInputMethod.anchorRectangle": (),
-    "PySide2.QtGui.QInputMethod.commit": (),
-    "PySide2.QtGui.QInputMethod.cursorRectangle": (),
-    "PySide2.QtGui.QInputMethod.hide": (),
-    "PySide2.QtGui.QInputMethod.inputDirection": (),
-    "PySide2.QtGui.QInputMethod.inputItemClipRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemRectangle": (),
-    "PySide2.QtGui.QInputMethod.inputItemTransform": (),
-    "PySide2.QtGui.QInputMethod.invokeAction": ('PySide2.QtGui.QInputMethod.Action', 'int'),
-    "PySide2.QtGui.QInputMethod.isAnimating": (),
-    "PySide2.QtGui.QInputMethod.isVisible": (),
-    "PySide2.QtGui.QInputMethod.keyboardRectangle": (),
-    "PySide2.QtGui.QInputMethod.locale": (),
-    "PySide2.QtGui.QInputMethod.queryFocusObject": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethod.reset": (),
-    "PySide2.QtGui.QInputMethod.setInputItemRectangle": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QInputMethod.setInputItemTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtGui.QInputMethod.setVisible": ('bool',),
-    "PySide2.QtGui.QInputMethod.show": (),
-    "PySide2.QtGui.QInputMethod.update": ('PySide2.QtCore.Qt.InputMethodQueries',),
-# class PySide2.QtGui.QInputMethodEvent:
-# class PySide2.QtGui.QInputMethodEvent.Attribute:
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__init__": [('PySide2.QtGui.QInputMethodEvent.Attribute',), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int'), ('PySide2.QtGui.QInputMethodEvent.AttributeType', 'int', 'int', 'typing.Any')],
-    "PySide2.QtGui.QInputMethodEvent.Attribute.__copy__": (),
-# class PySide2.QtGui.QInputMethodEvent.AttributeType:
-    "PySide2.QtGui.QInputMethodEvent.__init__": [(), ('PySide2.QtGui.QInputMethodEvent',), ('str', 'typing.Sequence[PySide2.QtGui.QInputMethodEvent.Attribute]')],
-    "PySide2.QtGui.QInputMethodEvent.attributes": (),
-    "PySide2.QtGui.QInputMethodEvent.commitString": (),
-    "PySide2.QtGui.QInputMethodEvent.preeditString": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementLength": (),
-    "PySide2.QtGui.QInputMethodEvent.replacementStart": (),
-    "PySide2.QtGui.QInputMethodEvent.setCommitString": ('str', 'int', 'int'),
-# class PySide2.QtGui.QInputMethodQueryEvent:
-    "PySide2.QtGui.QInputMethodQueryEvent.__init__": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtGui.QInputMethodQueryEvent.queries": (),
-    "PySide2.QtGui.QInputMethodQueryEvent.setValue": ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any'),
-    "PySide2.QtGui.QInputMethodQueryEvent.value": ('PySide2.QtCore.Qt.InputMethodQuery',),
-# class PySide2.QtGui.QIntValidator:
-    "PySide2.QtGui.QIntValidator.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QIntValidator.bottom": (),
-    "PySide2.QtGui.QIntValidator.fixup": ('str',),
-    "PySide2.QtGui.QIntValidator.setBottom": ('int',),
-    "PySide2.QtGui.QIntValidator.setRange": ('int', 'int'),
-    "PySide2.QtGui.QIntValidator.setTop": ('int',),
-    "PySide2.QtGui.QIntValidator.top": (),
-    "PySide2.QtGui.QIntValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QKeyEvent:
-    "PySide2.QtGui.QKeyEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'int', 'int', 'str', 'bool', 'int'), ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtGui.QKeyEvent.count": (),
-    "PySide2.QtGui.QKeyEvent.isAutoRepeat": (),
-    "PySide2.QtGui.QKeyEvent.key": (),
-    "PySide2.QtGui.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeyEvent.modifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeModifiers": (),
-    "PySide2.QtGui.QKeyEvent.nativeScanCode": (),
-    "PySide2.QtGui.QKeyEvent.nativeVirtualKey": (),
-    "PySide2.QtGui.QKeyEvent.text": (),
-# class PySide2.QtGui.QKeySequence:
-# class PySide2.QtGui.QKeySequence.SequenceFormat:
-# class PySide2.QtGui.QKeySequence.SequenceMatch:
-# class PySide2.QtGui.QKeySequence.StandardKey:
-    "PySide2.QtGui.QKeySequence.__init__": [(), ('PySide2.QtGui.QKeySequence',), ('PySide2.QtGui.QKeySequence.StandardKey',), ('int', 'int', 'int', 'int'), ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat')],
-    "PySide2.QtGui.QKeySequence.__copy__": (),
-    "PySide2.QtGui.QKeySequence.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.__reduce__": (),
-    "PySide2.QtGui.QKeySequence.__repr__": (),
-    "PySide2.QtGui.QKeySequence.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QKeySequence.count": (),
-    "PySide2.QtGui.QKeySequence.fromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.isEmpty": (),
-    "PySide2.QtGui.QKeySequence.keyBindings": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.QtGui.QKeySequence.listFromString": ('str', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.listToString": ('typing.Sequence[PySide2.QtGui.QKeySequence]', 'PySide2.QtGui.QKeySequence.SequenceFormat'),
-    "PySide2.QtGui.QKeySequence.matches": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.mnemonic": ('str',),
-    "PySide2.QtGui.QKeySequence.swap": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtGui.QKeySequence.toString": ('PySide2.QtGui.QKeySequence.SequenceFormat',),
-# class PySide2.QtGui.QLinearGradient:
-    "PySide2.QtGui.QLinearGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('PySide2.QtGui.QLinearGradient',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QLinearGradient.__copy__": (),
-    "PySide2.QtGui.QLinearGradient.finalStop": (),
-    "PySide2.QtGui.QLinearGradient.setFinalStop": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.setStart": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QLinearGradient.start": (),
-# class PySide2.QtGui.QMatrix:
-    "PySide2.QtGui.QMatrix.__init__": [(), ('PySide2.QtGui.QMatrix',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix.__copy__": (),
-    "PySide2.QtGui.QMatrix.__imul__": ('PySide2.QtGui.QMatrix',),
-    "PySide2.QtGui.QMatrix.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix',)],
-    "PySide2.QtGui.QMatrix.__reduce__": (),
-    "PySide2.QtGui.QMatrix.__repr__": (),
-    "PySide2.QtGui.QMatrix.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix.determinant": (),
-    "PySide2.QtGui.QMatrix.dx": (),
-    "PySide2.QtGui.QMatrix.dy": (),
-    "PySide2.QtGui.QMatrix.inverted": (),
-    "PySide2.QtGui.QMatrix.isIdentity": (),
-    "PySide2.QtGui.QMatrix.isInvertible": (),
-    "PySide2.QtGui.QMatrix.m11": (),
-    "PySide2.QtGui.QMatrix.m12": (),
-    "PySide2.QtGui.QMatrix.m21": (),
-    "PySide2.QtGui.QMatrix.m22": (),
-    "PySide2.QtGui.QMatrix.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float'), ('int', 'int')],
-    "PySide2.QtGui.QMatrix.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QMatrix.reset": (),
-    "PySide2.QtGui.QMatrix.rotate": ('float',),
-    "PySide2.QtGui.QMatrix.scale": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix.shear": ('float', 'float'),
-    "PySide2.QtGui.QMatrix.translate": ('float', 'float'),
-# class PySide2.QtGui.QMatrix2x2:
-    "PySide2.QtGui.QMatrix2x2.__init__": [(), ('PySide2.QtGui.QMatrix2x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x2.__copy__": (),
-    "PySide2.QtGui.QMatrix2x2.__iadd__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x2.__isub__": ('PySide2.QtGui.QMatrix2x2',),
-    "PySide2.QtGui.QMatrix2x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x2.__repr__": (),
-    "PySide2.QtGui.QMatrix2x2.data": (),
-    "PySide2.QtGui.QMatrix2x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x2.transposed": (),
-# class PySide2.QtGui.QMatrix2x3:
-    "PySide2.QtGui.QMatrix2x3.__init__": [(), ('PySide2.QtGui.QMatrix2x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x3.__copy__": (),
-    "PySide2.QtGui.QMatrix2x3.__iadd__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x3.__isub__": ('PySide2.QtGui.QMatrix2x3',),
-    "PySide2.QtGui.QMatrix2x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x3.__repr__": (),
-    "PySide2.QtGui.QMatrix2x3.data": (),
-    "PySide2.QtGui.QMatrix2x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x3.transposed": (),
-# class PySide2.QtGui.QMatrix2x4:
-    "PySide2.QtGui.QMatrix2x4.__init__": [(), ('PySide2.QtGui.QMatrix2x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix2x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix2x4.__copy__": (),
-    "PySide2.QtGui.QMatrix2x4.__iadd__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix2x4.__isub__": ('PySide2.QtGui.QMatrix2x4',),
-    "PySide2.QtGui.QMatrix2x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix2x4.__repr__": (),
-    "PySide2.QtGui.QMatrix2x4.data": (),
-    "PySide2.QtGui.QMatrix2x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix2x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix2x4.transposed": (),
-# class PySide2.QtGui.QMatrix3x2:
-    "PySide2.QtGui.QMatrix3x2.__init__": [(), ('PySide2.QtGui.QMatrix3x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x2.__copy__": (),
-    "PySide2.QtGui.QMatrix3x2.__iadd__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x2.__isub__": ('PySide2.QtGui.QMatrix3x2',),
-    "PySide2.QtGui.QMatrix3x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x2.__repr__": (),
-    "PySide2.QtGui.QMatrix3x2.data": (),
-    "PySide2.QtGui.QMatrix3x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x2.transposed": (),
-# class PySide2.QtGui.QMatrix3x3:
-    "PySide2.QtGui.QMatrix3x3.__init__": [(), ('PySide2.QtGui.QMatrix3x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x3.__copy__": (),
-    "PySide2.QtGui.QMatrix3x3.__iadd__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x3.__isub__": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QMatrix3x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x3.__repr__": (),
-    "PySide2.QtGui.QMatrix3x3.data": (),
-    "PySide2.QtGui.QMatrix3x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x3.transposed": (),
-# class PySide2.QtGui.QMatrix3x4:
-    "PySide2.QtGui.QMatrix3x4.__init__": [(), ('PySide2.QtGui.QMatrix3x4',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix3x4.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix3x4.__copy__": (),
-    "PySide2.QtGui.QMatrix3x4.__iadd__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix3x4.__isub__": ('PySide2.QtGui.QMatrix3x4',),
-    "PySide2.QtGui.QMatrix3x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix3x4.__repr__": (),
-    "PySide2.QtGui.QMatrix3x4.data": (),
-    "PySide2.QtGui.QMatrix3x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix3x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix3x4.transposed": (),
-# class PySide2.QtGui.QMatrix4x2:
-    "PySide2.QtGui.QMatrix4x2.__init__": [(), ('PySide2.QtGui.QMatrix4x2',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x2.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x2.__copy__": (),
-    "PySide2.QtGui.QMatrix4x2.__iadd__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x2.__isub__": ('PySide2.QtGui.QMatrix4x2',),
-    "PySide2.QtGui.QMatrix4x2.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x2.__repr__": (),
-    "PySide2.QtGui.QMatrix4x2.data": (),
-    "PySide2.QtGui.QMatrix4x2.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x2.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x2.transposed": (),
-# class PySide2.QtGui.QMatrix4x3:
-    "PySide2.QtGui.QMatrix4x3.__init__": [(), ('PySide2.QtGui.QMatrix4x3',), ('typing.Iterable',)],
-    "PySide2.QtGui.QMatrix4x3.__call__": ('int', 'int'),
-    "PySide2.QtGui.QMatrix4x3.__copy__": (),
-    "PySide2.QtGui.QMatrix4x3.__iadd__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__imul__": ('float',),
-    "PySide2.QtGui.QMatrix4x3.__isub__": ('PySide2.QtGui.QMatrix4x3',),
-    "PySide2.QtGui.QMatrix4x3.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x3.__repr__": (),
-    "PySide2.QtGui.QMatrix4x3.data": (),
-    "PySide2.QtGui.QMatrix4x3.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x3.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x3.transposed": (),
-# class PySide2.QtGui.QMatrix4x4:
-    "PySide2.QtGui.QMatrix4x4.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtGui.QMatrix4x4.__add__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__copy__": (),
-    "PySide2.QtGui.QMatrix4x4.__dummy": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QMatrix4x4.__iadd__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__imul__": [('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__isub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__mul__": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QMatrix4x4',), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.__neg__": (),
-    "PySide2.QtGui.QMatrix4x4.__reduce__": (),
-    "PySide2.QtGui.QMatrix4x4.__repr__": (),
-    "PySide2.QtGui.QMatrix4x4.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QMatrix4x4.__sub__": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtGui.QMatrix4x4.column": ('int',),
-    "PySide2.QtGui.QMatrix4x4.copyDataTo": (),
-    "PySide2.QtGui.QMatrix4x4.data": (),
-    "PySide2.QtGui.QMatrix4x4.determinant": (),
-    "PySide2.QtGui.QMatrix4x4.fill": ('float',),
-    "PySide2.QtGui.QMatrix4x4.flipCoordinates": (),
-    "PySide2.QtGui.QMatrix4x4.frustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.inverted": (),
-    "PySide2.QtGui.QMatrix4x4.isAffine": (),
-    "PySide2.QtGui.QMatrix4x4.isIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.lookAt": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QMatrix4x4.map": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',)],
-    "PySide2.QtGui.QMatrix4x4.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QMatrix4x4.mapVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QMatrix4x4.normalMatrix": (),
-    "PySide2.QtGui.QMatrix4x4.optimize": (),
-    "PySide2.QtGui.QMatrix4x4.ortho": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.perspective": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QMatrix4x4.rotate": [('PySide2.QtGui.QQuaternion',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.row": ('int',),
-    "PySide2.QtGui.QMatrix4x4.scale": [('PySide2.QtGui.QVector3D',), ('float',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.setColumn": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setRow": ('int', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QMatrix4x4.setToIdentity": (),
-    "PySide2.QtGui.QMatrix4x4.toAffine": (),
-    "PySide2.QtGui.QMatrix4x4.toTransform": [(), ('float',)],
-    "PySide2.QtGui.QMatrix4x4.translate": [('PySide2.QtGui.QVector3D',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtGui.QMatrix4x4.transposed": (),
-    "PySide2.QtGui.QMatrix4x4.viewport": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float', 'float', 'float')],
-# class PySide2.QtGui.QMouseEvent:
-    "PySide2.QtGui.QMouseEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers')],
-    "PySide2.QtGui.QMouseEvent.button": (),
-    "PySide2.QtGui.QMouseEvent.buttons": (),
-    "PySide2.QtGui.QMouseEvent.flags": (),
-    "PySide2.QtGui.QMouseEvent.globalPos": (),
-    "PySide2.QtGui.QMouseEvent.globalX": (),
-    "PySide2.QtGui.QMouseEvent.global""Y": (),
-    "PySide2.QtGui.QMouseEvent.localPos": (),
-    "PySide2.QtGui.QMouseEvent.pos": (),
-    "PySide2.QtGui.QMouseEvent.screenPos": (),
-    "PySide2.QtGui.QMouseEvent.setLocalPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QMouseEvent.source": (),
-    "PySide2.QtGui.QMouseEvent.windowPos": (),
-    "PySide2.QtGui.QMouseEvent.x": (),
-    "PySide2.QtGui.QMouseEvent.y": (),
-# class PySide2.QtGui.QMoveEvent:
-    "PySide2.QtGui.QMoveEvent.__init__": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QMoveEvent.oldPos": (),
-    "PySide2.QtGui.QMoveEvent.pos": (),
-# class PySide2.QtGui.QMovie:
-# class PySide2.QtGui.QMovie.CacheMode:
-# class PySide2.QtGui.QMovie.MovieState:
-    "PySide2.QtGui.QMovie.__init__": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QMovie.backgroundColor": (),
-    "PySide2.QtGui.QMovie.cacheMode": (),
-    "PySide2.QtGui.QMovie.currentFrameNumber": (),
-    "PySide2.QtGui.QMovie.currentImage": (),
-    "PySide2.QtGui.QMovie.currentPixmap": (),
-    "PySide2.QtGui.QMovie.device": (),
-    "PySide2.QtGui.QMovie.fileName": (),
-    "PySide2.QtGui.QMovie.format": (),
-    "PySide2.QtGui.QMovie.frameCount": (),
-    "PySide2.QtGui.QMovie.frameRect": (),
-    "PySide2.QtGui.QMovie.isValid": (),
-    "PySide2.QtGui.QMovie.jumpToFrame": ('int',),
-    "PySide2.QtGui.QMovie.jumpToNextFrame": (),
-    "PySide2.QtGui.QMovie.lastError": (),
-    "PySide2.QtGui.QMovie.lastErrorString": (),
-    "PySide2.QtGui.QMovie.loopCount": (),
-    "PySide2.QtGui.QMovie.nextFrameDelay": (),
-    "PySide2.QtGui.QMovie.scaledSize": (),
-    "PySide2.QtGui.QMovie.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QMovie.setCacheMode": ('PySide2.QtGui.QMovie.CacheMode',),
-    "PySide2.QtGui.QMovie.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QMovie.setFileName": ('str',),
-    "PySide2.QtGui.QMovie.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QMovie.setPaused": ('bool',),
-    "PySide2.QtGui.QMovie.setScaledSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QMovie.setSpeed": ('int',),
-    "PySide2.QtGui.QMovie.speed": (),
-    "PySide2.QtGui.QMovie.start": (),
-    "PySide2.QtGui.QMovie.state": (),
-    "PySide2.QtGui.QMovie.stop": (),
-    "PySide2.QtGui.QMovie.supportedFormats": (),
-# class PySide2.QtGui.QNativeGestureEvent:
-    "PySide2.QtGui.QNativeGestureEvent.__init__": [('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int'), ('PySide2.QtCore.Qt.NativeGestureType', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'float', 'int', 'int')],
-    "PySide2.QtGui.QNativeGestureEvent.device": (),
-    "PySide2.QtGui.QNativeGestureEvent.gestureType": (),
-    "PySide2.QtGui.QNativeGestureEvent.globalPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.localPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.pos": (),
-    "PySide2.QtGui.QNativeGestureEvent.screenPos": (),
-    "PySide2.QtGui.QNativeGestureEvent.value": (),
-    "PySide2.QtGui.QNativeGestureEvent.windowPos": (),
-# class PySide2.QtGui.QOffscreenSurface:
-    "PySide2.QtGui.QOffscreenSurface.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QScreen', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QOffscreenSurface.create": (),
-    "PySide2.QtGui.QOffscreenSurface.destroy": (),
-    "PySide2.QtGui.QOffscreenSurface.format": (),
-    "PySide2.QtGui.QOffscreenSurface.isValid": (),
-    "PySide2.QtGui.QOffscreenSurface.nativeHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.requestedFormat": (),
-    "PySide2.QtGui.QOffscreenSurface.screen": (),
-    "PySide2.QtGui.QOffscreenSurface.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOffscreenSurface.setNativeHandle": ('int',),
-    "PySide2.QtGui.QOffscreenSurface.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOffscreenSurface.size": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceHandle": (),
-    "PySide2.QtGui.QOffscreenSurface.surfaceType": (),
-# class PySide2.QtGui.QOpenGLBuffer:
-# class PySide2.QtGui.QOpenGLBuffer.Access:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlag:
-# class PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags:
-# class PySide2.QtGui.QOpenGLBuffer.Type:
-# class PySide2.QtGui.QOpenGLBuffer.UsagePattern:
-    "PySide2.QtGui.QOpenGLBuffer.__init__": [(), ('PySide2.QtGui.QOpenGLBuffer',), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QOpenGLBuffer.bind": (),
-    "PySide2.QtGui.QOpenGLBuffer.bufferId": (),
-    "PySide2.QtGui.QOpenGLBuffer.create": (),
-    "PySide2.QtGui.QOpenGLBuffer.destroy": (),
-    "PySide2.QtGui.QOpenGLBuffer.isCreated": (),
-    "PySide2.QtGui.QOpenGLBuffer.map": ('PySide2.QtGui.QOpenGLBuffer.Access',),
-    "PySide2.QtGui.QOpenGLBuffer.mapRange": ('int', 'int', 'PySide2.QtGui.QOpenGLBuffer.RangeAccessFlags'),
-    "PySide2.QtGui.QOpenGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLBuffer.release": [(), ('PySide2.QtGui.QOpenGLBuffer.Type',)],
-    "PySide2.QtGui.QOpenGLBuffer.setUsagePattern": ('PySide2.QtGui.QOpenGLBuffer.UsagePattern',),
-    "PySide2.QtGui.QOpenGLBuffer.size": (),
-    "PySide2.QtGui.QOpenGLBuffer.type": (),
-    "PySide2.QtGui.QOpenGLBuffer.unmap": (),
-    "PySide2.QtGui.QOpenGLBuffer.usagePattern": (),
-    "PySide2.QtGui.QOpenGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtGui.QOpenGLContext:
-# class PySide2.QtGui.QOpenGLContext.OpenGLModuleType:
-    "PySide2.QtGui.QOpenGLContext.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLContext.areSharing": ('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLContext.create": (),
-    "PySide2.QtGui.QOpenGLContext.currentContext": (),
-    "PySide2.QtGui.QOpenGLContext.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLContext.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLContext.extensions": (),
-    "PySide2.QtGui.QOpenGLContext.extraFunctions": (),
-    "PySide2.QtGui.QOpenGLContext.format": (),
-    "PySide2.QtGui.QOpenGLContext.functions": (),
-    "PySide2.QtGui.QOpenGLContext.globalShareContext": (),
-    "PySide2.QtGui.QOpenGLContext.hasExtension": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QOpenGLContext.isOpenGLES": (),
-    "PySide2.QtGui.QOpenGLContext.isValid": (),
-    "PySide2.QtGui.QOpenGLContext.makeCurrent": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.nativeHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleHandle": (),
-    "PySide2.QtGui.QOpenGLContext.openGLModuleType": (),
-    "PySide2.QtGui.QOpenGLContext.screen": (),
-    "PySide2.QtGui.QOpenGLContext.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QOpenGLContext.setNativeHandle": ('typing.Any',),
-    "PySide2.QtGui.QOpenGLContext.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QOpenGLContext.setShareContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLContext.shareContext": (),
-    "PySide2.QtGui.QOpenGLContext.shareGroup": (),
-    "PySide2.QtGui.QOpenGLContext.supportsThreadedOpenGL": (),
-    "PySide2.QtGui.QOpenGLContext.surface": (),
-    "PySide2.QtGui.QOpenGLContext.swapBuffers": ('PySide2.QtGui.QSurface',),
-    "PySide2.QtGui.QOpenGLContext.versionFunctions": ('PySide2.QtGui.QOpenGLVersionProfile',),
-# class PySide2.QtGui.QOpenGLContextGroup:
-    "PySide2.QtGui.QOpenGLContextGroup.currentContextGroup": (),
-    "PySide2.QtGui.QOpenGLContextGroup.shares": (),
-# class PySide2.QtGui.QOpenGLDebugLogger:
-# class PySide2.QtGui.QOpenGLDebugLogger.LoggingMode:
-    "PySide2.QtGui.QOpenGLDebugLogger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLDebugLogger.disableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.enableMessages": [('PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types', 'PySide2.QtGui.QOpenGLDebugMessage.Severities'), ('typing.List[int]', 'PySide2.QtGui.QOpenGLDebugMessage.Sources', 'PySide2.QtGui.QOpenGLDebugMessage.Types')],
-    "PySide2.QtGui.QOpenGLDebugLogger.initialize": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.isLogging": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.logMessage": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggedMessages": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.loggingMode": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.maximumMessageLength": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.popGroup": (),
-    "PySide2.QtGui.QOpenGLDebugLogger.pushGroup": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Source'),
-    "PySide2.QtGui.QOpenGLDebugLogger.startLogging": ('PySide2.QtGui.QOpenGLDebugLogger.LoggingMode',),
-    "PySide2.QtGui.QOpenGLDebugLogger.stopLogging": (),
-# class PySide2.QtGui.QOpenGLDebugMessage:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severities:
-# class PySide2.QtGui.QOpenGLDebugMessage.Severity:
-# class PySide2.QtGui.QOpenGLDebugMessage.Source:
-# class PySide2.QtGui.QOpenGLDebugMessage.Sources:
-# class PySide2.QtGui.QOpenGLDebugMessage.Type:
-# class PySide2.QtGui.QOpenGLDebugMessage.Types:
-    "PySide2.QtGui.QOpenGLDebugMessage.__init__": [(), ('PySide2.QtGui.QOpenGLDebugMessage',)],
-    "PySide2.QtGui.QOpenGLDebugMessage.__copy__": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.createApplicationMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.createThirdPartyMessage": ('str', 'int', 'PySide2.QtGui.QOpenGLDebugMessage.Severity', 'PySide2.QtGui.QOpenGLDebugMessage.Type'),
-    "PySide2.QtGui.QOpenGLDebugMessage.id": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.message": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.severity": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.source": (),
-    "PySide2.QtGui.QOpenGLDebugMessage.swap": ('PySide2.QtGui.QOpenGLDebugMessage',),
-    "PySide2.QtGui.QOpenGLDebugMessage.type": (),
-# class PySide2.QtGui.QOpenGLExtraFunctions:
-    "PySide2.QtGui.QOpenGLExtraFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLExtraFunctions.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginQuery": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBeginTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindSampler": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBindVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendBarrier": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glClearBufferuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageControl": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDeleteVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDisablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEnablei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glEndQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenProgramPipelines": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenQueries": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenSamplers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenTransformFeedbacks": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGenVertexArrays": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformBlockiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetActiveUniformsiv": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetFramebufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetGraphicsResetStatus": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetIntegeri_v": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetInternalformativ": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetMultisamplefv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramBinary": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramInterfaceiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramPipelineiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetProgramResourceiv": ('int', 'int', 'int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryObjectuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetQueryiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetStringi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameterfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexLevelParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetTexParameterIuiv": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetUniformuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetVertexAttribIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformfv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glGetnUniformuiv": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glInvalidateSubFramebuffer": ('int', 'int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsQuery": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsSampler": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsTransformFeedback": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glIsVertexArray": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrier": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glMinSampleShading": ('float',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPopDebugGroup": (),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPrimitiveBoundingBox": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform1uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform2uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform3uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4iv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniform4uiv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSampleMaski": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glSamplerParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexParameterIuiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1ui": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform1uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform2uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform3uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniform4uiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUnmapBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glValidateProgramPipeline": ('int',),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4iv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribI4uiv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLExtraFunctions.glVertexBindingDivisor": ('int', 'int'),
-# class PySide2.QtGui.QOpenGLFramebufferObject:
-# class PySide2.QtGui.QOpenGLFramebufferObject.Attachment:
-# class PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy:
-    "PySide2.QtGui.QOpenGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.addColorAttachment": [('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bind": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.bindDefault": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.blitFramebuffer": [('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLFramebufferObject.FramebufferRestorePolicy'), ('PySide2.QtGui.QOpenGLFramebufferObject', 'PySide2.QtGui.QOpenGLFramebufferObject', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.format": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.handle": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.height": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isBound": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.isValid": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.release": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObject.size": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.sizes": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.takeTexture": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLFramebufferObject.texture": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.textures": (),
-    "PySide2.QtGui.QOpenGLFramebufferObject.toImage": [(), ('bool',), ('bool', 'int')],
-    "PySide2.QtGui.QOpenGLFramebufferObject.width": (),
-# class PySide2.QtGui.QOpenGLFramebufferObjectFormat:
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtGui.QOpenGLFramebufferObjectFormat',)],
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setAttachment": ('PySide2.QtGui.QOpenGLFramebufferObject.Attachment',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtGui.QOpenGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtGui.QOpenGLFunctions:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeature:
-# class PySide2.QtGui.QOpenGLFunctions.OpenGLFeatures:
-    "PySide2.QtGui.QOpenGLFunctions.__init__": [(), ('PySide2.QtGui.QOpenGLContext',)],
-    "PySide2.QtGui.QOpenGLFunctions.glActiveTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glAttachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindBuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBindTexture": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquation": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFunc": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClear": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glClearDepthf": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glClearStencil": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompileShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateProgram": (),
-    "PySide2.QtGui.QOpenGLFunctions.glCreateShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glCullFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDeleteTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthFunc": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDepthRangef": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glDetachShader": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDisable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glEnable": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glFinish": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFlush": (),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glFrontFace": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGenBuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenFramebuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenRenderbuffers": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenTextures": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGenerateMipmap": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttachedShaders": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetBufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetError": (),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFloatv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetFramebufferAttachmentParameteriv": ('int', 'int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetIntegerv": ('int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetProgramiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetRenderbufferParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderPrecisionFormat": ('int', 'int', 'shibokensupport.typing27.Sequence', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetShaderiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetString": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetUniformiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glGetVertexAttribiv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glHint": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glIsBuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsEnabled": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsFramebuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsRenderbuffer": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsShader": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glIsTexture": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glLineWidth": ('float',),
-    "PySide2.QtGui.QOpenGLFunctions.glLinkProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glPixelStorei": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glReleaseShaderCompiler": (),
-    "PySide2.QtGui.QOpenGLFunctions.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glShaderBinary": ('int', 'shibokensupport.typing27.Sequence', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMask": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexParameteriv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1i": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform1iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform2iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform3iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniform4iv": ('int', 'int', 'shibokensupport.typing27.Sequence'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glUseProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glValidateProgram": ('int',),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtGui.QOpenGLFunctions.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLFunctions.hasOpenGLFeature": ('PySide2.QtGui.QOpenGLFunctions.OpenGLFeature',),
-    "PySide2.QtGui.QOpenGLFunctions.initializeOpenGLFunctions": (),
-    "PySide2.QtGui.QOpenGLFunctions.openGLFeatures": (),
-# class PySide2.QtGui.QOpenGLPixelTransferOptions:
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__init__": [(), ('PySide2.QtGui.QOpenGLPixelTransferOptions',)],
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.__copy__": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.alignment": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.imageHeight": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isLeastSignificantBitFirst": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.isSwapBytesEnabled": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.rowLength": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setAlignment": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setImageHeight": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setLeastSignificantByteFirst": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setRowLength": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipImages": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipPixels": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSkipRows": ('int',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.setSwapBytesEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipImages": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipPixels": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.skipRows": (),
-    "PySide2.QtGui.QOpenGLPixelTransferOptions.swap": ('PySide2.QtGui.QOpenGLPixelTransferOptions',),
-# class PySide2.QtGui.QOpenGLShader:
-# class PySide2.QtGui.QOpenGLShader.ShaderType:
-# class PySide2.QtGui.QOpenGLShader.ShaderTypeBit:
-    "PySide2.QtGui.QOpenGLShader.__init__": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtGui.QOpenGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShader.compileSourceFile": ('str',),
-    "PySide2.QtGui.QOpenGLShader.hasOpenGLShaders": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtGui.QOpenGLContext'),
-    "PySide2.QtGui.QOpenGLShader.isCompiled": (),
-    "PySide2.QtGui.QOpenGLShader.log": (),
-    "PySide2.QtGui.QOpenGLShader.shaderId": (),
-    "PySide2.QtGui.QOpenGLShader.shaderType": (),
-    "PySide2.QtGui.QOpenGLShader.sourceCode": (),
-# class PySide2.QtGui.QOpenGLShaderProgram:
-    "PySide2.QtGui.QOpenGLShaderProgram.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addCacheableShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtGui.QOpenGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str')],
-    "PySide2.QtGui.QOpenGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtGui.QOpenGLShader.ShaderType', 'str'),
-    "PySide2.QtGui.QOpenGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.bind": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.create": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultInnerTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.defaultOuterTessellationLevels": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtGui.QOpenGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtGui.QOpenGLShaderProgram.isLinked": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.link": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.log": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.patchVertexCount": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.programId": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.release": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.removeShader": ('PySide2.QtGui.QOpenGLShader',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeArray": [('int', 'int', 'int', 'int', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'int', 'int', 'int', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultInnerTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setDefaultOuterTessellationLevels": ('typing.List[float]',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setPatchVertexCount": ('int',),
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('int', 'typing.Tuple[typing.Tuple, typing.Tuple]'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]'), ('str', 'typing.Tuple[typing.Tuple, typing.Tuple]')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1f": [('int', 'float'), ('str', 'float')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValue1i": [('int', 'int'), ('str', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.setUniformValueArray": [('int', 'shibokensupport.typing27.Sequence', 'int'), ('int', 'typing.Sequence[float]', 'int', 'int'), ('str', 'shibokensupport.typing27.Sequence', 'int'), ('str', 'typing.Sequence[float]', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLShaderProgram.shaders": (),
-    "PySide2.QtGui.QOpenGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtGui.QOpenGLTexture:
-# class PySide2.QtGui.QOpenGLTexture.BindingTarget:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonFunction:
-# class PySide2.QtGui.QOpenGLTexture.ComparisonMode:
-# class PySide2.QtGui.QOpenGLTexture.CoordinateDirection:
-# class PySide2.QtGui.QOpenGLTexture.CubeMapFace:
-# class PySide2.QtGui.QOpenGLTexture.DepthStencilMode:
-# class PySide2.QtGui.QOpenGLTexture.Feature:
-# class PySide2.QtGui.QOpenGLTexture.Features:
-# class PySide2.QtGui.QOpenGLTexture.Filter:
-# class PySide2.QtGui.QOpenGLTexture.MipMapGeneration:
-# class PySide2.QtGui.QOpenGLTexture.PixelFormat:
-# class PySide2.QtGui.QOpenGLTexture.PixelType:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleComponent:
-# class PySide2.QtGui.QOpenGLTexture.SwizzleValue:
-# class PySide2.QtGui.QOpenGLTexture.Target:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormat:
-# class PySide2.QtGui.QOpenGLTexture.TextureFormatClass:
-# class PySide2.QtGui.QOpenGLTexture.TextureUnitReset:
-# class PySide2.QtGui.QOpenGLTexture.WrapMode:
-    "PySide2.QtGui.QOpenGLTexture.__init__": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.Target',)],
-    "PySide2.QtGui.QOpenGLTexture.allocateStorage": [(), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType')],
-    "PySide2.QtGui.QOpenGLTexture.bind": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.borderColor": (),
-    "PySide2.QtGui.QOpenGLTexture.boundTextureId": [('PySide2.QtGui.QOpenGLTexture.BindingTarget',), ('int', 'PySide2.QtGui.QOpenGLTexture.BindingTarget')],
-    "PySide2.QtGui.QOpenGLTexture.comparisonFunction": (),
-    "PySide2.QtGui.QOpenGLTexture.comparisonMode": (),
-    "PySide2.QtGui.QOpenGLTexture.create": (),
-    "PySide2.QtGui.QOpenGLTexture.createTextureView": ('PySide2.QtGui.QOpenGLTexture.Target', 'PySide2.QtGui.QOpenGLTexture.TextureFormat', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.depth": (),
-    "PySide2.QtGui.QOpenGLTexture.depthStencilMode": (),
-    "PySide2.QtGui.QOpenGLTexture.destroy": (),
-    "PySide2.QtGui.QOpenGLTexture.faces": (),
-    "PySide2.QtGui.QOpenGLTexture.format": (),
-    "PySide2.QtGui.QOpenGLTexture.generateMipMaps": [(), ('int', 'bool')],
-    "PySide2.QtGui.QOpenGLTexture.hasFeature": ('PySide2.QtGui.QOpenGLTexture.Feature',),
-    "PySide2.QtGui.QOpenGLTexture.height": (),
-    "PySide2.QtGui.QOpenGLTexture.isAutoMipMapGenerationEnabled": (),
-    "PySide2.QtGui.QOpenGLTexture.isBound": [(), ('int',)],
-    "PySide2.QtGui.QOpenGLTexture.isCreated": (),
-    "PySide2.QtGui.QOpenGLTexture.isFixedSamplePositions": (),
-    "PySide2.QtGui.QOpenGLTexture.isStorageAllocated": (),
-    "PySide2.QtGui.QOpenGLTexture.isTextureView": (),
-    "PySide2.QtGui.QOpenGLTexture.layers": (),
-    "PySide2.QtGui.QOpenGLTexture.levelOfDetailRange": (),
-    "PySide2.QtGui.QOpenGLTexture.levelofDetailBias": (),
-    "PySide2.QtGui.QOpenGLTexture.magnificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumAnisotropy": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.maximumMipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.minMagFilters": (),
-    "PySide2.QtGui.QOpenGLTexture.minificationFilter": (),
-    "PySide2.QtGui.QOpenGLTexture.minimumLevelOfDetail": (),
-    "PySide2.QtGui.QOpenGLTexture.mipBaseLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevelRange": (),
-    "PySide2.QtGui.QOpenGLTexture.mipLevels": (),
-    "PySide2.QtGui.QOpenGLTexture.mipMaxLevel": (),
-    "PySide2.QtGui.QOpenGLTexture.release": [(), ('int', 'PySide2.QtGui.QOpenGLTexture.TextureUnitReset')],
-    "PySide2.QtGui.QOpenGLTexture.samples": (),
-    "PySide2.QtGui.QOpenGLTexture.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setBorderColor": [('PySide2.QtGui.QColor',), ('float', 'float', 'float', 'float'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QOpenGLTexture.setComparisonFunction": ('PySide2.QtGui.QOpenGLTexture.ComparisonFunction',),
-    "PySide2.QtGui.QOpenGLTexture.setComparisonMode": ('PySide2.QtGui.QOpenGLTexture.ComparisonMode',),
-    "PySide2.QtGui.QOpenGLTexture.setCompressedData": [('int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setData": [('PySide2.QtGui.QImage', 'PySide2.QtGui.QOpenGLTexture.MipMapGeneration'), ('PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.CubeMapFace', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions'), ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QOpenGLTexture.PixelFormat', 'PySide2.QtGui.QOpenGLTexture.PixelType', 'int', 'PySide2.QtGui.QOpenGLPixelTransferOptions')],
-    "PySide2.QtGui.QOpenGLTexture.setDepthStencilMode": ('PySide2.QtGui.QOpenGLTexture.DepthStencilMode',),
-    "PySide2.QtGui.QOpenGLTexture.setFixedSamplePositions": ('bool',),
-    "PySide2.QtGui.QOpenGLTexture.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.QtGui.QOpenGLTexture.setLayers": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setLevelOfDetailRange": ('float', 'float'),
-    "PySide2.QtGui.QOpenGLTexture.setLevelofDetailBias": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMagnificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMaximumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMinMagFilters": ('PySide2.QtGui.QOpenGLTexture.Filter', 'PySide2.QtGui.QOpenGLTexture.Filter'),
-    "PySide2.QtGui.QOpenGLTexture.setMinificationFilter": ('PySide2.QtGui.QOpenGLTexture.Filter',),
-    "PySide2.QtGui.QOpenGLTexture.setMinimumLevelOfDetail": ('float',),
-    "PySide2.QtGui.QOpenGLTexture.setMipBaseLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevelRange": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setMipLevels": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setMipMaxLevel": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSamples": ('int',),
-    "PySide2.QtGui.QOpenGLTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.QtGui.QOpenGLTexture.setSwizzleMask": [('PySide2.QtGui.QOpenGLTexture.SwizzleComponent', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue'), ('PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue', 'PySide2.QtGui.QOpenGLTexture.SwizzleValue')],
-    "PySide2.QtGui.QOpenGLTexture.setWrapMode": [('PySide2.QtGui.QOpenGLTexture.CoordinateDirection', 'PySide2.QtGui.QOpenGLTexture.WrapMode'), ('PySide2.QtGui.QOpenGLTexture.WrapMode',)],
-    "PySide2.QtGui.QOpenGLTexture.swizzleMask": ('PySide2.QtGui.QOpenGLTexture.SwizzleComponent',),
-    "PySide2.QtGui.QOpenGLTexture.target": (),
-    "PySide2.QtGui.QOpenGLTexture.textureId": (),
-    "PySide2.QtGui.QOpenGLTexture.width": (),
-    "PySide2.QtGui.QOpenGLTexture.wrapMode": ('PySide2.QtGui.QOpenGLTexture.CoordinateDirection',),
-# class PySide2.QtGui.QOpenGLTextureBlitter:
-# class PySide2.QtGui.QOpenGLTextureBlitter.Origin:
-    "PySide2.QtGui.QOpenGLTextureBlitter.__init__": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.bind": ('int',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.blit": [('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin')],
-    "PySide2.QtGui.QOpenGLTextureBlitter.create": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.destroy": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.isCreated": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.release": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setOpacity": ('float',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.setRedBlueSwizzle": ('bool',),
-    "PySide2.QtGui.QOpenGLTextureBlitter.sourceTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QSize', 'PySide2.QtGui.QOpenGLTextureBlitter.Origin'),
-    "PySide2.QtGui.QOpenGLTextureBlitter.supportsExternalOESTarget": (),
-    "PySide2.QtGui.QOpenGLTextureBlitter.targetTransform": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect'),
-# class PySide2.QtGui.QOpenGLTimeMonitor:
-    "PySide2.QtGui.QOpenGLTimeMonitor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimeMonitor.create": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.destroy": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.objectIds": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.recordSample": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.reset": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.sampleCount": (),
-    "PySide2.QtGui.QOpenGLTimeMonitor.setSampleCount": ('int',),
-# class PySide2.QtGui.QOpenGLTimerQuery:
-    "PySide2.QtGui.QOpenGLTimerQuery.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLTimerQuery.begin": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.create": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.destroy": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.end": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isCreated": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.isResultAvailable": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.objectId": (),
-    "PySide2.QtGui.QOpenGLTimerQuery.recordTimestamp": (),
-# class PySide2.QtGui.QOpenGLVersionProfile:
-    "PySide2.QtGui.QOpenGLVersionProfile.__init__": [(), ('PySide2.QtGui.QOpenGLVersionProfile',), ('PySide2.QtGui.QSurfaceFormat',)],
-    "PySide2.QtGui.QOpenGLVersionProfile.__copy__": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.hasProfiles": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isLegacyVersion": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.isValid": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.profile": (),
-    "PySide2.QtGui.QOpenGLVersionProfile.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QOpenGLVersionProfile.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLVersionProfile.version": (),
-# class PySide2.QtGui.QOpenGLVertexArrayObject:
-# class PySide2.QtGui.QOpenGLVertexArrayObject.Binder:
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.__init__": ('PySide2.QtGui.QOpenGLVertexArrayObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.rebind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.Binder.release": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.bind": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.create": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.destroy": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.isCreated": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.objectId": (),
-    "PySide2.QtGui.QOpenGLVertexArrayObject.release": (),
-# class PySide2.QtGui.QOpenGLWindow:
-# class PySide2.QtGui.QOpenGLWindow.UpdateBehavior:
-    "PySide2.QtGui.QOpenGLWindow.__init__": [('PySide2.QtGui.QOpenGLContext', 'PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow'), ('PySide2.QtGui.QOpenGLWindow.UpdateBehavior', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtGui.QOpenGLWindow.context": (),
-    "PySide2.QtGui.QOpenGLWindow.defaultFramebufferObject": (),
-    "PySide2.QtGui.QOpenGLWindow.doneCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.grabFramebuffer": (),
-    "PySide2.QtGui.QOpenGLWindow.initializeGL": (),
-    "PySide2.QtGui.QOpenGLWindow.isValid": (),
-    "PySide2.QtGui.QOpenGLWindow.makeCurrent": (),
-    "PySide2.QtGui.QOpenGLWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QOpenGLWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QOpenGLWindow.paintGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintOverGL": (),
-    "PySide2.QtGui.QOpenGLWindow.paintUnderGL": (),
-    "PySide2.QtGui.QOpenGLWindow.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QOpenGLWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QOpenGLWindow.resizeGL": ('int', 'int'),
-    "PySide2.QtGui.QOpenGLWindow.shareContext": (),
-    "PySide2.QtGui.QOpenGLWindow.updateBehavior": (),
-# class PySide2.QtGui.QPageLayout:
-# class PySide2.QtGui.QPageLayout.Mode:
-# class PySide2.QtGui.QPageLayout.Orientation:
-# class PySide2.QtGui.QPageLayout.Unit:
-    "PySide2.QtGui.QPageLayout.__init__": [(), ('PySide2.QtGui.QPageLayout',), ('PySide2.QtGui.QPageSize', 'PySide2.QtGui.QPageLayout.Orientation', 'PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit', 'PySide2.QtCore.QMarginsF')],
-    "PySide2.QtGui.QPageLayout.__copy__": (),
-    "PySide2.QtGui.QPageLayout.fullRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.fullRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.fullRectPoints": (),
-    "PySide2.QtGui.QPageLayout.isEquivalentTo": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.isValid": (),
-    "PySide2.QtGui.QPageLayout.margins": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.marginsPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.marginsPoints": (),
-    "PySide2.QtGui.QPageLayout.maximumMargins": (),
-    "PySide2.QtGui.QPageLayout.minimumMargins": (),
-    "PySide2.QtGui.QPageLayout.mode": (),
-    "PySide2.QtGui.QPageLayout.orientation": (),
-    "PySide2.QtGui.QPageLayout.pageSize": (),
-    "PySide2.QtGui.QPageLayout.paintRect": [(), ('PySide2.QtGui.QPageLayout.Unit',)],
-    "PySide2.QtGui.QPageLayout.paintRectPixels": ('int',),
-    "PySide2.QtGui.QPageLayout.paintRectPoints": (),
-    "PySide2.QtGui.QPageLayout.setBottomMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setLeftMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMinimumMargins": ('PySide2.QtCore.QMarginsF',),
-    "PySide2.QtGui.QPageLayout.setMode": ('PySide2.QtGui.QPageLayout.Mode',),
-    "PySide2.QtGui.QPageLayout.setOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPageLayout.setPageSize": ('PySide2.QtGui.QPageSize', 'PySide2.QtCore.QMarginsF'),
-    "PySide2.QtGui.QPageLayout.setRightMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setTopMargin": ('float',),
-    "PySide2.QtGui.QPageLayout.setUnits": ('PySide2.QtGui.QPageLayout.Unit',),
-    "PySide2.QtGui.QPageLayout.swap": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPageLayout.units": (),
-# class PySide2.QtGui.QPageSize:
-# class PySide2.QtGui.QPageSize.PageSizeId:
-# class PySide2.QtGui.QPageSize.SizeMatchPolicy:
-# class PySide2.QtGui.QPageSize.Unit:
-    "PySide2.QtGui.QPageSize.__init__": [(), ('PySide2.QtCore.QSize', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'str', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.__copy__": (),
-    "PySide2.QtGui.QPageSize.definitionSize": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.definitionUnits": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.id": [(), ('PySide2.QtCore.QSize', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('PySide2.QtCore.QSizeF', 'PySide2.QtGui.QPageSize.Unit', 'PySide2.QtGui.QPageSize.SizeMatchPolicy'), ('int',)],
-    "PySide2.QtGui.QPageSize.isEquivalentTo": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.isValid": (),
-    "PySide2.QtGui.QPageSize.key": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.name": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.rect": ('PySide2.QtGui.QPageSize.Unit',),
-    "PySide2.QtGui.QPageSize.rectPixels": ('int',),
-    "PySide2.QtGui.QPageSize.rectPoints": (),
-    "PySide2.QtGui.QPageSize.size": [('PySide2.QtGui.QPageSize.PageSizeId', 'PySide2.QtGui.QPageSize.Unit'), ('PySide2.QtGui.QPageSize.Unit',)],
-    "PySide2.QtGui.QPageSize.sizePixels": [('PySide2.QtGui.QPageSize.PageSizeId', 'int'), ('int',)],
-    "PySide2.QtGui.QPageSize.sizePoints": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-    "PySide2.QtGui.QPageSize.swap": ('PySide2.QtGui.QPageSize',),
-    "PySide2.QtGui.QPageSize.windowsId": [(), ('PySide2.QtGui.QPageSize.PageSizeId',)],
-# class PySide2.QtGui.QPagedPaintDevice:
-# class PySide2.QtGui.QPagedPaintDevice.Margins:
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__init__": [(), ('PySide2.QtGui.QPagedPaintDevice.Margins',)],
-    "PySide2.QtGui.QPagedPaintDevice.Margins.__copy__": (),
-# class PySide2.QtGui.QPagedPaintDevice.PageSize:
-# class PySide2.QtGui.QPagedPaintDevice.PdfVersion:
-    "PySide2.QtGui.QPagedPaintDevice.__init__": (),
-    "PySide2.QtGui.QPagedPaintDevice.devicePageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.margins": (),
-    "PySide2.QtGui.QPagedPaintDevice.newPage": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageLayout": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSize": (),
-    "PySide2.QtGui.QPagedPaintDevice.pageSizeMM": (),
-    "PySide2.QtGui.QPagedPaintDevice.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageLayout": ('PySide2.QtGui.QPageLayout',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('PySide2.QtCore.QMarginsF', 'PySide2.QtGui.QPageLayout.Unit')],
-    "PySide2.QtGui.QPagedPaintDevice.setPageOrientation": ('PySide2.QtGui.QPageLayout.Orientation',),
-    "PySide2.QtGui.QPagedPaintDevice.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtGui.QPagedPaintDevice.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtGui.QPaintDevice:
-# class PySide2.QtGui.QPaintDevice.PaintDeviceMetric:
-    "PySide2.QtGui.QPaintDevice.__init__": (),
-    "PySide2.QtGui.QPaintDevice.colorCount": (),
-    "PySide2.QtGui.QPaintDevice.depth": (),
-    "PySide2.QtGui.QPaintDevice.devType": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatio": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioF": (),
-    "PySide2.QtGui.QPaintDevice.devicePixelRatioFScale": (),
-    "PySide2.QtGui.QPaintDevice.height": (),
-    "PySide2.QtGui.QPaintDevice.heightMM": (),
-    "PySide2.QtGui.QPaintDevice.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPaintDevice.logicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.logicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDevice.paintEngine": (),
-    "PySide2.QtGui.QPaintDevice.paintingActive": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiX": (),
-    "PySide2.QtGui.QPaintDevice.physicalDpiY": (),
-    "PySide2.QtGui.QPaintDevice.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPaintDevice.sharedPainter": (),
-    "PySide2.QtGui.QPaintDevice.width": (),
-    "PySide2.QtGui.QPaintDevice.widthMM": (),
-# class PySide2.QtGui.QPaintDeviceWindow:
-    "PySide2.QtGui.QPaintDeviceWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEngine": (),
-    "PySide2.QtGui.QPaintDeviceWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtGui.QPaintDeviceWindow.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-# class PySide2.QtGui.QPaintEngine:
-# class PySide2.QtGui.QPaintEngine.DirtyFlag:
-# class PySide2.QtGui.QPaintEngine.DirtyFlags:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeature:
-# class PySide2.QtGui.QPaintEngine.PaintEngineFeatures:
-# class PySide2.QtGui.QPaintEngine.PolygonDrawMode:
-# class PySide2.QtGui.QPaintEngine.Type:
-    "PySide2.QtGui.QPaintEngine.__init__": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPaintEngine.clearDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.coordinateOffset": (),
-    "PySide2.QtGui.QPaintEngine.drawEllipse": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QPaintEngine.drawImage": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPaintEngine.drawLines": [('PySide2.QtCore.QLine', 'int'), ('PySide2.QtCore.QLineF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPaintEngine.drawPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QPaintEngine.drawPoints": [('PySide2.QtCore.QPoint', 'int'), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawPolygon": [('PySide2.QtCore.QPoint', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtGui.QPaintEngine.PolygonDrawMode')],
-    "PySide2.QtGui.QPaintEngine.drawRects": [('PySide2.QtCore.QRect', 'int'), ('PySide2.QtCore.QRectF', 'int')],
-    "PySide2.QtGui.QPaintEngine.drawTextItem": ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'),
-    "PySide2.QtGui.QPaintEngine.drawTiledPixmap": ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPaintEngine.end": (),
-    "PySide2.QtGui.QPaintEngine.hasFeature": ('PySide2.QtGui.QPaintEngine.PaintEngineFeatures',),
-    "PySide2.QtGui.QPaintEngine.isActive": (),
-    "PySide2.QtGui.QPaintEngine.isExtended": (),
-    "PySide2.QtGui.QPaintEngine.paintDevice": (),
-    "PySide2.QtGui.QPaintEngine.painter": (),
-    "PySide2.QtGui.QPaintEngine.setActive": ('bool',),
-    "PySide2.QtGui.QPaintEngine.setDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.setSystemClip": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPaintEngine.setSystemRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPaintEngine.syncState": (),
-    "PySide2.QtGui.QPaintEngine.systemClip": (),
-    "PySide2.QtGui.QPaintEngine.systemRect": (),
-    "PySide2.QtGui.QPaintEngine.testDirty": ('PySide2.QtGui.QPaintEngine.DirtyFlags',),
-    "PySide2.QtGui.QPaintEngine.type": (),
-    "PySide2.QtGui.QPaintEngine.updateState": ('PySide2.QtGui.QPaintEngineState',),
-# class PySide2.QtGui.QPaintEngineState:
-    "PySide2.QtGui.QPaintEngineState.__init__": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundBrush": (),
-    "PySide2.QtGui.QPaintEngineState.backgroundMode": (),
-    "PySide2.QtGui.QPaintEngineState.brush": (),
-    "PySide2.QtGui.QPaintEngineState.brushNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.brushOrigin": (),
-    "PySide2.QtGui.QPaintEngineState.clipOperation": (),
-    "PySide2.QtGui.QPaintEngineState.clipPath": (),
-    "PySide2.QtGui.QPaintEngineState.clipRegion": (),
-    "PySide2.QtGui.QPaintEngineState.compositionMode": (),
-    "PySide2.QtGui.QPaintEngineState.font": (),
-    "PySide2.QtGui.QPaintEngineState.isClipEnabled": (),
-    "PySide2.QtGui.QPaintEngineState.matrix": (),
-    "PySide2.QtGui.QPaintEngineState.opacity": (),
-    "PySide2.QtGui.QPaintEngineState.painter": (),
-    "PySide2.QtGui.QPaintEngineState.pen": (),
-    "PySide2.QtGui.QPaintEngineState.penNeedsResolving": (),
-    "PySide2.QtGui.QPaintEngineState.renderHints": (),
-    "PySide2.QtGui.QPaintEngineState.state": (),
-    "PySide2.QtGui.QPaintEngineState.transform": (),
-# class PySide2.QtGui.QPaintEvent:
-    "PySide2.QtGui.QPaintEvent.__init__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QPaintEvent.rect": (),
-    "PySide2.QtGui.QPaintEvent.region": (),
-# class PySide2.QtGui.QPainter:
-# class PySide2.QtGui.QPainter.CompositionMode:
-# class PySide2.QtGui.QPainter.PixmapFragment:
-    "PySide2.QtGui.QPainter.PixmapFragment.__init__": [(), ('PySide2.QtGui.QPainter.PixmapFragment',)],
-    "PySide2.QtGui.QPainter.PixmapFragment.__copy__": (),
-    "PySide2.QtGui.QPainter.PixmapFragment.create": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QRectF', 'float', 'float', 'float', 'float'),
-# class PySide2.QtGui.QPainter.PixmapFragmentHint:
-# class PySide2.QtGui.QPainter.PixmapFragmentHints:
-# class PySide2.QtGui.QPainter.RenderHint:
-# class PySide2.QtGui.QPainter.RenderHints:
-    "PySide2.QtGui.QPainter.__init__": [(), ('PySide2.QtGui.QPaintDevice',)],
-    "PySide2.QtGui.QPainter.background": (),
-    "PySide2.QtGui.QPainter.backgroundMode": (),
-    "PySide2.QtGui.QPainter.begin": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.beginNativePainting": (),
-    "PySide2.QtGui.QPainter.boundingRect": [('PySide2.QtCore.QRect', 'int', 'str'), ('PySide2.QtCore.QRectF', 'int', 'str'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.brush": (),
-    "PySide2.QtGui.QPainter.brushOrigin": (),
-    "PySide2.QtGui.QPainter.clipBoundingRect": (),
-    "PySide2.QtGui.QPainter.clipPath": (),
-    "PySide2.QtGui.QPainter.clipRegion": (),
-    "PySide2.QtGui.QPainter.combinedMatrix": (),
-    "PySide2.QtGui.QPainter.combinedTransform": (),
-    "PySide2.QtGui.QPainter.compositionMode": (),
-    "PySide2.QtGui.QPainter.device": (),
-    "PySide2.QtGui.QPainter.deviceMatrix": (),
-    "PySide2.QtGui.QPainter.deviceTransform": (),
-    "PySide2.QtGui.QPainter.drawArc": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawChord": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawConvexPolygon": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawEllipse": [('PySide2.QtCore.QPoint', 'int', 'int'), ('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawImage": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('int', 'int', 'PySide2.QtGui.QImage', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPainter.drawLine": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawLines": [('typing.List[PySide2.QtCore.QLineF]',), ('typing.List[PySide2.QtCore.QLine]',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainter.drawPicture": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPicture'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPicture'), ('int', 'int', 'PySide2.QtGui.QPicture')],
-    "PySide2.QtGui.QPainter.drawPie": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmap": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPoint', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QRectF'), ('int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawPixmapFragments": ('PySide2.QtGui.QPainter.PixmapFragment', 'int', 'PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPainter.PixmapFragmentHints'),
-    "PySide2.QtGui.QPainter.drawPoint": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.drawPoints": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawPolygon": [('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPointF]', 'PySide2.QtCore.Qt.FillRule'), ('typing.List[PySide2.QtCore.QPoint]', 'PySide2.QtCore.Qt.FillRule')],
-    "PySide2.QtGui.QPainter.drawPolyline": [('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPainter.drawRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRects": [('typing.List[PySide2.QtCore.QRectF]',), ('typing.List[PySide2.QtCore.QRect]',)],
-    "PySide2.QtGui.QPainter.drawRoundRect": [('PySide2.QtCore.QRect', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('int', 'int', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.drawRoundedRect": [('PySide2.QtCore.QRect', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('int', 'int', 'int', 'int', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainter.drawStaticText": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QStaticText'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QStaticText'), ('int', 'int', 'PySide2.QtGui.QStaticText')],
-    "PySide2.QtGui.QPainter.drawText": [('PySide2.QtCore.QPoint', 'str'), ('PySide2.QtCore.QPointF', 'str'), ('PySide2.QtCore.QRect', 'int', 'str', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QRectF', 'int', 'str', 'PySide2.QtCore.QRectF'), ('PySide2.QtCore.QRectF', 'str', 'PySide2.QtGui.QTextOption'), ('int', 'int', 'int', 'int', 'int', 'str', 'PySide2.QtCore.QRect'), ('int', 'int', 'str')],
-    "PySide2.QtGui.QPainter.drawTextItem": [('PySide2.QtCore.QPoint', 'PySide2.QtGui.QTextItem'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextItem'), ('int', 'int', 'PySide2.QtGui.QTextItem')],
-    "PySide2.QtGui.QPainter.drawTiledPixmap": [('PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPoint'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.QPointF'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QPixmap', 'int', 'int')],
-    "PySide2.QtGui.QPainter.end": (),
-    "PySide2.QtGui.QPainter.endNativePainting": (),
-    "PySide2.QtGui.QPainter.eraseRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.fillPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPainter.fillRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QGradient.Preset'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.BrushStyle'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.GlobalColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QBrush'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor'), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QGradient.Preset'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.BrushStyle'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.GlobalColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QBrush'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QGradient.Preset')],
-    "PySide2.QtGui.QPainter.font": (),
-    "PySide2.QtGui.QPainter.fontInfo": (),
-    "PySide2.QtGui.QPainter.fontMetrics": (),
-    "PySide2.QtGui.QPainter.hasClipping": (),
-    "PySide2.QtGui.QPainter.initFrom": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.isActive": (),
-    "PySide2.QtGui.QPainter.layoutDirection": (),
-    "PySide2.QtGui.QPainter.matrix": (),
-    "PySide2.QtGui.QPainter.matrixEnabled": (),
-    "PySide2.QtGui.QPainter.opacity": (),
-    "PySide2.QtGui.QPainter.paintEngine": (),
-    "PySide2.QtGui.QPainter.pen": (),
-    "PySide2.QtGui.QPainter.redirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.renderHints": (),
-    "PySide2.QtGui.QPainter.resetMatrix": (),
-    "PySide2.QtGui.QPainter.resetTransform": (),
-    "PySide2.QtGui.QPainter.restore": (),
-    "PySide2.QtGui.QPainter.restoreRedirected": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtGui.QPainter.rotate": ('float',),
-    "PySide2.QtGui.QPainter.save": (),
-    "PySide2.QtGui.QPainter.scale": ('float', 'float'),
-    "PySide2.QtGui.QPainter.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPainter.setBackgroundMode": ('PySide2.QtCore.Qt.BGMode',),
-    "PySide2.QtGui.QPainter.setBrush": [('PySide2.QtCore.Qt.BrushStyle',), ('PySide2.QtGui.QBrush',)],
-    "PySide2.QtGui.QPainter.setBrushOrigin": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('int', 'int')],
-    "PySide2.QtGui.QPainter.setClipPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipRect": [('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ClipOperation'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ClipOperation'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ClipOperation')],
-    "PySide2.QtGui.QPainter.setClipRegion": ('PySide2.QtGui.QRegion', 'PySide2.QtCore.Qt.ClipOperation'),
-    "PySide2.QtGui.QPainter.setClipping": ('bool',),
-    "PySide2.QtGui.QPainter.setCompositionMode": ('PySide2.QtGui.QPainter.CompositionMode',),
-    "PySide2.QtGui.QPainter.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QPainter.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QPainter.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setOpacity": ('float',),
-    "PySide2.QtGui.QPainter.setPen": [('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainter.setRedirected": ('PySide2.QtGui.QPaintDevice', 'PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPainter.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtGui.QPainter.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints', 'bool'),
-    "PySide2.QtGui.QPainter.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.setViewTransformEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setViewport": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWindow": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPainter.setWorldMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtGui.QPainter.setWorldMatrixEnabled": ('bool',),
-    "PySide2.QtGui.QPainter.setWorldTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtGui.QPainter.shear": ('float', 'float'),
-    "PySide2.QtGui.QPainter.strokePath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen'),
-    "PySide2.QtGui.QPainter.testRenderHint": ('PySide2.QtGui.QPainter.RenderHint',),
-    "PySide2.QtGui.QPainter.transform": (),
-    "PySide2.QtGui.QPainter.translate": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainter.viewTransformEnabled": (),
-    "PySide2.QtGui.QPainter.viewport": (),
-    "PySide2.QtGui.QPainter.window": (),
-    "PySide2.QtGui.QPainter.worldMatrix": (),
-    "PySide2.QtGui.QPainter.worldMatrixEnabled": (),
-    "PySide2.QtGui.QPainter.worldTransform": (),
-# class PySide2.QtGui.QPainterPath:
-# class PySide2.QtGui.QPainterPath.Element:
-    "PySide2.QtGui.QPainterPath.Element.__init__": [(), ('PySide2.QtGui.QPainterPath.Element',)],
-    "PySide2.QtGui.QPainterPath.Element.__copy__": (),
-    "PySide2.QtGui.QPainterPath.Element.isCurveTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isLineTo": (),
-    "PySide2.QtGui.QPainterPath.Element.isMoveTo": (),
-# class PySide2.QtGui.QPainterPath.ElementType:
-    "PySide2.QtGui.QPainterPath.__init__": [(), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.__add__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__and__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__copy__": (),
-    "PySide2.QtGui.QPainterPath.__iadd__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__iand__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__ior__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__isub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.__or__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPainterPath.__sub__": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addEllipse": [('PySide2.QtCore.QPointF', 'float', 'float'), ('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.addPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPainterPath.addRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.addRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QPainterPath.addRoundRect": [('PySide2.QtCore.QRectF', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtGui.QPainterPath.addRoundedRect": [('PySide2.QtCore.QRectF', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode'), ('float', 'float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.SizeMode')],
-    "PySide2.QtGui.QPainterPath.addText": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QFont', 'str'), ('float', 'float', 'PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtGui.QPainterPath.angleAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.arcMoveTo": [('PySide2.QtCore.QRectF', 'float'), ('float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.arcTo": [('PySide2.QtCore.QRectF', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.boundingRect": (),
-    "PySide2.QtGui.QPainterPath.capacity": (),
-    "PySide2.QtGui.QPainterPath.clear": (),
-    "PySide2.QtGui.QPainterPath.closeSubpath": (),
-    "PySide2.QtGui.QPainterPath.connectPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.contains": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.controlPointRect": (),
-    "PySide2.QtGui.QPainterPath.cubicTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.currentPosition": (),
-    "PySide2.QtGui.QPainterPath.elementAt": ('int',),
-    "PySide2.QtGui.QPainterPath.elementCount": (),
-    "PySide2.QtGui.QPainterPath.fillRule": (),
-    "PySide2.QtGui.QPainterPath.intersected": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.intersects": [('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',)],
-    "PySide2.QtGui.QPainterPath.isEmpty": (),
-    "PySide2.QtGui.QPainterPath.length": (),
-    "PySide2.QtGui.QPainterPath.lineTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.moveTo": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.percentAtLength": ('float',),
-    "PySide2.QtGui.QPainterPath.pointAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.quadTo": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QPainterPath.reserve": ('int',),
-    "PySide2.QtGui.QPainterPath.setElementPositionAt": ('int', 'float', 'float'),
-    "PySide2.QtGui.QPainterPath.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtGui.QPainterPath.simplified": (),
-    "PySide2.QtGui.QPainterPath.slopeAtPercent": ('float',),
-    "PySide2.QtGui.QPainterPath.subtracted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.subtractedInverted": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.swap": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPath.toFillPolygon": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toFillPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.toReversed": (),
-    "PySide2.QtGui.QPainterPath.toSubpathPolygons": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPainterPath.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPainterPath.united": ('PySide2.QtGui.QPainterPath',),
-# class PySide2.QtGui.QPainterPathStroker:
-    "PySide2.QtGui.QPainterPathStroker.__init__": [(), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPainterPathStroker.capStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.createStroke": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtGui.QPainterPathStroker.curveThreshold": (),
-    "PySide2.QtGui.QPainterPathStroker.dashOffset": (),
-    "PySide2.QtGui.QPainterPathStroker.dashPattern": (),
-    "PySide2.QtGui.QPainterPathStroker.joinStyle": (),
-    "PySide2.QtGui.QPainterPathStroker.miterLimit": (),
-    "PySide2.QtGui.QPainterPathStroker.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setCurveThreshold": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashOffset": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setDashPattern": [('PySide2.QtCore.Qt.PenStyle',), ('typing.List[float]',)],
-    "PySide2.QtGui.QPainterPathStroker.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPainterPathStroker.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.setWidth": ('float',),
-    "PySide2.QtGui.QPainterPathStroker.width": (),
-# class PySide2.QtGui.QPalette:
-# class PySide2.QtGui.QPalette.ColorGroup:
-# class PySide2.QtGui.QPalette.ColorRole:
-    "PySide2.QtGui.QPalette.__init__": [(), ('PySide2.QtCore.Qt.GlobalColor',), ('PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette',)],
-    "PySide2.QtGui.QPalette.__copy__": (),
-    "PySide2.QtGui.QPalette.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPalette.alternateBase": (),
-    "PySide2.QtGui.QPalette.background": (),
-    "PySide2.QtGui.QPalette.base": (),
-    "PySide2.QtGui.QPalette.brightText": (),
-    "PySide2.QtGui.QPalette.brush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.button": (),
-    "PySide2.QtGui.QPalette.buttonText": (),
-    "PySide2.QtGui.QPalette.cacheKey": (),
-    "PySide2.QtGui.QPalette.color": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'), ('PySide2.QtGui.QPalette.ColorRole',)],
-    "PySide2.QtGui.QPalette.currentColorGroup": (),
-    "PySide2.QtGui.QPalette.dark": (),
-    "PySide2.QtGui.QPalette.foreground": (),
-    "PySide2.QtGui.QPalette.highlight": (),
-    "PySide2.QtGui.QPalette.highlightedText": (),
-    "PySide2.QtGui.QPalette.isBrushSet": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtGui.QPalette.isCopyOf": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.isEqual": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorGroup'),
-    "PySide2.QtGui.QPalette.light": (),
-    "PySide2.QtGui.QPalette.link": (),
-    "PySide2.QtGui.QPalette.linkVisited": (),
-    "PySide2.QtGui.QPalette.mid": (),
-    "PySide2.QtGui.QPalette.midlight": (),
-    "PySide2.QtGui.QPalette.placeholderText": (),
-    "PySide2.QtGui.QPalette.resolve": [(), ('PySide2.QtGui.QPalette',), ('int',)],
-    "PySide2.QtGui.QPalette.setBrush": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtGui.QPalette.setColor": [('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor'), ('PySide2.QtGui.QPalette.ColorRole', 'PySide2.QtGui.QColor')],
-    "PySide2.QtGui.QPalette.setColorGroup": ('PySide2.QtGui.QPalette.ColorGroup', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtGui.QPalette.setCurrentColorGroup": ('PySide2.QtGui.QPalette.ColorGroup',),
-    "PySide2.QtGui.QPalette.shadow": (),
-    "PySide2.QtGui.QPalette.swap": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtGui.QPalette.text": (),
-    "PySide2.QtGui.QPalette.toolTipBase": (),
-    "PySide2.QtGui.QPalette.toolTipText": (),
-    "PySide2.QtGui.QPalette.window": (),
-    "PySide2.QtGui.QPalette.windowText": (),
-# class PySide2.QtGui.QPdfWriter:
-    "PySide2.QtGui.QPdfWriter.__init__": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPdfWriter.creator": (),
-    "PySide2.QtGui.QPdfWriter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPdfWriter.newPage": (),
-    "PySide2.QtGui.QPdfWriter.paintEngine": (),
-    "PySide2.QtGui.QPdfWriter.pdfVersion": (),
-    "PySide2.QtGui.QPdfWriter.resolution": (),
-    "PySide2.QtGui.QPdfWriter.setCreator": ('str',),
-    "PySide2.QtGui.QPdfWriter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtGui.QPdfWriter.setPageSize": ('PySide2.QtGui.QPagedPaintDevice.PageSize',),
-    "PySide2.QtGui.QPdfWriter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QPdfWriter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtGui.QPdfWriter.setResolution": ('int',),
-    "PySide2.QtGui.QPdfWriter.setTitle": ('str',),
-    "PySide2.QtGui.QPdfWriter.title": (),
-# class PySide2.QtGui.QPen:
-    "PySide2.QtGui.QPen.__init__": [(), ('PySide2.QtCore.Qt.PenStyle',), ('PySide2.QtGui.QBrush', 'float', 'PySide2.QtCore.Qt.PenStyle', 'PySide2.QtCore.Qt.PenCapStyle', 'PySide2.QtCore.Qt.PenJoinStyle'), ('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPen',)],
-    "PySide2.QtGui.QPen.__copy__": (),
-    "PySide2.QtGui.QPen.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPen.brush": (),
-    "PySide2.QtGui.QPen.capStyle": (),
-    "PySide2.QtGui.QPen.color": (),
-    "PySide2.QtGui.QPen.dashOffset": (),
-    "PySide2.QtGui.QPen.dashPattern": (),
-    "PySide2.QtGui.QPen.isCosmetic": (),
-    "PySide2.QtGui.QPen.isSolid": (),
-    "PySide2.QtGui.QPen.joinStyle": (),
-    "PySide2.QtGui.QPen.miterLimit": (),
-    "PySide2.QtGui.QPen.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QPen.setCapStyle": ('PySide2.QtCore.Qt.PenCapStyle',),
-    "PySide2.QtGui.QPen.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QPen.setCosmetic": ('bool',),
-    "PySide2.QtGui.QPen.setDashOffset": ('float',),
-    "PySide2.QtGui.QPen.setDashPattern": ('typing.List[float]',),
-    "PySide2.QtGui.QPen.setJoinStyle": ('PySide2.QtCore.Qt.PenJoinStyle',),
-    "PySide2.QtGui.QPen.setMiterLimit": ('float',),
-    "PySide2.QtGui.QPen.setStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtGui.QPen.setWidth": ('int',),
-    "PySide2.QtGui.QPen.setWidthF": ('float',),
-    "PySide2.QtGui.QPen.style": (),
-    "PySide2.QtGui.QPen.swap": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QPen.width": (),
-    "PySide2.QtGui.QPen.widthF": (),
-# class PySide2.QtGui.QPicture:
-    "PySide2.QtGui.QPicture.__init__": [('PySide2.QtGui.QPicture',), ('int',)],
-    "PySide2.QtGui.QPicture.__copy__": (),
-    "PySide2.QtGui.QPicture.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPicture.boundingRect": (),
-    "PySide2.QtGui.QPicture.data": (),
-    "PySide2.QtGui.QPicture.devType": (),
-    "PySide2.QtGui.QPicture.inputFormatList": (),
-    "PySide2.QtGui.QPicture.inputFormats": (),
-    "PySide2.QtGui.QPicture.isNull": (),
-    "PySide2.QtGui.QPicture.load": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPicture.outputFormatList": (),
-    "PySide2.QtGui.QPicture.outputFormats": (),
-    "PySide2.QtGui.QPicture.paintEngine": (),
-    "PySide2.QtGui.QPicture.pictureFormat": ('str',),
-    "PySide2.QtGui.QPicture.play": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtGui.QPicture.save": [('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPicture.setBoundingRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QPicture.setData": ('str', 'int'),
-    "PySide2.QtGui.QPicture.size": (),
-    "PySide2.QtGui.QPicture.swap": ('PySide2.QtGui.QPicture',),
-# class PySide2.QtGui.QPictureIO:
-    "PySide2.QtGui.QPictureIO.__init__": [(), ('PySide2.QtCore.QIODevice', 'str'), ('str', 'str')],
-    "PySide2.QtGui.QPictureIO.description": (),
-    "PySide2.QtGui.QPictureIO.fileName": (),
-    "PySide2.QtGui.QPictureIO.format": (),
-    "PySide2.QtGui.QPictureIO.gamma": (),
-    "PySide2.QtGui.QPictureIO.inputFormats": (),
-    "PySide2.QtGui.QPictureIO.ioDevice": (),
-    "PySide2.QtGui.QPictureIO.outputFormats": (),
-    "PySide2.QtGui.QPictureIO.parameters": (),
-    "PySide2.QtGui.QPictureIO.picture": (),
-    "PySide2.QtGui.QPictureIO.pictureFormat": [('PySide2.QtCore.QIODevice',), ('str',)],
-    "PySide2.QtGui.QPictureIO.quality": (),
-    "PySide2.QtGui.QPictureIO.read": (),
-    "PySide2.QtGui.QPictureIO.setDescription": ('str',),
-    "PySide2.QtGui.QPictureIO.setFileName": ('str',),
-    "PySide2.QtGui.QPictureIO.setFormat": ('str',),
-    "PySide2.QtGui.QPictureIO.setGamma": ('float',),
-    "PySide2.QtGui.QPictureIO.setIODevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QPictureIO.setParameters": ('str',),
-    "PySide2.QtGui.QPictureIO.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtGui.QPictureIO.setQuality": ('int',),
-    "PySide2.QtGui.QPictureIO.setStatus": ('int',),
-    "PySide2.QtGui.QPictureIO.status": (),
-    "PySide2.QtGui.QPictureIO.write": (),
-# class PySide2.QtGui.QPixelFormat:
-# class PySide2.QtGui.QPixelFormat.AlphaPosition:
-# class PySide2.QtGui.QPixelFormat.AlphaPremultiplied:
-# class PySide2.QtGui.QPixelFormat.AlphaUsage:
-# class PySide2.QtGui.QPixelFormat.ByteOrder:
-# class PySide2.QtGui.QPixelFormat.ColorModel:
-# class PySide2.QtGui.QPixelFormat.TypeInterpretation:
-# class PySide2.QtGui.QPixelFormat.YUVLayout:
-    "PySide2.QtGui.QPixelFormat.__init__": [(), ('PySide2.QtGui.QPixelFormat',), ('PySide2.QtGui.QPixelFormat.ColorModel', 'int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QPixelFormat.AlphaUsage', 'PySide2.QtGui.QPixelFormat.AlphaPosition', 'PySide2.QtGui.QPixelFormat.AlphaPremultiplied', 'PySide2.QtGui.QPixelFormat.TypeInterpretation', 'PySide2.QtGui.QPixelFormat.ByteOrder', 'int')],
-    "PySide2.QtGui.QPixelFormat.__copy__": (),
-    "PySide2.QtGui.QPixelFormat.alphaPosition": (),
-    "PySide2.QtGui.QPixelFormat.alphaSize": (),
-    "PySide2.QtGui.QPixelFormat.alphaUsage": (),
-    "PySide2.QtGui.QPixelFormat.bitsPerPixel": (),
-    "PySide2.QtGui.QPixelFormat.blackSize": (),
-    "PySide2.QtGui.QPixelFormat.blueSize": (),
-    "PySide2.QtGui.QPixelFormat.brightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.byteOrder": (),
-    "PySide2.QtGui.QPixelFormat.channelCount": (),
-    "PySide2.QtGui.QPixelFormat.colorModel": (),
-    "PySide2.QtGui.QPixelFormat.cyanSize": (),
-    "PySide2.QtGui.QPixelFormat.greenSize": (),
-    "PySide2.QtGui.QPixelFormat.hueSize": (),
-    "PySide2.QtGui.QPixelFormat.lightnessSize": (),
-    "PySide2.QtGui.QPixelFormat.magentaSize": (),
-    "PySide2.QtGui.QPixelFormat.premultiplied": (),
-    "PySide2.QtGui.QPixelFormat.redSize": (),
-    "PySide2.QtGui.QPixelFormat.saturationSize": (),
-    "PySide2.QtGui.QPixelFormat.subEnum": (),
-    "PySide2.QtGui.QPixelFormat.typeInterpretation": (),
-    "PySide2.QtGui.QPixelFormat.yellowSize": (),
-    "PySide2.QtGui.QPixelFormat.yuvLayout": (),
-# class PySide2.QtGui.QPixmap:
-    "PySide2.QtGui.QPixmap.__init__": [(), ('PySide2.QtCore.QSize',), ('PySide2.QtGui.QImage',), ('PySide2.QtGui.QPixmap',), ('int', 'int'), ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('typing.Sequence[str]',)],
-    "PySide2.QtGui.QPixmap.__copy__": (),
-    "PySide2.QtGui.QPixmap.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPixmap.cacheKey": (),
-    "PySide2.QtGui.QPixmap.convertFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.copy": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.createHeuristicMask": ('bool',),
-    "PySide2.QtGui.QPixmap.createMaskFromColor": ('PySide2.QtGui.QColor', 'PySide2.QtCore.Qt.MaskMode'),
-    "PySide2.QtGui.QPixmap.defaultDepth": (),
-    "PySide2.QtGui.QPixmap.depth": (),
-    "PySide2.QtGui.QPixmap.devType": (),
-    "PySide2.QtGui.QPixmap.devicePixelRatio": (),
-    "PySide2.QtGui.QPixmap.fill": [('PySide2.QtGui.QColor',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint'), ('PySide2.QtGui.QPaintDevice', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.fromImage": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageInPlace": ('PySide2.QtGui.QImage', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.fromImageReader": ('PySide2.QtGui.QImageReader', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.grabWidget": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QObject', 'int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QPixmap.hasAlpha": (),
-    "PySide2.QtGui.QPixmap.hasAlphaChannel": (),
-    "PySide2.QtGui.QPixmap.height": (),
-    "PySide2.QtGui.QPixmap.isNull": (),
-    "PySide2.QtGui.QPixmap.isQBitmap": (),
-    "PySide2.QtGui.QPixmap.load": ('str', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'),
-    "PySide2.QtGui.QPixmap.loadFromData": [('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags'), ('str', 'int', 'str', 'PySide2.QtCore.Qt.ImageConversionFlags')],
-    "PySide2.QtGui.QPixmap.mask": (),
-    "PySide2.QtGui.QPixmap.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QPixmap.paintEngine": (),
-    "PySide2.QtGui.QPixmap.rect": (),
-    "PySide2.QtGui.QPixmap.save": [('PySide2.QtCore.QIODevice', 'str', 'int'), ('str', 'str', 'int')],
-    "PySide2.QtGui.QPixmap.scaled": [('PySide2.QtCore.QSize', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode'), ('int', 'int', 'PySide2.QtCore.Qt.AspectRatioMode', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.scaledToHeight": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scaledToWidth": ('int', 'PySide2.QtCore.Qt.TransformationMode'),
-    "PySide2.QtGui.QPixmap.scroll": [('int', 'int', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion'), ('int', 'int', 'int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion')],
-    "PySide2.QtGui.QPixmap.setDevicePixelRatio": ('float',),
-    "PySide2.QtGui.QPixmap.setMask": ('PySide2.QtGui.QBitmap',),
-    "PySide2.QtGui.QPixmap.size": (),
-    "PySide2.QtGui.QPixmap.swap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtGui.QPixmap.toImage": (),
-    "PySide2.QtGui.QPixmap.transformed": [('PySide2.QtGui.QMatrix', 'PySide2.QtCore.Qt.TransformationMode'), ('PySide2.QtGui.QTransform', 'PySide2.QtCore.Qt.TransformationMode')],
-    "PySide2.QtGui.QPixmap.trueMatrix": [('PySide2.QtGui.QMatrix', 'int', 'int'), ('PySide2.QtGui.QTransform', 'int', 'int')],
-    "PySide2.QtGui.QPixmap.width": (),
-# class PySide2.QtGui.QPixmapCache:
-# class PySide2.QtGui.QPixmapCache.Key:
-    "PySide2.QtGui.QPixmapCache.Key.__init__": [(), ('PySide2.QtGui.QPixmapCache.Key',)],
-    "PySide2.QtGui.QPixmapCache.Key.__copy__": (),
-    "PySide2.QtGui.QPixmapCache.Key.isValid": (),
-    "PySide2.QtGui.QPixmapCache.Key.swap": ('PySide2.QtGui.QPixmapCache.Key',),
-    "PySide2.QtGui.QPixmapCache.__init__": (),
-    "PySide2.QtGui.QPixmapCache.cacheLimit": (),
-    "PySide2.QtGui.QPixmapCache.clear": (),
-    "PySide2.QtGui.QPixmapCache.find": [('PySide2.QtGui.QPixmapCache.Key',), ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'), ('str',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.insert": [('PySide2.QtGui.QPixmap',), ('str', 'PySide2.QtGui.QPixmap')],
-    "PySide2.QtGui.QPixmapCache.remove": [('PySide2.QtGui.QPixmapCache.Key',), ('str',)],
-    "PySide2.QtGui.QPixmapCache.replace": ('PySide2.QtGui.QPixmapCache.Key', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtGui.QPixmapCache.setCacheLimit": ('int',),
-# class PySide2.QtGui.QPointingDeviceUniqueId:
-    "PySide2.QtGui.QPointingDeviceUniqueId.__init__": [(), ('PySide2.QtGui.QPointingDeviceUniqueId',)],
-    "PySide2.QtGui.QPointingDeviceUniqueId.__copy__": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.fromNumericId": ('int',),
-    "PySide2.QtGui.QPointingDeviceUniqueId.isValid": (),
-    "PySide2.QtGui.QPointingDeviceUniqueId.numericId": (),
-# class PySide2.QtGui.QPolygon:
-    "PySide2.QtGui.QPolygon.__init__": [(), ('PySide2.QtCore.QRect', 'bool'), ('PySide2.QtGui.QPolygon',), ('int',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__add__": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.__copy__": (),
-    "PySide2.QtGui.QPolygon.__iadd__": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.__lshift__": [('PySide2.QtCore.QDataStream',), ('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygon.__reduce__": (),
-    "PySide2.QtGui.QPolygon.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygon.append": [('PySide2.QtCore.QPoint',), ('typing.List[PySide2.QtCore.QPoint]',)],
-    "PySide2.QtGui.QPolygon.at": ('int',),
-    "PySide2.QtGui.QPolygon.back": (),
-    "PySide2.QtGui.QPolygon.boundingRect": (),
-    "PySide2.QtGui.QPolygon.capacity": (),
-    "PySide2.QtGui.QPolygon.clear": (),
-    "PySide2.QtGui.QPolygon.constData": (),
-    "PySide2.QtGui.QPolygon.constFirst": (),
-    "PySide2.QtGui.QPolygon.constLast": (),
-    "PySide2.QtGui.QPolygon.contains": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.containsPoint": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygon.count": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtGui.QPolygon.data": (),
-    "PySide2.QtGui.QPolygon.empty": (),
-    "PySide2.QtGui.QPolygon.endsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.fill": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.first": (),
-    "PySide2.QtGui.QPolygon.fromList": ('typing.Sequence[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.front": (),
-    "PySide2.QtGui.QPolygon.indexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.insert": [('int', 'PySide2.QtCore.QPoint'), ('int', 'int', 'PySide2.QtCore.QPoint')],
-    "PySide2.QtGui.QPolygon.intersected": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.intersects": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.isEmpty": (),
-    "PySide2.QtGui.QPolygon.isSharedWith": ('typing.List[PySide2.QtCore.QPoint]',),
-    "PySide2.QtGui.QPolygon.last": (),
-    "PySide2.QtGui.QPolygon.lastIndexOf": ('PySide2.QtCore.QPoint', 'int'),
-    "PySide2.QtGui.QPolygon.length": (),
-    "PySide2.QtGui.QPolygon.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.pop_back": (),
-    "PySide2.QtGui.QPolygon.pop_front": (),
-    "PySide2.QtGui.QPolygon.prepend": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_back": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.push_front": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.removeAll": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.removeAt": ('int',),
-    "PySide2.QtGui.QPolygon.removeFirst": (),
-    "PySide2.QtGui.QPolygon.removeLast": (),
-    "PySide2.QtGui.QPolygon.removeOne": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.replace": ('int', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtGui.QPolygon.reserve": ('int',),
-    "PySide2.QtGui.QPolygon.resize": ('int',),
-    "PySide2.QtGui.QPolygon.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygon.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygon.size": (),
-    "PySide2.QtGui.QPolygon.squeeze": (),
-    "PySide2.QtGui.QPolygon.startsWith": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QPolygon.subtracted": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swap": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygon.takeAt": ('int',),
-    "PySide2.QtGui.QPolygon.takeFirst": (),
-    "PySide2.QtGui.QPolygon.takeLast": (),
-    "PySide2.QtGui.QPolygon.toList": (),
-    "PySide2.QtGui.QPolygon.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QPolygon.united": ('PySide2.QtGui.QPolygon',),
-    "PySide2.QtGui.QPolygon.value": [('int',), ('int', 'PySide2.QtCore.QPoint')],
-# class PySide2.QtGui.QPolygonF:
-    "PySide2.QtGui.QPolygonF.__init__": [(), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('int',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.__add__": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.__copy__": (),
-    "PySide2.QtGui.QPolygonF.__iadd__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QPolygonF.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QPolygonF.append": [('PySide2.QtCore.QPointF',), ('typing.List[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtGui.QPolygonF.at": ('int',),
-    "PySide2.QtGui.QPolygonF.back": (),
-    "PySide2.QtGui.QPolygonF.boundingRect": (),
-    "PySide2.QtGui.QPolygonF.capacity": (),
-    "PySide2.QtGui.QPolygonF.clear": (),
-    "PySide2.QtGui.QPolygonF.constData": (),
-    "PySide2.QtGui.QPolygonF.constFirst": (),
-    "PySide2.QtGui.QPolygonF.constLast": (),
-    "PySide2.QtGui.QPolygonF.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.containsPoint": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.FillRule'),
-    "PySide2.QtGui.QPolygonF.count": [(), ('PySide2.QtCore.QPointF',)],
-    "PySide2.QtGui.QPolygonF.data": (),
-    "PySide2.QtGui.QPolygonF.empty": (),
-    "PySide2.QtGui.QPolygonF.endsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.fill": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.first": (),
-    "PySide2.QtGui.QPolygonF.fromList": ('typing.Sequence[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.front": (),
-    "PySide2.QtGui.QPolygonF.indexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.insert": [('int', 'PySide2.QtCore.QPointF'), ('int', 'int', 'PySide2.QtCore.QPointF')],
-    "PySide2.QtGui.QPolygonF.intersected": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.intersects": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.isClosed": (),
-    "PySide2.QtGui.QPolygonF.isEmpty": (),
-    "PySide2.QtGui.QPolygonF.isSharedWith": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QPolygonF.last": (),
-    "PySide2.QtGui.QPolygonF.lastIndexOf": ('PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtGui.QPolygonF.length": (),
-    "PySide2.QtGui.QPolygonF.mid": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.move": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.pop_back": (),
-    "PySide2.QtGui.QPolygonF.pop_front": (),
-    "PySide2.QtGui.QPolygonF.prepend": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_back": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.push_front": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.remove": [('int',), ('int', 'int')],
-    "PySide2.QtGui.QPolygonF.removeAll": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.removeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.removeFirst": (),
-    "PySide2.QtGui.QPolygonF.removeLast": (),
-    "PySide2.QtGui.QPolygonF.removeOne": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.replace": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtGui.QPolygonF.reserve": ('int',),
-    "PySide2.QtGui.QPolygonF.resize": ('int',),
-    "PySide2.QtGui.QPolygonF.setSharable": ('bool',),
-    "PySide2.QtGui.QPolygonF.shrink_to_fit": (),
-    "PySide2.QtGui.QPolygonF.size": (),
-    "PySide2.QtGui.QPolygonF.squeeze": (),
-    "PySide2.QtGui.QPolygonF.startsWith": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QPolygonF.subtracted": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swap": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.swapItemsAt": ('int', 'int'),
-    "PySide2.QtGui.QPolygonF.takeAt": ('int',),
-    "PySide2.QtGui.QPolygonF.takeFirst": (),
-    "PySide2.QtGui.QPolygonF.takeLast": (),
-    "PySide2.QtGui.QPolygonF.toList": (),
-    "PySide2.QtGui.QPolygonF.toPolygon": (),
-    "PySide2.QtGui.QPolygonF.translate": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.translated": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QPolygonF.united": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtGui.QPolygonF.value": [('int',), ('int', 'PySide2.QtCore.QPointF')],
-# class PySide2.QtGui.QPyTextObject:
-    "PySide2.QtGui.QPyTextObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QPyTextObject.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QPyTextObject.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QQuaternion:
-    "PySide2.QtGui.QQuaternion.__init__": [(), ('PySide2.QtGui.QVector4D',), ('float', 'PySide2.QtGui.QVector3D'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.__add__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__copy__": (),
-    "PySide2.QtGui.QQuaternion.__iadd__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__imul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__isub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__mul__": [('PySide2.QtGui.QQuaternion',), ('float',)],
-    "PySide2.QtGui.QQuaternion.__neg__": (),
-    "PySide2.QtGui.QQuaternion.__reduce__": (),
-    "PySide2.QtGui.QQuaternion.__repr__": (),
-    "PySide2.QtGui.QQuaternion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QQuaternion.__sub__": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtGui.QQuaternion.conjugate": (),
-    "PySide2.QtGui.QQuaternion.conjugated": (),
-    "PySide2.QtGui.QQuaternion.dotProduct": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion'),
-    "PySide2.QtGui.QQuaternion.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromDirection": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.fromRotationMatrix": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.QtGui.QQuaternion.getAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.inverted": (),
-    "PySide2.QtGui.QQuaternion.isIdentity": (),
-    "PySide2.QtGui.QQuaternion.isNull": (),
-    "PySide2.QtGui.QQuaternion.length": (),
-    "PySide2.QtGui.QQuaternion.lengthSquared": (),
-    "PySide2.QtGui.QQuaternion.nlerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.normalize": (),
-    "PySide2.QtGui.QQuaternion.normalized": (),
-    "PySide2.QtGui.QQuaternion.rotatedVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QQuaternion.rotationTo": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QQuaternion.scalar": (),
-    "PySide2.QtGui.QQuaternion.setScalar": ('float',),
-    "PySide2.QtGui.QQuaternion.setVector": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QQuaternion.setX": ('float',),
-    "PySide2.QtGui.QQuaternion.setY": ('float',),
-    "PySide2.QtGui.QQuaternion.setZ": ('float',),
-    "PySide2.QtGui.QQuaternion.slerp": ('PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QQuaternion', 'float'),
-    "PySide2.QtGui.QQuaternion.toEulerAngles": (),
-    "PySide2.QtGui.QQuaternion.toRotationMatrix": (),
-    "PySide2.QtGui.QQuaternion.toVector4D": (),
-    "PySide2.QtGui.QQuaternion.vector": (),
-    "PySide2.QtGui.QQuaternion.x": (),
-    "PySide2.QtGui.QQuaternion.y": (),
-    "PySide2.QtGui.QQuaternion.z": (),
-# class PySide2.QtGui.QRadialGradient:
-    "PySide2.QtGui.QRadialGradient.__init__": [(), ('PySide2.QtCore.QPointF', 'float'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF'), ('PySide2.QtCore.QPointF', 'float', 'PySide2.QtCore.QPointF', 'float'), ('PySide2.QtGui.QRadialGradient',), ('float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QRadialGradient.__copy__": (),
-    "PySide2.QtGui.QRadialGradient.center": (),
-    "PySide2.QtGui.QRadialGradient.centerRadius": (),
-    "PySide2.QtGui.QRadialGradient.focalPoint": (),
-    "PySide2.QtGui.QRadialGradient.focalRadius": (),
-    "PySide2.QtGui.QRadialGradient.radius": (),
-    "PySide2.QtGui.QRadialGradient.setCenter": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setCenterRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setFocalPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtGui.QRadialGradient.setFocalRadius": ('float',),
-    "PySide2.QtGui.QRadialGradient.setRadius": ('float',),
-# class PySide2.QtGui.QRasterWindow:
-    "PySide2.QtGui.QRasterWindow.__init__": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QRasterWindow.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtGui.QRasterWindow.redirected": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtGui.QRawFont:
-# class PySide2.QtGui.QRawFont.AntialiasingType:
-# class PySide2.QtGui.QRawFont.LayoutFlag:
-# class PySide2.QtGui.QRawFont.LayoutFlags:
-    "PySide2.QtGui.QRawFont.__init__": [(), ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'), ('PySide2.QtGui.QRawFont',), ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference')],
-    "PySide2.QtGui.QRawFont.__copy__": (),
-    "PySide2.QtGui.QRawFont.advancesForGlyphIndexes": [('typing.List[int]',), ('typing.List[int]', 'PySide2.QtGui.QRawFont.LayoutFlags')],
-    "PySide2.QtGui.QRawFont.alphaMapForGlyph": ('int', 'PySide2.QtGui.QRawFont.AntialiasingType', 'PySide2.QtGui.QTransform'),
-    "PySide2.QtGui.QRawFont.ascent": (),
-    "PySide2.QtGui.QRawFont.averageCharWidth": (),
-    "PySide2.QtGui.QRawFont.boundingRect": ('int',),
-    "PySide2.QtGui.QRawFont.capHeight": (),
-    "PySide2.QtGui.QRawFont.descent": (),
-    "PySide2.QtGui.QRawFont.familyName": (),
-    "PySide2.QtGui.QRawFont.fontTable": ('str',),
-    "PySide2.QtGui.QRawFont.fromFont": ('PySide2.QtGui.QFont', 'PySide2.QtGui.QFontDatabase.WritingSystem'),
-    "PySide2.QtGui.QRawFont.glyphIndexesForString": ('str',),
-    "PySide2.QtGui.QRawFont.hintingPreference": (),
-    "PySide2.QtGui.QRawFont.isValid": (),
-    "PySide2.QtGui.QRawFont.leading": (),
-    "PySide2.QtGui.QRawFont.lineThickness": (),
-    "PySide2.QtGui.QRawFont.loadFromData": ('PySide2.QtCore.QByteArray', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.loadFromFile": ('str', 'float', 'PySide2.QtGui.QFont.HintingPreference'),
-    "PySide2.QtGui.QRawFont.maxCharWidth": (),
-    "PySide2.QtGui.QRawFont.pathForGlyph": ('int',),
-    "PySide2.QtGui.QRawFont.pixelSize": (),
-    "PySide2.QtGui.QRawFont.setPixelSize": ('float',),
-    "PySide2.QtGui.QRawFont.style": (),
-    "PySide2.QtGui.QRawFont.styleName": (),
-    "PySide2.QtGui.QRawFont.supportedWritingSystems": (),
-    "PySide2.QtGui.QRawFont.supportsCharacter": [('int',), ('str',)],
-    "PySide2.QtGui.QRawFont.swap": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QRawFont.underlinePosition": (),
-    "PySide2.QtGui.QRawFont.unitsPerEm": (),
-    "PySide2.QtGui.QRawFont.weight": (),
-    "PySide2.QtGui.QRawFont.xHeight": (),
-# class PySide2.QtGui.QRegExpValidator:
-    "PySide2.QtGui.QRegExpValidator.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRegExp', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QRegExpValidator.regExp": (),
-    "PySide2.QtGui.QRegExpValidator.setRegExp": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtGui.QRegExpValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QRegion:
-# class PySide2.QtGui.QRegion.RegionType:
-    "PySide2.QtGui.QRegion.__init__": [(), ('PySide2.QtCore.QRect', 'PySide2.QtGui.QRegion.RegionType'), ('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.FillRule'), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int', 'PySide2.QtGui.QRegion.RegionType')],
-    "PySide2.QtGui.QRegion.__add__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__and__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__copy__": (),
-    "PySide2.QtGui.QRegion.__iadd__": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.__ior__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__isub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__ixor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__mul__": [('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',)],
-    "PySide2.QtGui.QRegion.__or__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QRegion.__sub__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.__xor__": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.begin": (),
-    "PySide2.QtGui.QRegion.boundingRect": (),
-    "PySide2.QtGui.QRegion.cbegin": (),
-    "PySide2.QtGui.QRegion.cend": (),
-    "PySide2.QtGui.QRegion.contains": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtGui.QRegion.end": (),
-    "PySide2.QtGui.QRegion.intersected": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.intersects": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.isEmpty": (),
-    "PySide2.QtGui.QRegion.isNull": (),
-    "PySide2.QtGui.QRegion.rectCount": (),
-    "PySide2.QtGui.QRegion.rects": (),
-    "PySide2.QtGui.QRegion.setRects": ('PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtGui.QRegion.subtracted": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.swap": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QRegion.translate": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.translated": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QRegion.united": [('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtGui.QRegion.xored": ('PySide2.QtGui.QRegion',),
-# class PySide2.QtGui.QResizeEvent:
-    "PySide2.QtGui.QResizeEvent.__init__": ('PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtGui.QResizeEvent.oldSize": (),
-    "PySide2.QtGui.QResizeEvent.size": (),
-# class PySide2.QtGui.QScreen:
-    "PySide2.QtGui.QScreen.angleBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation'),
-    "PySide2.QtGui.QScreen.availableGeometry": (),
-    "PySide2.QtGui.QScreen.availableSize": (),
-    "PySide2.QtGui.QScreen.availableVirtualGeometry": (),
-    "PySide2.QtGui.QScreen.availableVirtualSize": (),
-    "PySide2.QtGui.QScreen.depth": (),
-    "PySide2.QtGui.QScreen.devicePixelRatio": (),
-    "PySide2.QtGui.QScreen.geometry": (),
-    "PySide2.QtGui.QScreen.grabWindow": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtGui.QScreen.isLandscape": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.isPortrait": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QScreen.logicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.logicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.manufacturer": (),
-    "PySide2.QtGui.QScreen.mapBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.model": (),
-    "PySide2.QtGui.QScreen.name": (),
-    "PySide2.QtGui.QScreen.nativeOrientation": (),
-    "PySide2.QtGui.QScreen.orientation": (),
-    "PySide2.QtGui.QScreen.orientationUpdateMask": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInch": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchX": (),
-    "PySide2.QtGui.QScreen.physicalDotsPerInchY": (),
-    "PySide2.QtGui.QScreen.physicalSize": (),
-    "PySide2.QtGui.QScreen.primaryOrientation": (),
-    "PySide2.QtGui.QScreen.refreshRate": (),
-    "PySide2.QtGui.QScreen.serialNumber": (),
-    "PySide2.QtGui.QScreen.setOrientationUpdateMask": ('PySide2.QtCore.Qt.ScreenOrientations',),
-    "PySide2.QtGui.QScreen.size": (),
-    "PySide2.QtGui.QScreen.transformBetween": ('PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.Qt.ScreenOrientation', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QScreen.virtualGeometry": (),
-    "PySide2.QtGui.QScreen.virtualSiblings": (),
-    "PySide2.QtGui.QScreen.virtualSize": (),
-# class PySide2.QtGui.QScrollEvent:
-# class PySide2.QtGui.QScrollEvent.ScrollState:
-    "PySide2.QtGui.QScrollEvent.__init__": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QScrollEvent.ScrollState'),
-    "PySide2.QtGui.QScrollEvent.contentPos": (),
-    "PySide2.QtGui.QScrollEvent.overshootDistance": (),
-    "PySide2.QtGui.QScrollEvent.scrollState": (),
-# class PySide2.QtGui.QScrollPrepareEvent:
-    "PySide2.QtGui.QScrollPrepareEvent.__init__": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.contentPosRange": (),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setContentPosRange": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QScrollPrepareEvent.setViewportSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QScrollPrepareEvent.startPos": (),
-    "PySide2.QtGui.QScrollPrepareEvent.viewportSize": (),
-# class PySide2.QtGui.QSessionManager:
-# class PySide2.QtGui.QSessionManager.RestartHint:
-    "PySide2.QtGui.QSessionManager.allowsErrorInteraction": (),
-    "PySide2.QtGui.QSessionManager.allowsInteraction": (),
-    "PySide2.QtGui.QSessionManager.cancel": (),
-    "PySide2.QtGui.QSessionManager.discardCommand": (),
-    "PySide2.QtGui.QSessionManager.isPhase2": (),
-    "PySide2.QtGui.QSessionManager.release": (),
-    "PySide2.QtGui.QSessionManager.requestPhase2": (),
-    "PySide2.QtGui.QSessionManager.restartCommand": (),
-    "PySide2.QtGui.QSessionManager.restartHint": (),
-    "PySide2.QtGui.QSessionManager.sessionId": (),
-    "PySide2.QtGui.QSessionManager.sessionKey": (),
-    "PySide2.QtGui.QSessionManager.setDiscardCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setManagerProperty": [('str', 'str'), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtGui.QSessionManager.setRestartCommand": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QSessionManager.setRestartHint": ('PySide2.QtGui.QSessionManager.RestartHint',),
-# class PySide2.QtGui.QShortcutEvent:
-    "PySide2.QtGui.QShortcutEvent.__init__": ('PySide2.QtGui.QKeySequence', 'int', 'bool'),
-    "PySide2.QtGui.QShortcutEvent.isAmbiguous": (),
-    "PySide2.QtGui.QShortcutEvent.key": (),
-    "PySide2.QtGui.QShortcutEvent.shortcutId": (),
-# class PySide2.QtGui.QShowEvent:
-    "PySide2.QtGui.QShowEvent.__init__": (),
-# class PySide2.QtGui.QStandardItem:
-# class PySide2.QtGui.QStandardItem.ItemType:
-    "PySide2.QtGui.QStandardItem.__init__": [(), ('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QStandardItem',), ('int', 'int'), ('str',)],
-    "PySide2.QtGui.QStandardItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.accessibleDescription": (),
-    "PySide2.QtGui.QStandardItem.accessibleText": (),
-    "PySide2.QtGui.QStandardItem.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItem.appendRows": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItem.background": (),
-    "PySide2.QtGui.QStandardItem.checkState": (),
-    "PySide2.QtGui.QStandardItem.child": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.clearData": (),
-    "PySide2.QtGui.QStandardItem.clone": (),
-    "PySide2.QtGui.QStandardItem.column": (),
-    "PySide2.QtGui.QStandardItem.columnCount": (),
-    "PySide2.QtGui.QStandardItem.data": ('int',),
-    "PySide2.QtGui.QStandardItem.emitDataChanged": (),
-    "PySide2.QtGui.QStandardItem.flags": (),
-    "PySide2.QtGui.QStandardItem.font": (),
-    "PySide2.QtGui.QStandardItem.foreground": (),
-    "PySide2.QtGui.QStandardItem.hasChildren": (),
-    "PySide2.QtGui.QStandardItem.icon": (),
-    "PySide2.QtGui.QStandardItem.index": (),
-    "PySide2.QtGui.QStandardItem.insertColumn": ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]'),
-    "PySide2.QtGui.QStandardItem.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.insertRow": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.insertRows": [('int', 'int'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItem.isAutoTristate": (),
-    "PySide2.QtGui.QStandardItem.isCheckable": (),
-    "PySide2.QtGui.QStandardItem.isDragEnabled": (),
-    "PySide2.QtGui.QStandardItem.isDropEnabled": (),
-    "PySide2.QtGui.QStandardItem.isEditable": (),
-    "PySide2.QtGui.QStandardItem.isEnabled": (),
-    "PySide2.QtGui.QStandardItem.isSelectable": (),
-    "PySide2.QtGui.QStandardItem.isTristate": (),
-    "PySide2.QtGui.QStandardItem.isUserTristate": (),
-    "PySide2.QtGui.QStandardItem.model": (),
-    "PySide2.QtGui.QStandardItem.parent": (),
-    "PySide2.QtGui.QStandardItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QStandardItem.removeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.removeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.row": (),
-    "PySide2.QtGui.QStandardItem.rowCount": (),
-    "PySide2.QtGui.QStandardItem.setAccessibleDescription": ('str',),
-    "PySide2.QtGui.QStandardItem.setAccessibleText": ('str',),
-    "PySide2.QtGui.QStandardItem.setAutoTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtGui.QStandardItem.setCheckable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setChild": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItem.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setData": ('typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItem.setDragEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setDropEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEditable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setEnabled": ('bool',),
-    "PySide2.QtGui.QStandardItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtGui.QStandardItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QStandardItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QStandardItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QStandardItem.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItem.setSelectable": ('bool',),
-    "PySide2.QtGui.QStandardItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QStandardItem.setStatusTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setText": ('str',),
-    "PySide2.QtGui.QStandardItem.setTextAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QStandardItem.setToolTip": ('str',),
-    "PySide2.QtGui.QStandardItem.setTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setUserTristate": ('bool',),
-    "PySide2.QtGui.QStandardItem.setWhatsThis": ('str',),
-    "PySide2.QtGui.QStandardItem.sizeHint": (),
-    "PySide2.QtGui.QStandardItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItem.statusTip": (),
-    "PySide2.QtGui.QStandardItem.takeChild": ('int', 'int'),
-    "PySide2.QtGui.QStandardItem.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItem.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItem.text": (),
-    "PySide2.QtGui.QStandardItem.textAlignment": (),
-    "PySide2.QtGui.QStandardItem.toolTip": (),
-    "PySide2.QtGui.QStandardItem.type": (),
-    "PySide2.QtGui.QStandardItem.whatsThis": (),
-    "PySide2.QtGui.QStandardItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtGui.QStandardItemModel:
-    "PySide2.QtGui.QStandardItemModel.__init__": [('PySide2.QtCore.QObject',), ('int', 'int', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QStandardItemModel.appendColumn": ('typing.Sequence[PySide2.QtGui.QStandardItem]',),
-    "PySide2.QtGui.QStandardItemModel.appendRow": [('PySide2.QtGui.QStandardItem',), ('typing.Sequence[PySide2.QtGui.QStandardItem]',)],
-    "PySide2.QtGui.QStandardItemModel.clear": (),
-    "PySide2.QtGui.QStandardItemModel.clearItemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtGui.QStandardItemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtGui.QStandardItemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtGui.QStandardItemModel.horizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.indexFromItem": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.insertColumn": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.insertRow": [('int', 'PySide2.QtCore.QModelIndex'), ('int', 'PySide2.QtGui.QStandardItem'), ('int', 'typing.Sequence[PySide2.QtGui.QStandardItem]')],
-    "PySide2.QtGui.QStandardItemModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.invisibleRootItem": (),
-    "PySide2.QtGui.QStandardItemModel.item": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.itemData": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.itemPrototype": (),
-    "PySide2.QtGui.QStandardItemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtGui.QStandardItemModel.mimeTypes": (),
-    "PySide2.QtGui.QStandardItemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtGui.QStandardItemModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtGui.QStandardItemModel.setColumnCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.setItem": [('int', 'PySide2.QtGui.QStandardItem'), ('int', 'int', 'PySide2.QtGui.QStandardItem')],
-    "PySide2.QtGui.QStandardItemModel.setItemData": ('PySide2.QtCore.QModelIndex', 'typing.Dict[int, typing.Any]'),
-    "PySide2.QtGui.QStandardItemModel.setItemPrototype": ('PySide2.QtGui.QStandardItem',),
-    "PySide2.QtGui.QStandardItemModel.setItemRoleNames": ('typing.Dict[int, PySide2.QtCore.QByteArray]',),
-    "PySide2.QtGui.QStandardItemModel.setRowCount": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setSortRole": ('int',),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderItem": ('int', 'PySide2.QtGui.QStandardItem'),
-    "PySide2.QtGui.QStandardItemModel.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QStandardItemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtGui.QStandardItemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtGui.QStandardItemModel.sortRole": (),
-    "PySide2.QtGui.QStandardItemModel.supportedDropActions": (),
-    "PySide2.QtGui.QStandardItemModel.takeColumn": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeItem": ('int', 'int'),
-    "PySide2.QtGui.QStandardItemModel.takeRow": ('int',),
-    "PySide2.QtGui.QStandardItemModel.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtGui.QStandardItemModel.verticalHeaderItem": ('int',),
-# class PySide2.QtGui.QStaticText:
-# class PySide2.QtGui.QStaticText.PerformanceHint:
-    "PySide2.QtGui.QStaticText.__init__": [(), ('PySide2.QtGui.QStaticText',), ('str',)],
-    "PySide2.QtGui.QStaticText.__copy__": (),
-    "PySide2.QtGui.QStaticText.performanceHint": (),
-    "PySide2.QtGui.QStaticText.prepare": ('PySide2.QtGui.QTransform', 'PySide2.QtGui.QFont'),
-    "PySide2.QtGui.QStaticText.setPerformanceHint": ('PySide2.QtGui.QStaticText.PerformanceHint',),
-    "PySide2.QtGui.QStaticText.setText": ('str',),
-    "PySide2.QtGui.QStaticText.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtGui.QStaticText.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QStaticText.setTextWidth": ('float',),
-    "PySide2.QtGui.QStaticText.size": (),
-    "PySide2.QtGui.QStaticText.swap": ('PySide2.QtGui.QStaticText',),
-    "PySide2.QtGui.QStaticText.text": (),
-    "PySide2.QtGui.QStaticText.textFormat": (),
-    "PySide2.QtGui.QStaticText.textOption": (),
-    "PySide2.QtGui.QStaticText.textWidth": (),
-# class PySide2.QtGui.QStatusTipEvent:
-    "PySide2.QtGui.QStatusTipEvent.__init__": ('str',),
-    "PySide2.QtGui.QStatusTipEvent.tip": (),
-# class PySide2.QtGui.QStyleHints:
-    "PySide2.QtGui.QStyleHints.cursorFlashTime": (),
-    "PySide2.QtGui.QStyleHints.fontSmoothingGamma": (),
-    "PySide2.QtGui.QStyleHints.keyboardAutoRepeatRate": (),
-    "PySide2.QtGui.QStyleHints.keyboardInputInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickDistance": (),
-    "PySide2.QtGui.QStyleHints.mouseDoubleClickInterval": (),
-    "PySide2.QtGui.QStyleHints.mousePressAndHoldInterval": (),
-    "PySide2.QtGui.QStyleHints.mouseQuickSelectionThreshold": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskCharacter": (),
-    "PySide2.QtGui.QStyleHints.passwordMaskDelay": (),
-    "PySide2.QtGui.QStyleHints.setCursorFlashTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setFocusOnTouchRelease": (),
-    "PySide2.QtGui.QStyleHints.setKeyboardInputInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseDoubleClickInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMousePressAndHoldInterval": ('int',),
-    "PySide2.QtGui.QStyleHints.setMouseQuickSelectionThreshold": ('int',),
-    "PySide2.QtGui.QStyleHints.setShowShortcutsInContextMenus": ('bool',),
-    "PySide2.QtGui.QStyleHints.setStartDragDistance": ('int',),
-    "PySide2.QtGui.QStyleHints.setStartDragTime": ('int',),
-    "PySide2.QtGui.QStyleHints.setTabFocusBehavior": ('PySide2.QtCore.Qt.TabFocusBehavior',),
-    "PySide2.QtGui.QStyleHints.setUseHoverEffects": ('bool',),
-    "PySide2.QtGui.QStyleHints.setWheelScrollLines": ('int',),
-    "PySide2.QtGui.QStyleHints.showIsFullScreen": (),
-    "PySide2.QtGui.QStyleHints.showIsMaximized": (),
-    "PySide2.QtGui.QStyleHints.showShortcutsInContextMenus": (),
-    "PySide2.QtGui.QStyleHints.singleClickActivation": (),
-    "PySide2.QtGui.QStyleHints.startDragDistance": (),
-    "PySide2.QtGui.QStyleHints.startDragTime": (),
-    "PySide2.QtGui.QStyleHints.startDragVelocity": (),
-    "PySide2.QtGui.QStyleHints.tabFocusBehavior": (),
-    "PySide2.QtGui.QStyleHints.touchDoubleTapDistance": (),
-    "PySide2.QtGui.QStyleHints.useHoverEffects": (),
-    "PySide2.QtGui.QStyleHints.useRtlExtensions": (),
-    "PySide2.QtGui.QStyleHints.wheelScrollLines": (),
-# class PySide2.QtGui.QSurface:
-# class PySide2.QtGui.QSurface.SurfaceClass:
-# class PySide2.QtGui.QSurface.SurfaceType:
-    "PySide2.QtGui.QSurface.__init__": ('PySide2.QtGui.QSurface.SurfaceClass',),
-    "PySide2.QtGui.QSurface.format": (),
-    "PySide2.QtGui.QSurface.size": (),
-    "PySide2.QtGui.QSurface.supportsOpenGL": (),
-    "PySide2.QtGui.QSurface.surfaceClass": (),
-    "PySide2.QtGui.QSurface.surfaceHandle": (),
-    "PySide2.QtGui.QSurface.surfaceType": (),
-# class PySide2.QtGui.QSurfaceFormat:
-# class PySide2.QtGui.QSurfaceFormat.ColorSpace:
-# class PySide2.QtGui.QSurfaceFormat.FormatOption:
-# class PySide2.QtGui.QSurfaceFormat.FormatOptions:
-# class PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile:
-# class PySide2.QtGui.QSurfaceFormat.RenderableType:
-# class PySide2.QtGui.QSurfaceFormat.SwapBehavior:
-    "PySide2.QtGui.QSurfaceFormat.__init__": [(), ('PySide2.QtGui.QSurfaceFormat',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.__copy__": (),
-    "PySide2.QtGui.QSurfaceFormat.alphaBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.blueBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.colorSpace": (),
-    "PySide2.QtGui.QSurfaceFormat.defaultFormat": (),
-    "PySide2.QtGui.QSurfaceFormat.depthBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.greenBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.hasAlpha": (),
-    "PySide2.QtGui.QSurfaceFormat.majorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.minorVersion": (),
-    "PySide2.QtGui.QSurfaceFormat.options": (),
-    "PySide2.QtGui.QSurfaceFormat.profile": (),
-    "PySide2.QtGui.QSurfaceFormat.redBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.renderableType": (),
-    "PySide2.QtGui.QSurfaceFormat.samples": (),
-    "PySide2.QtGui.QSurfaceFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setColorSpace": ('PySide2.QtGui.QSurfaceFormat.ColorSpace',),
-    "PySide2.QtGui.QSurfaceFormat.setDefaultFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QSurfaceFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMajorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setMinorVersion": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption', 'bool'), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.setOptions": ('PySide2.QtGui.QSurfaceFormat.FormatOptions',),
-    "PySide2.QtGui.QSurfaceFormat.setProfile": ('PySide2.QtGui.QSurfaceFormat.OpenGLContextProfile',),
-    "PySide2.QtGui.QSurfaceFormat.setRedBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setRenderableType": ('PySide2.QtGui.QSurfaceFormat.RenderableType',),
-    "PySide2.QtGui.QSurfaceFormat.setSamples": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setStereo": ('bool',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapBehavior": ('PySide2.QtGui.QSurfaceFormat.SwapBehavior',),
-    "PySide2.QtGui.QSurfaceFormat.setSwapInterval": ('int',),
-    "PySide2.QtGui.QSurfaceFormat.setVersion": ('int', 'int'),
-    "PySide2.QtGui.QSurfaceFormat.stencilBufferSize": (),
-    "PySide2.QtGui.QSurfaceFormat.stereo": (),
-    "PySide2.QtGui.QSurfaceFormat.swapBehavior": (),
-    "PySide2.QtGui.QSurfaceFormat.swapInterval": (),
-    "PySide2.QtGui.QSurfaceFormat.testOption": [('PySide2.QtGui.QSurfaceFormat.FormatOption',), ('PySide2.QtGui.QSurfaceFormat.FormatOptions',)],
-    "PySide2.QtGui.QSurfaceFormat.version": (),
-# class PySide2.QtGui.QSyntaxHighlighter:
-    "PySide2.QtGui.QSyntaxHighlighter.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QTextDocument',)],
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlock": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.currentBlockUserData": (),
-    "PySide2.QtGui.QSyntaxHighlighter.document": (),
-    "PySide2.QtGui.QSyntaxHighlighter.format": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.highlightBlock": ('str',),
-    "PySide2.QtGui.QSyntaxHighlighter.previousBlockState": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlight": (),
-    "PySide2.QtGui.QSyntaxHighlighter.rehighlightBlock": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockState": ('int',),
-    "PySide2.QtGui.QSyntaxHighlighter.setCurrentBlockUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QSyntaxHighlighter.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QSyntaxHighlighter.setFormat": [('int', 'int', 'PySide2.QtGui.QColor'), ('int', 'int', 'PySide2.QtGui.QFont'), ('int', 'int', 'PySide2.QtGui.QTextCharFormat')],
-# class PySide2.QtGui.QTabletEvent:
-# class PySide2.QtGui.QTabletEvent.PointerType:
-# class PySide2.QtGui.QTabletEvent.TabletDevice:
-    "PySide2.QtGui.QTabletEvent.__init__": [('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'int', 'float', 'int', 'int', 'float', 'float', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.MouseButtons')],
-    "PySide2.QtGui.QTabletEvent.button": (),
-    "PySide2.QtGui.QTabletEvent.buttons": (),
-    "PySide2.QtGui.QTabletEvent.device": (),
-    "PySide2.QtGui.QTabletEvent.globalPos": (),
-    "PySide2.QtGui.QTabletEvent.globalPosF": (),
-    "PySide2.QtGui.QTabletEvent.globalX": (),
-    "PySide2.QtGui.QTabletEvent.global""Y": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobalX": (),
-    "PySide2.QtGui.QTabletEvent.hiResGlobal""Y": (),
-    "PySide2.QtGui.QTabletEvent.pointerType": (),
-    "PySide2.QtGui.QTabletEvent.pos": (),
-    "PySide2.QtGui.QTabletEvent.posF": (),
-    "PySide2.QtGui.QTabletEvent.pressure": (),
-    "PySide2.QtGui.QTabletEvent.rotation": (),
-    "PySide2.QtGui.QTabletEvent.tangentialPressure": (),
-    "PySide2.QtGui.QTabletEvent.uniqueId": (),
-    "PySide2.QtGui.QTabletEvent.x": (),
-    "PySide2.QtGui.QTabletEvent.xTilt": (),
-    "PySide2.QtGui.QTabletEvent.y": (),
-    "PySide2.QtGui.QTabletEvent.yTilt": (),
-    "PySide2.QtGui.QTabletEvent.z": (),
-# class PySide2.QtGui.QTextBlock:
-# class PySide2.QtGui.QTextBlock.iterator:
-    "PySide2.QtGui.QTextBlock.iterator.__init__": [(), ('PySide2.QtGui.QTextBlock.iterator',)],
-    "PySide2.QtGui.QTextBlock.iterator.__copy__": (),
-    "PySide2.QtGui.QTextBlock.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextBlock.iterator.__iter__": (),
-    "PySide2.QtGui.QTextBlock.iterator.atEnd": (),
-    "PySide2.QtGui.QTextBlock.iterator.fragment": (),
-    "PySide2.QtGui.QTextBlock.__init__": [(), ('PySide2.QtGui.QTextBlock',)],
-    "PySide2.QtGui.QTextBlock.__copy__": (),
-    "PySide2.QtGui.QTextBlock.__iter__": (),
-    "PySide2.QtGui.QTextBlock.begin": (),
-    "PySide2.QtGui.QTextBlock.blockFormat": (),
-    "PySide2.QtGui.QTextBlock.blockFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.blockNumber": (),
-    "PySide2.QtGui.QTextBlock.charFormat": (),
-    "PySide2.QtGui.QTextBlock.charFormatIndex": (),
-    "PySide2.QtGui.QTextBlock.clearLayout": (),
-    "PySide2.QtGui.QTextBlock.contains": ('int',),
-    "PySide2.QtGui.QTextBlock.document": (),
-    "PySide2.QtGui.QTextBlock.end": (),
-    "PySide2.QtGui.QTextBlock.firstLineNumber": (),
-    "PySide2.QtGui.QTextBlock.fragmentIndex": (),
-    "PySide2.QtGui.QTextBlock.isValid": (),
-    "PySide2.QtGui.QTextBlock.isVisible": (),
-    "PySide2.QtGui.QTextBlock.layout": (),
-    "PySide2.QtGui.QTextBlock.length": (),
-    "PySide2.QtGui.QTextBlock.lineCount": (),
-    "PySide2.QtGui.QTextBlock.position": (),
-    "PySide2.QtGui.QTextBlock.previous": (),
-    "PySide2.QtGui.QTextBlock.revision": (),
-    "PySide2.QtGui.QTextBlock.setLineCount": ('int',),
-    "PySide2.QtGui.QTextBlock.setRevision": ('int',),
-    "PySide2.QtGui.QTextBlock.setUserData": ('PySide2.QtGui.QTextBlockUserData',),
-    "PySide2.QtGui.QTextBlock.setUserState": ('int',),
-    "PySide2.QtGui.QTextBlock.setVisible": ('bool',),
-    "PySide2.QtGui.QTextBlock.text": (),
-    "PySide2.QtGui.QTextBlock.textDirection": (),
-    "PySide2.QtGui.QTextBlock.textFormats": (),
-    "PySide2.QtGui.QTextBlock.textList": (),
-    "PySide2.QtGui.QTextBlock.userData": (),
-    "PySide2.QtGui.QTextBlock.userState": (),
-# class PySide2.QtGui.QTextBlockFormat:
-# class PySide2.QtGui.QTextBlockFormat.LineHeightTypes:
-# class PySide2.QtGui.QTextBlockFormat.MarkerType:
-    "PySide2.QtGui.QTextBlockFormat.__init__": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextBlockFormat.__copy__": (),
-    "PySide2.QtGui.QTextBlockFormat.alignment": (),
-    "PySide2.QtGui.QTextBlockFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.headingLevel": (),
-    "PySide2.QtGui.QTextBlockFormat.indent": (),
-    "PySide2.QtGui.QTextBlockFormat.isValid": (),
-    "PySide2.QtGui.QTextBlockFormat.leftMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.lineHeight": [(), ('float', 'float')],
-    "PySide2.QtGui.QTextBlockFormat.lineHeightType": (),
-    "PySide2.QtGui.QTextBlockFormat.marker": (),
-    "PySide2.QtGui.QTextBlockFormat.nonBreakableLines": (),
-    "PySide2.QtGui.QTextBlockFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextBlockFormat.rightMargin": (),
-    "PySide2.QtGui.QTextBlockFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextBlockFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setHeadingLevel": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextBlockFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setLineHeight": ('float', 'int'),
-    "PySide2.QtGui.QTextBlockFormat.setMarker": ('PySide2.QtGui.QTextBlockFormat.MarkerType',),
-    "PySide2.QtGui.QTextBlockFormat.setNonBreakableLines": ('bool',),
-    "PySide2.QtGui.QTextBlockFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextBlockFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTabPositions": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextBlockFormat.setTextIndent": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextBlockFormat.tabPositions": (),
-    "PySide2.QtGui.QTextBlockFormat.textIndent": (),
-    "PySide2.QtGui.QTextBlockFormat.topMargin": (),
-# class PySide2.QtGui.QTextBlockGroup:
-    "PySide2.QtGui.QTextBlockGroup.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextBlockGroup.blockFormatChanged": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockInserted": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextBlockGroup.blockList": (),
-    "PySide2.QtGui.QTextBlockGroup.blockRemoved": ('PySide2.QtGui.QTextBlock',),
-# class PySide2.QtGui.QTextBlockUserData:
-    "PySide2.QtGui.QTextBlockUserData.__init__": (),
-# class PySide2.QtGui.QTextCharFormat:
-# class PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior:
-# class PySide2.QtGui.QTextCharFormat.UnderlineStyle:
-# class PySide2.QtGui.QTextCharFormat.VerticalAlignment:
-    "PySide2.QtGui.QTextCharFormat.__init__": [(), ('PySide2.QtGui.QTextCharFormat',), ('PySide2.QtGui.QTextFormat',)],
-    "PySide2.QtGui.QTextCharFormat.__copy__": (),
-    "PySide2.QtGui.QTextCharFormat.anchorHref": (),
-    "PySide2.QtGui.QTextCharFormat.anchorName": (),
-    "PySide2.QtGui.QTextCharFormat.anchorNames": (),
-    "PySide2.QtGui.QTextCharFormat.font": (),
-    "PySide2.QtGui.QTextCharFormat.fontCapitalization": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamilies": (),
-    "PySide2.QtGui.QTextCharFormat.fontFamily": (),
-    "PySide2.QtGui.QTextCharFormat.fontFixedPitch": (),
-    "PySide2.QtGui.QTextCharFormat.fontHintingPreference": (),
-    "PySide2.QtGui.QTextCharFormat.fontItalic": (),
-    "PySide2.QtGui.QTextCharFormat.fontKerning": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.fontLetterSpacingType": (),
-    "PySide2.QtGui.QTextCharFormat.fontOverline": (),
-    "PySide2.QtGui.QTextCharFormat.fontPointSize": (),
-    "PySide2.QtGui.QTextCharFormat.fontStretch": (),
-    "PySide2.QtGui.QTextCharFormat.fontStrikeOut": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleHint": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleName": (),
-    "PySide2.QtGui.QTextCharFormat.fontStyleStrategy": (),
-    "PySide2.QtGui.QTextCharFormat.fontUnderline": (),
-    "PySide2.QtGui.QTextCharFormat.fontWeight": (),
-    "PySide2.QtGui.QTextCharFormat.fontWordSpacing": (),
-    "PySide2.QtGui.QTextCharFormat.isAnchor": (),
-    "PySide2.QtGui.QTextCharFormat.isValid": (),
-    "PySide2.QtGui.QTextCharFormat.setAnchor": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorHref": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setAnchorNames": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'PySide2.QtGui.QTextCharFormat.FontPropertiesInheritanceBehavior')],
-    "PySide2.QtGui.QTextCharFormat.setFontCapitalization": ('PySide2.QtGui.QFont.Capitalization',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamilies": ('typing.Sequence[str]',),
-    "PySide2.QtGui.QTextCharFormat.setFontFamily": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontFixedPitch": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontHintingPreference": ('PySide2.QtGui.QFont.HintingPreference',),
-    "PySide2.QtGui.QTextCharFormat.setFontItalic": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontKerning": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontLetterSpacingType": ('PySide2.QtGui.QFont.SpacingType',),
-    "PySide2.QtGui.QTextCharFormat.setFontOverline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontPointSize": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setFontStretch": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontStrikeOut": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleHint": ('PySide2.QtGui.QFont.StyleHint', 'PySide2.QtGui.QFont.StyleStrategy'),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleName": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setFontStyleStrategy": ('PySide2.QtGui.QFont.StyleStrategy',),
-    "PySide2.QtGui.QTextCharFormat.setFontUnderline": ('bool',),
-    "PySide2.QtGui.QTextCharFormat.setFontWeight": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setFontWordSpacing": ('float',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellColumnSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTableCellRowSpan": ('int',),
-    "PySide2.QtGui.QTextCharFormat.setTextOutline": ('PySide2.QtGui.QPen',),
-    "PySide2.QtGui.QTextCharFormat.setToolTip": ('str',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtGui.QTextCharFormat.setUnderlineStyle": ('PySide2.QtGui.QTextCharFormat.UnderlineStyle',),
-    "PySide2.QtGui.QTextCharFormat.setVerticalAlignment": ('PySide2.QtGui.QTextCharFormat.VerticalAlignment',),
-    "PySide2.QtGui.QTextCharFormat.tableCellColumnSpan": (),
-    "PySide2.QtGui.QTextCharFormat.tableCellRowSpan": (),
-    "PySide2.QtGui.QTextCharFormat.textOutline": (),
-    "PySide2.QtGui.QTextCharFormat.toolTip": (),
-    "PySide2.QtGui.QTextCharFormat.underlineColor": (),
-    "PySide2.QtGui.QTextCharFormat.underlineStyle": (),
-    "PySide2.QtGui.QTextCharFormat.verticalAlignment": (),
-# class PySide2.QtGui.QTextCursor:
-# class PySide2.QtGui.QTextCursor.MoveMode:
-# class PySide2.QtGui.QTextCursor.MoveOperation:
-# class PySide2.QtGui.QTextCursor.SelectionType:
-    "PySide2.QtGui.QTextCursor.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextFrame',)],
-    "PySide2.QtGui.QTextCursor.__copy__": (),
-    "PySide2.QtGui.QTextCursor.anchor": (),
-    "PySide2.QtGui.QTextCursor.atBlockEnd": (),
-    "PySide2.QtGui.QTextCursor.atBlockStart": (),
-    "PySide2.QtGui.QTextCursor.atEnd": (),
-    "PySide2.QtGui.QTextCursor.atStart": (),
-    "PySide2.QtGui.QTextCursor.beginEditBlock": (),
-    "PySide2.QtGui.QTextCursor.block": (),
-    "PySide2.QtGui.QTextCursor.blockCharFormat": (),
-    "PySide2.QtGui.QTextCursor.blockFormat": (),
-    "PySide2.QtGui.QTextCursor.blockNumber": (),
-    "PySide2.QtGui.QTextCursor.charFormat": (),
-    "PySide2.QtGui.QTextCursor.clearSelection": (),
-    "PySide2.QtGui.QTextCursor.columnNumber": (),
-    "PySide2.QtGui.QTextCursor.createList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.currentFrame": (),
-    "PySide2.QtGui.QTextCursor.currentList": (),
-    "PySide2.QtGui.QTextCursor.currentTable": (),
-    "PySide2.QtGui.QTextCursor.deleteChar": (),
-    "PySide2.QtGui.QTextCursor.deletePreviousChar": (),
-    "PySide2.QtGui.QTextCursor.document": (),
-    "PySide2.QtGui.QTextCursor.endEditBlock": (),
-    "PySide2.QtGui.QTextCursor.hasComplexSelection": (),
-    "PySide2.QtGui.QTextCursor.hasSelection": (),
-    "PySide2.QtGui.QTextCursor.insertBlock": [(), ('PySide2.QtGui.QTextBlockFormat',), ('PySide2.QtGui.QTextBlockFormat', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.insertFragment": ('PySide2.QtGui.QTextDocumentFragment',),
-    "PySide2.QtGui.QTextCursor.insertFrame": ('PySide2.QtGui.QTextFrameFormat',),
-    "PySide2.QtGui.QTextCursor.insertHtml": ('str',),
-    "PySide2.QtGui.QTextCursor.insertImage": [('PySide2.QtGui.QImage', 'str'), ('PySide2.QtGui.QTextImageFormat',), ('PySide2.QtGui.QTextImageFormat', 'PySide2.QtGui.QTextFrameFormat.Position'), ('str',)],
-    "PySide2.QtGui.QTextCursor.insertList": [('PySide2.QtGui.QTextListFormat',), ('PySide2.QtGui.QTextListFormat.Style',)],
-    "PySide2.QtGui.QTextCursor.insertTable": [('int', 'int'), ('int', 'int', 'PySide2.QtGui.QTextTableFormat')],
-    "PySide2.QtGui.QTextCursor.insertText": [('str',), ('str', 'PySide2.QtGui.QTextCharFormat')],
-    "PySide2.QtGui.QTextCursor.isCopyOf": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.isNull": (),
-    "PySide2.QtGui.QTextCursor.joinPreviousEditBlock": (),
-    "PySide2.QtGui.QTextCursor.keepPositionOnInsert": (),
-    "PySide2.QtGui.QTextCursor.mergeBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.mergeBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.mergeCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.movePosition": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode', 'int'),
-    "PySide2.QtGui.QTextCursor.position": (),
-    "PySide2.QtGui.QTextCursor.positionInBlock": (),
-    "PySide2.QtGui.QTextCursor.removeSelectedText": (),
-    "PySide2.QtGui.QTextCursor.select": ('PySide2.QtGui.QTextCursor.SelectionType',),
-    "PySide2.QtGui.QTextCursor.selectedTableCells": (),
-    "PySide2.QtGui.QTextCursor.selectedText": (),
-    "PySide2.QtGui.QTextCursor.selection": (),
-    "PySide2.QtGui.QTextCursor.selectionEnd": (),
-    "PySide2.QtGui.QTextCursor.selectionStart": (),
-    "PySide2.QtGui.QTextCursor.setBlockCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setBlockFormat": ('PySide2.QtGui.QTextBlockFormat',),
-    "PySide2.QtGui.QTextCursor.setCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextCursor.setKeepPositionOnInsert": ('bool',),
-    "PySide2.QtGui.QTextCursor.setPosition": ('int', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtGui.QTextCursor.setVerticalMovementX": ('int',),
-    "PySide2.QtGui.QTextCursor.setVisualNavigation": ('bool',),
-    "PySide2.QtGui.QTextCursor.swap": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextCursor.verticalMovementX": (),
-    "PySide2.QtGui.QTextCursor.visualNavigation": (),
-# class PySide2.QtGui.QTextDocument:
-# class PySide2.QtGui.QTextDocument.FindFlag:
-# class PySide2.QtGui.QTextDocument.FindFlags:
-# class PySide2.QtGui.QTextDocument.MarkdownFeature:
-# class PySide2.QtGui.QTextDocument.MarkdownFeatures:
-# class PySide2.QtGui.QTextDocument.MetaInformation:
-# class PySide2.QtGui.QTextDocument.ResourceType:
-# class PySide2.QtGui.QTextDocument.Stacks:
-    "PySide2.QtGui.QTextDocument.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtGui.QTextDocument.addResource": ('int', 'PySide2.QtCore.QUrl', 'typing.Any'),
-    "PySide2.QtGui.QTextDocument.adjustSize": (),
-    "PySide2.QtGui.QTextDocument.allFormats": (),
-    "PySide2.QtGui.QTextDocument.availableRedoSteps": (),
-    "PySide2.QtGui.QTextDocument.availableUndoSteps": (),
-    "PySide2.QtGui.QTextDocument.baseUrl": (),
-    "PySide2.QtGui.QTextDocument.begin": (),
-    "PySide2.QtGui.QTextDocument.blockCount": (),
-    "PySide2.QtGui.QTextDocument.characterAt": ('int',),
-    "PySide2.QtGui.QTextDocument.characterCount": (),
-    "PySide2.QtGui.QTextDocument.clear": (),
-    "PySide2.QtGui.QTextDocument.clearUndoRedoStacks": ('PySide2.QtGui.QTextDocument.Stacks',),
-    "PySide2.QtGui.QTextDocument.clone": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTextDocument.createObject": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.defaultCursorMoveStyle": (),
-    "PySide2.QtGui.QTextDocument.defaultFont": (),
-    "PySide2.QtGui.QTextDocument.defaultStyleSheet": (),
-    "PySide2.QtGui.QTextDocument.defaultTextOption": (),
-    "PySide2.QtGui.QTextDocument.documentLayout": (),
-    "PySide2.QtGui.QTextDocument.documentMargin": (),
-    "PySide2.QtGui.QTextDocument.drawContents": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextDocument.end": (),
-    "PySide2.QtGui.QTextDocument.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegExp', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'int', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextCursor', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'int', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtGui.QTextDocument.findBlock": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByLineNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.findBlockByNumber": ('int',),
-    "PySide2.QtGui.QTextDocument.firstBlock": (),
-    "PySide2.QtGui.QTextDocument.frameAt": ('int',),
-    "PySide2.QtGui.QTextDocument.idealWidth": (),
-    "PySide2.QtGui.QTextDocument.indentWidth": (),
-    "PySide2.QtGui.QTextDocument.isEmpty": (),
-    "PySide2.QtGui.QTextDocument.isModified": (),
-    "PySide2.QtGui.QTextDocument.isRedoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoAvailable": (),
-    "PySide2.QtGui.QTextDocument.isUndoRedoEnabled": (),
-    "PySide2.QtGui.QTextDocument.lastBlock": (),
-    "PySide2.QtGui.QTextDocument.lineCount": (),
-    "PySide2.QtGui.QTextDocument.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.markContentsDirty": ('int', 'int'),
-    "PySide2.QtGui.QTextDocument.maximumBlockCount": (),
-    "PySide2.QtGui.QTextDocument.metaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation',),
-    "PySide2.QtGui.QTextDocument.object": ('int',),
-    "PySide2.QtGui.QTextDocument.objectForFormat": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextDocument.pageCount": (),
-    "PySide2.QtGui.QTextDocument.pageSize": (),
-    "PySide2.QtGui.QTextDocument.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtGui.QTextDocument.redo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.resource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtGui.QTextDocument.revision": (),
-    "PySide2.QtGui.QTextDocument.rootFrame": (),
-    "PySide2.QtGui.QTextDocument.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtGui.QTextDocument.setDefaultCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextDocument.setDefaultFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextDocument.setDefaultStyleSheet": ('str',),
-    "PySide2.QtGui.QTextDocument.setDefaultTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextDocument.setDocumentLayout": ('PySide2.QtGui.QAbstractTextDocumentLayout',),
-    "PySide2.QtGui.QTextDocument.setDocumentMargin": ('float',),
-    "PySide2.QtGui.QTextDocument.setHtml": ('str',),
-    "PySide2.QtGui.QTextDocument.setIndentWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setMarkdown": ('str', 'PySide2.QtGui.QTextDocument.MarkdownFeatures'),
-    "PySide2.QtGui.QTextDocument.setMaximumBlockCount": ('int',),
-    "PySide2.QtGui.QTextDocument.setMetaInformation": ('PySide2.QtGui.QTextDocument.MetaInformation', 'str'),
-    "PySide2.QtGui.QTextDocument.setModified": ('bool',),
-    "PySide2.QtGui.QTextDocument.setPageSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTextDocument.setPlainText": ('str',),
-    "PySide2.QtGui.QTextDocument.setTextWidth": ('float',),
-    "PySide2.QtGui.QTextDocument.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtGui.QTextDocument.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextDocument.size": (),
-    "PySide2.QtGui.QTextDocument.textWidth": (),
-    "PySide2.QtGui.QTextDocument.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocument.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtGui.QTextDocument.toPlainText": (),
-    "PySide2.QtGui.QTextDocument.toRawText": (),
-    "PySide2.QtGui.QTextDocument.undo": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtGui.QTextDocument.useDesignMetrics": (),
-# class PySide2.QtGui.QTextDocumentFragment:
-    "PySide2.QtGui.QTextDocumentFragment.__init__": [(), ('PySide2.QtGui.QTextCursor',), ('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-    "PySide2.QtGui.QTextDocumentFragment.__copy__": (),
-    "PySide2.QtGui.QTextDocumentFragment.fromHtml": [('str',), ('str', 'PySide2.QtGui.QTextDocument')],
-    "PySide2.QtGui.QTextDocumentFragment.fromPlainText": ('str',),
-    "PySide2.QtGui.QTextDocumentFragment.isEmpty": (),
-    "PySide2.QtGui.QTextDocumentFragment.toHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentFragment.toPlainText": (),
-# class PySide2.QtGui.QTextDocumentWriter:
-    "PySide2.QtGui.QTextDocumentWriter.__init__": [(), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QByteArray'), ('str', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtGui.QTextDocumentWriter.codec": (),
-    "PySide2.QtGui.QTextDocumentWriter.device": (),
-    "PySide2.QtGui.QTextDocumentWriter.fileName": (),
-    "PySide2.QtGui.QTextDocumentWriter.format": (),
-    "PySide2.QtGui.QTextDocumentWriter.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtGui.QTextDocumentWriter.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtGui.QTextDocumentWriter.setFileName": ('str',),
-    "PySide2.QtGui.QTextDocumentWriter.setFormat": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.QTextDocumentWriter.supportedDocumentFormats": (),
-    "PySide2.QtGui.QTextDocumentWriter.write": [('PySide2.QtGui.QTextDocument',), ('PySide2.QtGui.QTextDocumentFragment',)],
-# class PySide2.QtGui.QTextFormat:
-# class PySide2.QtGui.QTextFormat.FormatType:
-# class PySide2.QtGui.QTextFormat.ObjectTypes:
-# class PySide2.QtGui.QTextFormat.PageBreakFlag:
-# class PySide2.QtGui.QTextFormat.PageBreakFlags:
-# class PySide2.QtGui.QTextFormat.Property:
-    "PySide2.QtGui.QTextFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('int',)],
-    "PySide2.QtGui.QTextFormat.__copy__": (),
-    "PySide2.QtGui.QTextFormat.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextFormat.background": (),
-    "PySide2.QtGui.QTextFormat.boolProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.brushProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.clearBackground": (),
-    "PySide2.QtGui.QTextFormat.clearForeground": (),
-    "PySide2.QtGui.QTextFormat.clearProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.colorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.doubleProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.foreground": (),
-    "PySide2.QtGui.QTextFormat.hasProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.intProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.isBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.isCharFormat": (),
-    "PySide2.QtGui.QTextFormat.isEmpty": (),
-    "PySide2.QtGui.QTextFormat.isFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.isImageFormat": (),
-    "PySide2.QtGui.QTextFormat.isListFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.isTableFormat": (),
-    "PySide2.QtGui.QTextFormat.isValid": (),
-    "PySide2.QtGui.QTextFormat.layoutDirection": (),
-    "PySide2.QtGui.QTextFormat.lengthProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.lengthVectorProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.merge": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.objectIndex": (),
-    "PySide2.QtGui.QTextFormat.objectType": (),
-    "PySide2.QtGui.QTextFormat.penProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.properties": (),
-    "PySide2.QtGui.QTextFormat.property": ('int',),
-    "PySide2.QtGui.QTextFormat.propertyCount": (),
-    "PySide2.QtGui.QTextFormat.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFormat.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextFormat.setObjectIndex": ('int',),
-    "PySide2.QtGui.QTextFormat.setObjectType": ('int',),
-    "PySide2.QtGui.QTextFormat.setProperty": [('int', 'typing.Any'), ('int', 'typing.List[PySide2.QtGui.QTextLength]')],
-    "PySide2.QtGui.QTextFormat.stringProperty": ('int',),
-    "PySide2.QtGui.QTextFormat.swap": ('PySide2.QtGui.QTextFormat',),
-    "PySide2.QtGui.QTextFormat.toBlockFormat": (),
-    "PySide2.QtGui.QTextFormat.toCharFormat": (),
-    "PySide2.QtGui.QTextFormat.toFrameFormat": (),
-    "PySide2.QtGui.QTextFormat.toImageFormat": (),
-    "PySide2.QtGui.QTextFormat.toListFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableCellFormat": (),
-    "PySide2.QtGui.QTextFormat.toTableFormat": (),
-    "PySide2.QtGui.QTextFormat.type": (),
-# class PySide2.QtGui.QTextFragment:
-    "PySide2.QtGui.QTextFragment.__init__": [(), ('PySide2.QtGui.QTextFragment',)],
-    "PySide2.QtGui.QTextFragment.__copy__": (),
-    "PySide2.QtGui.QTextFragment.charFormat": (),
-    "PySide2.QtGui.QTextFragment.charFormatIndex": (),
-    "PySide2.QtGui.QTextFragment.contains": ('int',),
-    "PySide2.QtGui.QTextFragment.isValid": (),
-    "PySide2.QtGui.QTextFragment.length": (),
-    "PySide2.QtGui.QTextFragment.position": (),
-    "PySide2.QtGui.QTextFragment.text": (),
-# class PySide2.QtGui.QTextFrame:
-# class PySide2.QtGui.QTextFrame.iterator:
-    "PySide2.QtGui.QTextFrame.iterator.__init__": [(), ('PySide2.QtGui.QTextFrame.iterator',)],
-    "PySide2.QtGui.QTextFrame.iterator.__copy__": (),
-    "PySide2.QtGui.QTextFrame.iterator.__iadd__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__isub__": ('int',),
-    "PySide2.QtGui.QTextFrame.iterator.__iter__": (),
-    "PySide2.QtGui.QTextFrame.iterator.atEnd": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentBlock": (),
-    "PySide2.QtGui.QTextFrame.iterator.currentFrame": (),
-    "PySide2.QtGui.QTextFrame.iterator.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextFrame.__iter__": (),
-    "PySide2.QtGui.QTextFrame.begin": (),
-    "PySide2.QtGui.QTextFrame.childFrames": (),
-    "PySide2.QtGui.QTextFrame.end": (),
-    "PySide2.QtGui.QTextFrame.firstCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.firstPosition": (),
-    "PySide2.QtGui.QTextFrame.frameFormat": (),
-    "PySide2.QtGui.QTextFrame.lastCursorPosition": (),
-    "PySide2.QtGui.QTextFrame.lastPosition": (),
-    "PySide2.QtGui.QTextFrame.parentFrame": (),
-    "PySide2.QtGui.QTextFrame.setFrameFormat": ('PySide2.QtGui.QTextFrameFormat',),
-# class PySide2.QtGui.QTextFrameFormat:
-# class PySide2.QtGui.QTextFrameFormat.BorderStyle:
-# class PySide2.QtGui.QTextFrameFormat.Position:
-    "PySide2.QtGui.QTextFrameFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextFrameFormat',)],
-    "PySide2.QtGui.QTextFrameFormat.__copy__": (),
-    "PySide2.QtGui.QTextFrameFormat.border": (),
-    "PySide2.QtGui.QTextFrameFormat.borderBrush": (),
-    "PySide2.QtGui.QTextFrameFormat.borderStyle": (),
-    "PySide2.QtGui.QTextFrameFormat.bottomMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.height": (),
-    "PySide2.QtGui.QTextFrameFormat.isValid": (),
-    "PySide2.QtGui.QTextFrameFormat.leftMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.margin": (),
-    "PySide2.QtGui.QTextFrameFormat.padding": (),
-    "PySide2.QtGui.QTextFrameFormat.pageBreakPolicy": (),
-    "PySide2.QtGui.QTextFrameFormat.position": (),
-    "PySide2.QtGui.QTextFrameFormat.rightMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextFrameFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextFrameFormat.setBottomMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setHeight": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.setLeftMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setPageBreakPolicy": ('PySide2.QtGui.QTextFormat.PageBreakFlags',),
-    "PySide2.QtGui.QTextFrameFormat.setPosition": ('PySide2.QtGui.QTextFrameFormat.Position',),
-    "PySide2.QtGui.QTextFrameFormat.setRightMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setTopMargin": ('float',),
-    "PySide2.QtGui.QTextFrameFormat.setWidth": [('PySide2.QtGui.QTextLength',), ('float',)],
-    "PySide2.QtGui.QTextFrameFormat.topMargin": (),
-    "PySide2.QtGui.QTextFrameFormat.width": (),
-# class PySide2.QtGui.QTextImageFormat:
-    "PySide2.QtGui.QTextImageFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextImageFormat',)],
-    "PySide2.QtGui.QTextImageFormat.__copy__": (),
-    "PySide2.QtGui.QTextImageFormat.height": (),
-    "PySide2.QtGui.QTextImageFormat.isValid": (),
-    "PySide2.QtGui.QTextImageFormat.name": (),
-    "PySide2.QtGui.QTextImageFormat.quality": (),
-    "PySide2.QtGui.QTextImageFormat.setHeight": ('float',),
-    "PySide2.QtGui.QTextImageFormat.setName": ('str',),
-    "PySide2.QtGui.QTextImageFormat.setQuality": ('int',),
-    "PySide2.QtGui.QTextImageFormat.setWidth": ('float',),
-    "PySide2.QtGui.QTextImageFormat.width": (),
-# class PySide2.QtGui.QTextInlineObject:
-    "PySide2.QtGui.QTextInlineObject.__init__": (),
-    "PySide2.QtGui.QTextInlineObject.__copy__": (),
-    "PySide2.QtGui.QTextInlineObject.ascent": (),
-    "PySide2.QtGui.QTextInlineObject.descent": (),
-    "PySide2.QtGui.QTextInlineObject.format": (),
-    "PySide2.QtGui.QTextInlineObject.formatIndex": (),
-    "PySide2.QtGui.QTextInlineObject.height": (),
-    "PySide2.QtGui.QTextInlineObject.isValid": (),
-    "PySide2.QtGui.QTextInlineObject.rect": (),
-    "PySide2.QtGui.QTextInlineObject.setAscent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setDescent": ('float',),
-    "PySide2.QtGui.QTextInlineObject.setWidth": ('float',),
-    "PySide2.QtGui.QTextInlineObject.textDirection": (),
-    "PySide2.QtGui.QTextInlineObject.textPosition": (),
-    "PySide2.QtGui.QTextInlineObject.width": (),
-# class PySide2.QtGui.QTextItem:
-# class PySide2.QtGui.QTextItem.RenderFlag:
-# class PySide2.QtGui.QTextItem.RenderFlags:
-    "PySide2.QtGui.QTextItem.__init__": (),
-    "PySide2.QtGui.QTextItem.ascent": (),
-    "PySide2.QtGui.QTextItem.descent": (),
-    "PySide2.QtGui.QTextItem.font": (),
-    "PySide2.QtGui.QTextItem.renderFlags": (),
-    "PySide2.QtGui.QTextItem.text": (),
-    "PySide2.QtGui.QTextItem.width": (),
-# class PySide2.QtGui.QTextLayout:
-# class PySide2.QtGui.QTextLayout.CursorMode:
-# class PySide2.QtGui.QTextLayout.FormatRange:
-    "PySide2.QtGui.QTextLayout.FormatRange.__init__": [(), ('PySide2.QtGui.QTextLayout.FormatRange',)],
-    "PySide2.QtGui.QTextLayout.FormatRange.__copy__": (),
-    "PySide2.QtGui.QTextLayout.__init__": [(), ('PySide2.QtGui.QTextBlock',), ('str',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QPaintDevice')],
-    "PySide2.QtGui.QTextLayout.additionalFormats": (),
-    "PySide2.QtGui.QTextLayout.beginLayout": (),
-    "PySide2.QtGui.QTextLayout.boundingRect": (),
-    "PySide2.QtGui.QTextLayout.cacheEnabled": (),
-    "PySide2.QtGui.QTextLayout.clearAdditionalFormats": (),
-    "PySide2.QtGui.QTextLayout.clearFormats": (),
-    "PySide2.QtGui.QTextLayout.clearLayout": (),
-    "PySide2.QtGui.QTextLayout.createLine": (),
-    "PySide2.QtGui.QTextLayout.cursorMoveStyle": (),
-    "PySide2.QtGui.QTextLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'typing.List[PySide2.QtGui.QTextLayout.FormatRange]', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtGui.QTextLayout.drawCursor": [('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'int', 'int')],
-    "PySide2.QtGui.QTextLayout.endLayout": (),
-    "PySide2.QtGui.QTextLayout.font": (),
-    "PySide2.QtGui.QTextLayout.formats": (),
-    "PySide2.QtGui.QTextLayout.isValidCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.leftCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.lineAt": ('int',),
-    "PySide2.QtGui.QTextLayout.lineCount": (),
-    "PySide2.QtGui.QTextLayout.lineForTextPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.maximumWidth": (),
-    "PySide2.QtGui.QTextLayout.minimumWidth": (),
-    "PySide2.QtGui.QTextLayout.nextCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.position": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaPosition": (),
-    "PySide2.QtGui.QTextLayout.preeditAreaText": (),
-    "PySide2.QtGui.QTextLayout.previousCursorPosition": ('int', 'PySide2.QtGui.QTextLayout.CursorMode'),
-    "PySide2.QtGui.QTextLayout.rightCursorPosition": ('int',),
-    "PySide2.QtGui.QTextLayout.setAdditionalFormats": ('typing.Sequence[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setCacheEnabled": ('bool',),
-    "PySide2.QtGui.QTextLayout.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtGui.QTextLayout.setFlags": ('int',),
-    "PySide2.QtGui.QTextLayout.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtGui.QTextLayout.setFormats": ('typing.List[PySide2.QtGui.QTextLayout.FormatRange]',),
-    "PySide2.QtGui.QTextLayout.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLayout.setPreeditArea": ('int', 'str'),
-    "PySide2.QtGui.QTextLayout.setRawFont": ('PySide2.QtGui.QRawFont',),
-    "PySide2.QtGui.QTextLayout.setText": ('str',),
-    "PySide2.QtGui.QTextLayout.setTextOption": ('PySide2.QtGui.QTextOption',),
-    "PySide2.QtGui.QTextLayout.text": (),
-    "PySide2.QtGui.QTextLayout.textOption": (),
-# class PySide2.QtGui.QTextLength:
-# class PySide2.QtGui.QTextLength.Type:
-    "PySide2.QtGui.QTextLength.__init__": [(), ('PySide2.QtGui.QTextLength',), ('PySide2.QtGui.QTextLength.Type', 'float')],
-    "PySide2.QtGui.QTextLength.__copy__": (),
-    "PySide2.QtGui.QTextLength.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTextLength.rawValue": (),
-    "PySide2.QtGui.QTextLength.type": (),
-    "PySide2.QtGui.QTextLength.value": ('float',),
-# class PySide2.QtGui.QTextLine:
-# class PySide2.QtGui.QTextLine.CursorPosition:
-# class PySide2.QtGui.QTextLine.Edge:
-    "PySide2.QtGui.QTextLine.__init__": (),
-    "PySide2.QtGui.QTextLine.__copy__": (),
-    "PySide2.QtGui.QTextLine.ascent": (),
-    "PySide2.QtGui.QTextLine.cursorToX": ('int', 'PySide2.QtGui.QTextLine.Edge'),
-    "PySide2.QtGui.QTextLine.descent": (),
-    "PySide2.QtGui.QTextLine.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPointF', 'PySide2.QtGui.QTextLayout.FormatRange'),
-    "PySide2.QtGui.QTextLine.height": (),
-    "PySide2.QtGui.QTextLine.horizontalAdvance": (),
-    "PySide2.QtGui.QTextLine.isValid": (),
-    "PySide2.QtGui.QTextLine.leading": (),
-    "PySide2.QtGui.QTextLine.leadingIncluded": (),
-    "PySide2.QtGui.QTextLine.lineNumber": (),
-    "PySide2.QtGui.QTextLine.naturalTextRect": (),
-    "PySide2.QtGui.QTextLine.naturalTextWidth": (),
-    "PySide2.QtGui.QTextLine.position": (),
-    "PySide2.QtGui.QTextLine.rect": (),
-    "PySide2.QtGui.QTextLine.setLeadingIncluded": ('bool',),
-    "PySide2.QtGui.QTextLine.setLineWidth": ('float',),
-    "PySide2.QtGui.QTextLine.setNumColumns": [('int',), ('int', 'float')],
-    "PySide2.QtGui.QTextLine.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTextLine.textLength": (),
-    "PySide2.QtGui.QTextLine.textStart": (),
-    "PySide2.QtGui.QTextLine.width": (),
-    "PySide2.QtGui.QTextLine.x": (),
-    "PySide2.QtGui.QTextLine.xToCursor": ('float', 'PySide2.QtGui.QTextLine.CursorPosition'),
-    "PySide2.QtGui.QTextLine.y": (),
-# class PySide2.QtGui.QTextList:
-    "PySide2.QtGui.QTextList.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextList.add": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.count": (),
-    "PySide2.QtGui.QTextList.format": (),
-    "PySide2.QtGui.QTextList.item": ('int',),
-    "PySide2.QtGui.QTextList.itemNumber": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.itemText": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.remove": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtGui.QTextList.removeItem": ('int',),
-    "PySide2.QtGui.QTextList.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-# class PySide2.QtGui.QTextListFormat:
-# class PySide2.QtGui.QTextListFormat.Style:
-    "PySide2.QtGui.QTextListFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextListFormat',)],
-    "PySide2.QtGui.QTextListFormat.__copy__": (),
-    "PySide2.QtGui.QTextListFormat.indent": (),
-    "PySide2.QtGui.QTextListFormat.isValid": (),
-    "PySide2.QtGui.QTextListFormat.numberPrefix": (),
-    "PySide2.QtGui.QTextListFormat.numberSuffix": (),
-    "PySide2.QtGui.QTextListFormat.setIndent": ('int',),
-    "PySide2.QtGui.QTextListFormat.setNumberPrefix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setNumberSuffix": ('str',),
-    "PySide2.QtGui.QTextListFormat.setStyle": ('PySide2.QtGui.QTextListFormat.Style',),
-    "PySide2.QtGui.QTextListFormat.style": (),
-# class PySide2.QtGui.QTextObject:
-    "PySide2.QtGui.QTextObject.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextObject.document": (),
-    "PySide2.QtGui.QTextObject.format": (),
-    "PySide2.QtGui.QTextObject.formatIndex": (),
-    "PySide2.QtGui.QTextObject.objectIndex": (),
-    "PySide2.QtGui.QTextObject.setFormat": ('PySide2.QtGui.QTextFormat',),
-# class PySide2.QtGui.QTextObjectInterface:
-    "PySide2.QtGui.QTextObjectInterface.__init__": (),
-    "PySide2.QtGui.QTextObjectInterface.drawObject": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-    "PySide2.QtGui.QTextObjectInterface.intrinsicSize": ('PySide2.QtGui.QTextDocument', 'int', 'PySide2.QtGui.QTextFormat'),
-# class PySide2.QtGui.QTextOption:
-# class PySide2.QtGui.QTextOption.Flag:
-# class PySide2.QtGui.QTextOption.Flags:
-# class PySide2.QtGui.QTextOption.Tab:
-    "PySide2.QtGui.QTextOption.Tab.__init__": [(), ('PySide2.QtGui.QTextOption.Tab',), ('float', 'PySide2.QtGui.QTextOption.TabType', 'str')],
-    "PySide2.QtGui.QTextOption.Tab.__copy__": (),
-# class PySide2.QtGui.QTextOption.TabType:
-# class PySide2.QtGui.QTextOption.WrapMode:
-    "PySide2.QtGui.QTextOption.__init__": [(), ('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtGui.QTextOption',)],
-    "PySide2.QtGui.QTextOption.__copy__": (),
-    "PySide2.QtGui.QTextOption.alignment": (),
-    "PySide2.QtGui.QTextOption.flags": (),
-    "PySide2.QtGui.QTextOption.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextOption.setFlags": ('PySide2.QtGui.QTextOption.Flags',),
-    "PySide2.QtGui.QTextOption.setTabArray": ('typing.Sequence[float]',),
-    "PySide2.QtGui.QTextOption.setTabStop": ('float',),
-    "PySide2.QtGui.QTextOption.setTabStopDistance": ('float',),
-    "PySide2.QtGui.QTextOption.setTabs": ('typing.Sequence[PySide2.QtGui.QTextOption.Tab]',),
-    "PySide2.QtGui.QTextOption.setTextDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtGui.QTextOption.setUseDesignMetrics": ('bool',),
-    "PySide2.QtGui.QTextOption.setWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtGui.QTextOption.tabArray": (),
-    "PySide2.QtGui.QTextOption.tabStop": (),
-    "PySide2.QtGui.QTextOption.tabStopDistance": (),
-    "PySide2.QtGui.QTextOption.tabs": (),
-    "PySide2.QtGui.QTextOption.textDirection": (),
-    "PySide2.QtGui.QTextOption.useDesignMetrics": (),
-    "PySide2.QtGui.QTextOption.wrapMode": (),
-# class PySide2.QtGui.QTextTable:
-    "PySide2.QtGui.QTextTable.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtGui.QTextTable.appendColumns": ('int',),
-    "PySide2.QtGui.QTextTable.appendRows": ('int',),
-    "PySide2.QtGui.QTextTable.cellAt": [('PySide2.QtGui.QTextCursor',), ('int',), ('int', 'int')],
-    "PySide2.QtGui.QTextTable.columns": (),
-    "PySide2.QtGui.QTextTable.format": (),
-    "PySide2.QtGui.QTextTable.insertColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.insertRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.mergeCells": [('PySide2.QtGui.QTextCursor',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QTextTable.removeColumns": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.removeRows": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.resize": ('int', 'int'),
-    "PySide2.QtGui.QTextTable.rowEnd": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rowStart": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtGui.QTextTable.rows": (),
-    "PySide2.QtGui.QTextTable.setFormat": [('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTable.splitCell": ('int', 'int', 'int', 'int'),
-# class PySide2.QtGui.QTextTableCell:
-    "PySide2.QtGui.QTextTableCell.__init__": [(), ('PySide2.QtGui.QTextTableCell',)],
-    "PySide2.QtGui.QTextTableCell.__copy__": (),
-    "PySide2.QtGui.QTextTableCell.begin": (),
-    "PySide2.QtGui.QTextTableCell.column": (),
-    "PySide2.QtGui.QTextTableCell.columnSpan": (),
-    "PySide2.QtGui.QTextTableCell.end": (),
-    "PySide2.QtGui.QTextTableCell.firstCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.firstPosition": (),
-    "PySide2.QtGui.QTextTableCell.format": (),
-    "PySide2.QtGui.QTextTableCell.isValid": (),
-    "PySide2.QtGui.QTextTableCell.lastCursorPosition": (),
-    "PySide2.QtGui.QTextTableCell.lastPosition": (),
-    "PySide2.QtGui.QTextTableCell.row": (),
-    "PySide2.QtGui.QTextTableCell.rowSpan": (),
-    "PySide2.QtGui.QTextTableCell.setFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtGui.QTextTableCell.tableCellFormatIndex": (),
-# class PySide2.QtGui.QTextTableCellFormat:
-    "PySide2.QtGui.QTextTableCellFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableCellFormat',)],
-    "PySide2.QtGui.QTextTableCellFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.bottomPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.isValid": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.leftPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.rightPadding": (),
-    "PySide2.QtGui.QTextTableCellFormat.setBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setBottomPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setLeftPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setRightPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorder": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopBorderStyle": ('PySide2.QtGui.QTextFrameFormat.BorderStyle',),
-    "PySide2.QtGui.QTextTableCellFormat.setTopPadding": ('float',),
-    "PySide2.QtGui.QTextTableCellFormat.topBorder": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderBrush": (),
-    "PySide2.QtGui.QTextTableCellFormat.topBorderStyle": (),
-    "PySide2.QtGui.QTextTableCellFormat.topPadding": (),
-# class PySide2.QtGui.QTextTableFormat:
-    "PySide2.QtGui.QTextTableFormat.__init__": [(), ('PySide2.QtGui.QTextFormat',), ('PySide2.QtGui.QTextTableFormat',)],
-    "PySide2.QtGui.QTextTableFormat.__copy__": (),
-    "PySide2.QtGui.QTextTableFormat.alignment": (),
-    "PySide2.QtGui.QTextTableFormat.borderCollapse": (),
-    "PySide2.QtGui.QTextTableFormat.cellPadding": (),
-    "PySide2.QtGui.QTextTableFormat.cellSpacing": (),
-    "PySide2.QtGui.QTextTableFormat.clearColumnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columnWidthConstraints": (),
-    "PySide2.QtGui.QTextTableFormat.columns": (),
-    "PySide2.QtGui.QTextTableFormat.headerRowCount": (),
-    "PySide2.QtGui.QTextTableFormat.isValid": (),
-    "PySide2.QtGui.QTextTableFormat.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtGui.QTextTableFormat.setBorderCollapse": ('bool',),
-    "PySide2.QtGui.QTextTableFormat.setCellPadding": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setCellSpacing": ('float',),
-    "PySide2.QtGui.QTextTableFormat.setColumnWidthConstraints": ('typing.List[PySide2.QtGui.QTextLength]',),
-    "PySide2.QtGui.QTextTableFormat.setColumns": ('int',),
-    "PySide2.QtGui.QTextTableFormat.setHeaderRowCount": ('int',),
-# class PySide2.QtGui.QToolBarChangeEvent:
-    "PySide2.QtGui.QToolBarChangeEvent.__init__": ('bool',),
-    "PySide2.QtGui.QToolBarChangeEvent.toggle": (),
-# class PySide2.QtGui.QTouchDevice:
-# class PySide2.QtGui.QTouchDevice.Capabilities:
-# class PySide2.QtGui.QTouchDevice.CapabilityFlag:
-# class PySide2.QtGui.QTouchDevice.DeviceType:
-    "PySide2.QtGui.QTouchDevice.__init__": (),
-    "PySide2.QtGui.QTouchDevice.capabilities": (),
-    "PySide2.QtGui.QTouchDevice.devices": (),
-    "PySide2.QtGui.QTouchDevice.maximumTouchPoints": (),
-    "PySide2.QtGui.QTouchDevice.name": (),
-    "PySide2.QtGui.QTouchDevice.setCapabilities": ('PySide2.QtGui.QTouchDevice.Capabilities',),
-    "PySide2.QtGui.QTouchDevice.setMaximumTouchPoints": ('int',),
-    "PySide2.QtGui.QTouchDevice.setName": ('str',),
-    "PySide2.QtGui.QTouchDevice.setType": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtGui.QTouchDevice.type": (),
-# class PySide2.QtGui.QTouchEvent:
-# class PySide2.QtGui.QTouchEvent.TouchPoint:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlag:
-# class PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags:
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__init__": [('PySide2.QtGui.QTouchEvent.TouchPoint',), ('int',)],
-    "PySide2.QtGui.QTouchEvent.TouchPoint.__copy__": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.ellipseDiameters": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.flags": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.id": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.lastScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.normalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.pressure": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rawScreenPositions": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.rotation": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.scenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.sceneRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.screenRect": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setEllipseDiameters": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setFlags": ('PySide2.QtGui.QTouchEvent.TouchPoint.InfoFlags',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setLastScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setPressure": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRawScreenPositions": ('typing.List[PySide2.QtCore.QPointF]',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setRotation": ('float',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setScreenRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartNormalizedPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setStartScreenPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setState": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setUniqueId": ('int',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.setVelocity": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startNormalizedPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScenePos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.startScreenPos": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.state": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.swap": ('PySide2.QtGui.QTouchEvent.TouchPoint',),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.uniqueId": (),
-    "PySide2.QtGui.QTouchEvent.TouchPoint.velocity": (),
-    "PySide2.QtGui.QTouchEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'PySide2.QtGui.QTouchDevice', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.TouchPointStates', 'typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]'),
-    "PySide2.QtGui.QTouchEvent.device": (),
-    "PySide2.QtGui.QTouchEvent.setDevice": ('PySide2.QtGui.QTouchDevice',),
-    "PySide2.QtGui.QTouchEvent.setTarget": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QTouchEvent.setTouchPointStates": ('PySide2.QtCore.Qt.TouchPointStates',),
-    "PySide2.QtGui.QTouchEvent.setTouchPoints": ('typing.Sequence[PySide2.QtGui.QTouchEvent.TouchPoint]',),
-    "PySide2.QtGui.QTouchEvent.setWindow": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QTouchEvent.target": (),
-    "PySide2.QtGui.QTouchEvent.touchPointStates": (),
-    "PySide2.QtGui.QTouchEvent.touchPoints": (),
-    "PySide2.QtGui.QTouchEvent.window": (),
-# class PySide2.QtGui.QTransform:
-# class PySide2.QtGui.QTransform.TransformationType:
-    "PySide2.QtGui.QTransform.__init__": [(), ('PySide2.QtGui.QMatrix',), ('PySide2.QtGui.QTransform',), ('float', 'float', 'float', 'float', 'float', 'float'), ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QTransform.__add__": ('float',),
-    "PySide2.QtGui.QTransform.__copy__": (),
-    "PySide2.QtGui.QTransform.__iadd__": ('float',),
-    "PySide2.QtGui.QTransform.__imul__": [('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__isub__": ('float',),
-    "PySide2.QtGui.QTransform.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__mul__": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QTransform',), ('float',)],
-    "PySide2.QtGui.QTransform.__reduce__": (),
-    "PySide2.QtGui.QTransform.__repr__": (),
-    "PySide2.QtGui.QTransform.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QTransform.__sub__": ('float',),
-    "PySide2.QtGui.QTransform.adjoint": (),
-    "PySide2.QtGui.QTransform.det": (),
-    "PySide2.QtGui.QTransform.determinant": (),
-    "PySide2.QtGui.QTransform.dx": (),
-    "PySide2.QtGui.QTransform.dy": (),
-    "PySide2.QtGui.QTransform.fromScale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.fromTranslate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.inverted": (),
-    "PySide2.QtGui.QTransform.isAffine": (),
-    "PySide2.QtGui.QTransform.isIdentity": (),
-    "PySide2.QtGui.QTransform.isInvertible": (),
-    "PySide2.QtGui.QTransform.isRotating": (),
-    "PySide2.QtGui.QTransform.isScaling": (),
-    "PySide2.QtGui.QTransform.isTranslating": (),
-    "PySide2.QtGui.QTransform.m11": (),
-    "PySide2.QtGui.QTransform.m12": (),
-    "PySide2.QtGui.QTransform.m13": (),
-    "PySide2.QtGui.QTransform.m21": (),
-    "PySide2.QtGui.QTransform.m22": (),
-    "PySide2.QtGui.QTransform.m23": (),
-    "PySide2.QtGui.QTransform.m31": (),
-    "PySide2.QtGui.QTransform.m32": (),
-    "PySide2.QtGui.QTransform.m33": (),
-    "PySide2.QtGui.QTransform.map": [('PySide2.QtCore.QLine',), ('PySide2.QtCore.QLineF',), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QRegion',), ('float', 'float')],
-    "PySide2.QtGui.QTransform.mapRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtGui.QTransform.mapToPolygon": ('PySide2.QtCore.QRect',),
-    "PySide2.QtGui.QTransform.quadToQuad": [('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.quadToSquare": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.reset": (),
-    "PySide2.QtGui.QTransform.rotate": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.rotateRadians": ('float', 'PySide2.QtCore.Qt.Axis'),
-    "PySide2.QtGui.QTransform.scale": ('float', 'float'),
-    "PySide2.QtGui.QTransform.setMatrix": ('float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtGui.QTransform.shear": ('float', 'float'),
-    "PySide2.QtGui.QTransform.squareToQuad": [('PySide2.QtGui.QPolygonF',), ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtGui.QTransform.toAffine": (),
-    "PySide2.QtGui.QTransform.translate": ('float', 'float'),
-    "PySide2.QtGui.QTransform.transposed": (),
-    "PySide2.QtGui.QTransform.type": (),
-# class PySide2.QtGui.QValidator:
-# class PySide2.QtGui.QValidator.State:
-    "PySide2.QtGui.QValidator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtGui.QValidator.fixup": ('str',),
-    "PySide2.QtGui.QValidator.locale": (),
-    "PySide2.QtGui.QValidator.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtGui.QValidator.validate": ('str', 'int'),
-# class PySide2.QtGui.QVector2D:
-    "PySide2.QtGui.QVector2D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector4D',), ('float', 'float')],
-    "PySide2.QtGui.QVector2D.__add__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__copy__": (),
-    "PySide2.QtGui.QVector2D.__iadd__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__imul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__isub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__mul__": [('PySide2.QtGui.QVector2D',), ('float',)],
-    "PySide2.QtGui.QVector2D.__neg__": (),
-    "PySide2.QtGui.QVector2D.__reduce__": (),
-    "PySide2.QtGui.QVector2D.__repr__": (),
-    "PySide2.QtGui.QVector2D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector2D.__sub__": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.distanceToLine": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.distanceToPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.QtGui.QVector2D.dotProduct": ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D'),
-    "PySide2.QtGui.QVector2D.isNull": (),
-    "PySide2.QtGui.QVector2D.length": (),
-    "PySide2.QtGui.QVector2D.lengthSquared": (),
-    "PySide2.QtGui.QVector2D.normalize": (),
-    "PySide2.QtGui.QVector2D.normalized": (),
-    "PySide2.QtGui.QVector2D.setX": ('float',),
-    "PySide2.QtGui.QVector2D.setY": ('float',),
-    "PySide2.QtGui.QVector2D.toPoint": (),
-    "PySide2.QtGui.QVector2D.toPointF": (),
-    "PySide2.QtGui.QVector2D.toTuple": (),
-    "PySide2.QtGui.QVector2D.toVector3D": (),
-    "PySide2.QtGui.QVector2D.toVector4D": (),
-    "PySide2.QtGui.QVector2D.x": (),
-    "PySide2.QtGui.QVector2D.y": (),
-# class PySide2.QtGui.QVector3D:
-    "PySide2.QtGui.QVector3D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float'), ('PySide2.QtGui.QVector4D',), ('float', 'float', 'float')],
-    "PySide2.QtGui.QVector3D.__add__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__copy__": (),
-    "PySide2.QtGui.QVector3D.__iadd__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__imul__": [('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__isub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QQuaternion',), ('PySide2.QtGui.QVector3D',), ('float',)],
-    "PySide2.QtGui.QVector3D.__neg__": (),
-    "PySide2.QtGui.QVector3D.__reduce__": (),
-    "PySide2.QtGui.QVector3D.__repr__": (),
-    "PySide2.QtGui.QVector3D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector3D.__sub__": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.crossProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToLine": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.distanceToPlane": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.distanceToPoint": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtGui.QVector3D.dotProduct": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.QtGui.QVector3D.isNull": (),
-    "PySide2.QtGui.QVector3D.length": (),
-    "PySide2.QtGui.QVector3D.lengthSquared": (),
-    "PySide2.QtGui.QVector3D.normal": [('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D')],
-    "PySide2.QtGui.QVector3D.normalize": (),
-    "PySide2.QtGui.QVector3D.normalized": (),
-    "PySide2.QtGui.QVector3D.project": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.setX": ('float',),
-    "PySide2.QtGui.QVector3D.setY": ('float',),
-    "PySide2.QtGui.QVector3D.setZ": ('float',),
-    "PySide2.QtGui.QVector3D.toPoint": (),
-    "PySide2.QtGui.QVector3D.toPointF": (),
-    "PySide2.QtGui.QVector3D.toTuple": (),
-    "PySide2.QtGui.QVector3D.toVector2D": (),
-    "PySide2.QtGui.QVector3D.toVector4D": (),
-    "PySide2.QtGui.QVector3D.unproject": ('PySide2.QtGui.QMatrix4x4', 'PySide2.QtGui.QMatrix4x4', 'PySide2.QtCore.QRect'),
-    "PySide2.QtGui.QVector3D.x": (),
-    "PySide2.QtGui.QVector3D.y": (),
-    "PySide2.QtGui.QVector3D.z": (),
-# class PySide2.QtGui.QVector4D:
-    "PySide2.QtGui.QVector4D.__init__": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QPointF',), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'float', 'float'), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtGui.QVector4D.__add__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__copy__": (),
-    "PySide2.QtGui.QVector4D.__iadd__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__imul__": [('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__isub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__mul__": [('PySide2.QtGui.QMatrix4x4',), ('PySide2.QtGui.QVector4D',), ('float',)],
-    "PySide2.QtGui.QVector4D.__neg__": (),
-    "PySide2.QtGui.QVector4D.__reduce__": (),
-    "PySide2.QtGui.QVector4D.__repr__": (),
-    "PySide2.QtGui.QVector4D.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtGui.QVector4D.__sub__": ('PySide2.QtGui.QVector4D',),
-    "PySide2.QtGui.QVector4D.dotProduct": ('PySide2.QtGui.QVector4D', 'PySide2.QtGui.QVector4D'),
-    "PySide2.QtGui.QVector4D.isNull": (),
-    "PySide2.QtGui.QVector4D.length": (),
-    "PySide2.QtGui.QVector4D.lengthSquared": (),
-    "PySide2.QtGui.QVector4D.normalize": (),
-    "PySide2.QtGui.QVector4D.normalized": (),
-    "PySide2.QtGui.QVector4D.setW": ('float',),
-    "PySide2.QtGui.QVector4D.setX": ('float',),
-    "PySide2.QtGui.QVector4D.setY": ('float',),
-    "PySide2.QtGui.QVector4D.setZ": ('float',),
-    "PySide2.QtGui.QVector4D.toPoint": (),
-    "PySide2.QtGui.QVector4D.toPointF": (),
-    "PySide2.QtGui.QVector4D.toTuple": (),
-    "PySide2.QtGui.QVector4D.toVector2D": (),
-    "PySide2.QtGui.QVector4D.toVector2DAffine": (),
-    "PySide2.QtGui.QVector4D.toVector3D": (),
-    "PySide2.QtGui.QVector4D.toVector3DAffine": (),
-    "PySide2.QtGui.QVector4D.w": (),
-    "PySide2.QtGui.QVector4D.x": (),
-    "PySide2.QtGui.QVector4D.y": (),
-    "PySide2.QtGui.QVector4D.z": (),
-# class PySide2.QtGui.QWhatsThisClickedEvent:
-    "PySide2.QtGui.QWhatsThisClickedEvent.__init__": ('str',),
-    "PySide2.QtGui.QWhatsThisClickedEvent.href": (),
-# class PySide2.QtGui.QWheelEvent:
-    "PySide2.QtGui.QWheelEvent.__init__": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'bool', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'PySide2.QtCore.QPoint', 'PySide2.QtCore.QPoint', 'int', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.ScrollPhase', 'PySide2.QtCore.Qt.MouseEventSource', 'bool'), ('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation'), ('PySide2.QtCore.QPointF', 'int', 'PySide2.QtCore.Qt.MouseButtons', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtGui.QWheelEvent.angleDelta": (),
-    "PySide2.QtGui.QWheelEvent.buttons": (),
-    "PySide2.QtGui.QWheelEvent.delta": (),
-    "PySide2.QtGui.QWheelEvent.globalPos": (),
-    "PySide2.QtGui.QWheelEvent.globalPosF": (),
-    "PySide2.QtGui.QWheelEvent.globalPosition": (),
-    "PySide2.QtGui.QWheelEvent.globalX": (),
-    "PySide2.QtGui.QWheelEvent.global""Y": (),
-    "PySide2.QtGui.QWheelEvent.inverted": (),
-    "PySide2.QtGui.QWheelEvent.orientation": (),
-    "PySide2.QtGui.QWheelEvent.phase": (),
-    "PySide2.QtGui.QWheelEvent.pixelDelta": (),
-    "PySide2.QtGui.QWheelEvent.pos": (),
-    "PySide2.QtGui.QWheelEvent.posF": (),
-    "PySide2.QtGui.QWheelEvent.position": (),
-    "PySide2.QtGui.QWheelEvent.source": (),
-    "PySide2.QtGui.QWheelEvent.x": (),
-    "PySide2.QtGui.QWheelEvent.y": (),
-# class PySide2.QtGui.QWindow:
-# class PySide2.QtGui.QWindow.AncestorMode:
-# class PySide2.QtGui.QWindow.Visibility:
-    "PySide2.QtGui.QWindow.__init__": [('PySide2.QtGui.QScreen',), ('PySide2.QtGui.QWindow',)],
-    "PySide2.QtGui.QWindow.accessibleRoot": (),
-    "PySide2.QtGui.QWindow.alert": ('int',),
-    "PySide2.QtGui.QWindow.baseSize": (),
-    "PySide2.QtGui.QWindow.close": (),
-    "PySide2.QtGui.QWindow.contentOrientation": (),
-    "PySide2.QtGui.QWindow.create": (),
-    "PySide2.QtGui.QWindow.cursor": (),
-    "PySide2.QtGui.QWindow.destroy": (),
-    "PySide2.QtGui.QWindow.devicePixelRatio": (),
-    "PySide2.QtGui.QWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtGui.QWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtGui.QWindow.filePath": (),
-    "PySide2.QtGui.QWindow.flags": (),
-    "PySide2.QtGui.QWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.focusObject": (),
-    "PySide2.QtGui.QWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtGui.QWindow.format": (),
-    "PySide2.QtGui.QWindow.frameGeometry": (),
-    "PySide2.QtGui.QWindow.frameMargins": (),
-    "PySide2.QtGui.QWindow.framePosition": (),
-    "PySide2.QtGui.QWindow.fromWinId": ('int',),
-    "PySide2.QtGui.QWindow.geometry": (),
-    "PySide2.QtGui.QWindow.height": (),
-    "PySide2.QtGui.QWindow.hide": (),
-    "PySide2.QtGui.QWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtGui.QWindow.icon": (),
-    "PySide2.QtGui.QWindow.isActive": (),
-    "PySide2.QtGui.QWindow.isAncestorOf": ('PySide2.QtGui.QWindow', 'PySide2.QtGui.QWindow.AncestorMode'),
-    "PySide2.QtGui.QWindow.isExposed": (),
-    "PySide2.QtGui.QWindow.isModal": (),
-    "PySide2.QtGui.QWindow.isTopLevel": (),
-    "PySide2.QtGui.QWindow.isVisible": (),
-    "PySide2.QtGui.QWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtGui.QWindow.lower": (),
-    "PySide2.QtGui.QWindow.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.mask": (),
-    "PySide2.QtGui.QWindow.maximumHeight": (),
-    "PySide2.QtGui.QWindow.maximumSize": (),
-    "PySide2.QtGui.QWindow.maximumWidth": (),
-    "PySide2.QtGui.QWindow.minimumHeight": (),
-    "PySide2.QtGui.QWindow.minimumSize": (),
-    "PySide2.QtGui.QWindow.minimumWidth": (),
-    "PySide2.QtGui.QWindow.modality": (),
-    "PySide2.QtGui.QWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtGui.QWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtGui.QWindow.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtGui.QWindow.opacity": (),
-    "PySide2.QtGui.QWindow.parent": [(), ('PySide2.QtGui.QWindow.AncestorMode',)],
-    "PySide2.QtGui.QWindow.position": (),
-    "PySide2.QtGui.QWindow.raise_": (),
-    "PySide2.QtGui.QWindow.reportContentOrientationChange": ('PySide2.QtCore.Qt.ScreenOrientation',),
-    "PySide2.QtGui.QWindow.requestActivate": (),
-    "PySide2.QtGui.QWindow.requestUpdate": (),
-    "PySide2.QtGui.QWindow.requestedFormat": (),
-    "PySide2.QtGui.QWindow.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtGui.QWindow.screen": (),
-    "PySide2.QtGui.QWindow.setBaseSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtGui.QWindow.setFilePath": ('str',),
-    "PySide2.QtGui.QWindow.setFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtGui.QWindow.setFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtGui.QWindow.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtGui.QWindow.setFramePosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtGui.QWindow.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtGui.QWindow.setHeight": ('int',),
-    "PySide2.QtGui.QWindow.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtGui.QWindow.setKeyboardGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setMask": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtGui.QWindow.setMaximumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMaximumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMaximumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumHeight": ('int',),
-    "PySide2.QtGui.QWindow.setMinimumSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setMinimumWidth": ('int',),
-    "PySide2.QtGui.QWindow.setModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtGui.QWindow.setMouseGrabEnabled": ('bool',),
-    "PySide2.QtGui.QWindow.setOpacity": ('float',),
-    "PySide2.QtGui.QWindow.setParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setPosition": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtGui.QWindow.setScreen": ('PySide2.QtGui.QScreen',),
-    "PySide2.QtGui.QWindow.setSizeIncrement": ('PySide2.QtCore.QSize',),
-    "PySide2.QtGui.QWindow.setSurfaceType": ('PySide2.QtGui.QSurface.SurfaceType',),
-    "PySide2.QtGui.QWindow.setTitle": ('str',),
-    "PySide2.QtGui.QWindow.setTransientParent": ('PySide2.QtGui.QWindow',),
-    "PySide2.QtGui.QWindow.setVisibility": ('PySide2.QtGui.QWindow.Visibility',),
-    "PySide2.QtGui.QWindow.setVisible": ('bool',),
-    "PySide2.QtGui.QWindow.setWidth": ('int',),
-    "PySide2.QtGui.QWindow.setWindowState": ('PySide2.QtCore.Qt.WindowState',),
-    "PySide2.QtGui.QWindow.setWindowStates": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtGui.QWindow.setX": ('int',),
-    "PySide2.QtGui.QWindow.setY": ('int',),
-    "PySide2.QtGui.QWindow.show": (),
-    "PySide2.QtGui.QWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtGui.QWindow.showFullScreen": (),
-    "PySide2.QtGui.QWindow.showMaximized": (),
-    "PySide2.QtGui.QWindow.showMinimized": (),
-    "PySide2.QtGui.QWindow.showNormal": (),
-    "PySide2.QtGui.QWindow.size": (),
-    "PySide2.QtGui.QWindow.sizeIncrement": (),
-    "PySide2.QtGui.QWindow.surfaceHandle": (),
-    "PySide2.QtGui.QWindow.surfaceType": (),
-    "PySide2.QtGui.QWindow.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtGui.QWindow.title": (),
-    "PySide2.QtGui.QWindow.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtGui.QWindow.transientParent": (),
-    "PySide2.QtGui.QWindow.type": (),
-    "PySide2.QtGui.QWindow.unsetCursor": (),
-    "PySide2.QtGui.QWindow.visibility": (),
-    "PySide2.QtGui.QWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtGui.QWindow.width": (),
-    "PySide2.QtGui.QWindow.winId": (),
-    "PySide2.QtGui.QWindow.windowState": (),
-    "PySide2.QtGui.QWindow.windowStates": (),
-    "PySide2.QtGui.QWindow.x": (),
-    "PySide2.QtGui.QWindow.y": (),
-# class PySide2.QtGui.QWindowStateChangeEvent:
-    "PySide2.QtGui.QWindowStateChangeEvent.__init__": ('PySide2.QtCore.Qt.WindowStates', 'bool'),
-    "PySide2.QtGui.QWindowStateChangeEvent.isOverride": (),
-    "PySide2.QtGui.QWindowStateChangeEvent.oldState": (),
-# class PySide2.QtGui.Qt:
-    "PySide2.QtGui.Qt.codecForHtml": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtGui.Qt.convertFromPlainText": ('str', 'PySide2.QtCore.Qt.WhiteSpaceMode'),
-    "PySide2.QtGui.Qt.mightBeRichText": ('str',),
-    "PySide2.QtGui.Qt.qAlpha": ('int',),
-    "PySide2.QtGui.Qt.qBlue": ('int',),
-    "PySide2.QtGui.Qt.qGray": [('int',), ('int', 'int', 'int')],
-    "PySide2.QtGui.Qt.qGreen": ('int',),
-    "PySide2.QtGui.Qt.qIsGray": ('int',),
-    "PySide2.QtGui.Qt.qRed": ('int',),
-    "PySide2.QtGui.Qt.qRgb": ('int', 'int', 'int'),
-    "PySide2.QtGui.Qt.qRgba": ('int', 'int', 'int', 'int'),
-    }) if "PySide2.QtGui" in sys.modules else None
-# Module PySide2.QtWidgets
-sig_dict.update({
-# class PySide2.QtWidgets.QAbstractButton:
-    "PySide2.QtWidgets.QAbstractButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractButton.animateClick": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.autoExclusive": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeat": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatDelay": (),
-    "PySide2.QtWidgets.QAbstractButton.autoRepeatInterval": (),
-    "PySide2.QtWidgets.QAbstractButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.checkStateSet": (),
-    "PySide2.QtWidgets.QAbstractButton.click": (),
-    "PySide2.QtWidgets.QAbstractButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractButton.group": (),
-    "PySide2.QtWidgets.QAbstractButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractButton.icon": (),
-    "PySide2.QtWidgets.QAbstractButton.iconSize": (),
-    "PySide2.QtWidgets.QAbstractButton.isCheckable": (),
-    "PySide2.QtWidgets.QAbstractButton.isChecked": (),
-    "PySide2.QtWidgets.QAbstractButton.isDown": (),
-    "PySide2.QtWidgets.QAbstractButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractButton.nextCheckState": (),
-    "PySide2.QtWidgets.QAbstractButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoExclusive": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatDelay": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setAutoRepeatInterval": ('int',),
-    "PySide2.QtWidgets.QAbstractButton.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractButton.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAbstractButton.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractButton.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAbstractButton.setText": ('str',),
-    "PySide2.QtWidgets.QAbstractButton.shortcut": (),
-    "PySide2.QtWidgets.QAbstractButton.text": (),
-    "PySide2.QtWidgets.QAbstractButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractButton.toggle": (),
-# class PySide2.QtWidgets.QAbstractGraphicsShapeItem:
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.brush": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.opaqueArea": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.pen": (),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QAbstractGraphicsShapeItem.setPen": ('PySide2.QtGui.QPen',),
-# class PySide2.QtWidgets.QAbstractItemDelegate:
-# class PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint:
-    "PySide2.QtWidgets.QAbstractItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.destroyEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.elidedText": ('PySide2.QtGui.QFontMetrics', 'int', 'PySide2.QtCore.Qt.TextElideMode', 'str'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.helpEvent": ('PySide2.QtGui.QHelpEvent', 'PySide2.QtWidgets.QAbstractItemView', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.paintingRoles": (),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QAbstractItemView:
-# class PySide2.QtWidgets.QAbstractItemView.CursorAction:
-# class PySide2.QtWidgets.QAbstractItemView.DragDropMode:
-# class PySide2.QtWidgets.QAbstractItemView.DropIndicatorPosition:
-# class PySide2.QtWidgets.QAbstractItemView.EditTrigger:
-# class PySide2.QtWidgets.QAbstractItemView.EditTriggers:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollHint:
-# class PySide2.QtWidgets.QAbstractItemView.ScrollMode:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionBehavior:
-# class PySide2.QtWidgets.QAbstractItemView.SelectionMode:
-# class PySide2.QtWidgets.QAbstractItemView.State:
-    "PySide2.QtWidgets.QAbstractItemView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.alternatingRowColors": (),
-    "PySide2.QtWidgets.QAbstractItemView.autoScrollMargin": (),
-    "PySide2.QtWidgets.QAbstractItemView.clearSelection": (),
-    "PySide2.QtWidgets.QAbstractItemView.closeEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QAbstractItemDelegate.EndEditHint'),
-    "PySide2.QtWidgets.QAbstractItemView.closePersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.commitData": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractItemView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QAbstractItemView.currentIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QAbstractItemView.defaultDropAction": (),
-    "PySide2.QtWidgets.QAbstractItemView.dirtyRegionOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.doAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.doItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragDropOverwriteMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnabled": (),
-    "PySide2.QtWidgets.QAbstractItemView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.dropIndicatorPosition": (),
-    "PySide2.QtWidgets.QAbstractItemView.edit": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.EditTrigger', 'PySide2.QtCore.QEvent')],
-    "PySide2.QtWidgets.QAbstractItemView.editTriggers": (),
-    "PySide2.QtWidgets.QAbstractItemView.editorDestroyed": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QAbstractItemView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.executeDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.hasAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.horizontalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.iconSize": (),
-    "PySide2.QtWidgets.QAbstractItemView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QAbstractItemView.indexWidget": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractItemView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.isPersistentEditorOpen": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegate": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.itemDelegateForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QAbstractItemView.model": (),
-    "PySide2.QtWidgets.QAbstractItemView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QAbstractItemView.openPersistentEditor": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.reset": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetHorizontalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resetVerticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.rootIndex": (),
-    "PySide2.QtWidgets.QAbstractItemView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scheduleDelayedItemsLayout": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollDirtyRegion": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToBottom": (),
-    "PySide2.QtWidgets.QAbstractItemView.scrollToTop": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectAll": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectedIndexes": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionBehavior": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionCommand": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractItemView.selectionMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.selectionModel": (),
-    "PySide2.QtWidgets.QAbstractItemView.setAlternatingRowColors": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScroll": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setAutoScrollMargin": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setCurrentIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setDefaultDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QAbstractItemView.setDirtyRegion": ('PySide2.QtGui.QRegion',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropMode": ('PySide2.QtWidgets.QAbstractItemView.DragDropMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragDropOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setDropIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setEditTriggers": ('PySide2.QtWidgets.QAbstractItemView.EditTriggers',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setHorizontalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QAbstractItemView.setIndexWidget": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForColumn": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setItemDelegateForRow": ('int', 'PySide2.QtWidgets.QAbstractItemDelegate'),
-    "PySide2.QtWidgets.QAbstractItemView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionBehavior": ('PySide2.QtWidgets.QAbstractItemView.SelectionBehavior',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionMode": ('PySide2.QtWidgets.QAbstractItemView.SelectionMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QAbstractItemView.setState": ('PySide2.QtWidgets.QAbstractItemView.State',),
-    "PySide2.QtWidgets.QAbstractItemView.setTabKeyNavigation": ('bool',),
-    "PySide2.QtWidgets.QAbstractItemView.setTextElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalScrollMode": ('PySide2.QtWidgets.QAbstractItemView.ScrollMode',),
-    "PySide2.QtWidgets.QAbstractItemView.setVerticalStepsPerItem": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.showDropIndicator": (),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.startAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QAbstractItemView.state": (),
-    "PySide2.QtWidgets.QAbstractItemView.stopAutoScroll": (),
-    "PySide2.QtWidgets.QAbstractItemView.tabKeyNavigation": (),
-    "PySide2.QtWidgets.QAbstractItemView.textElideMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.update": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorData": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateEditorGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.updateGeometries": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalOffset": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollMode": (),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QAbstractItemView.verticalStepsPerItem": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewOptions": (),
-    "PySide2.QtWidgets.QAbstractItemView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractItemView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractItemView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QAbstractItemView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QAbstractScrollArea:
-# class PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QAbstractScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.addScrollBarWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QAbstractScrollArea.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.cornerWidget": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.horizontalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.maximumViewportSize": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollBarWidgets": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractScrollArea.setCornerWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setHorizontalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setSizeAdjustPolicy": ('PySide2.QtWidgets.QAbstractScrollArea.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBar": ('PySide2.QtWidgets.QScrollBar',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setVerticalScrollBarPolicy": ('PySide2.QtCore.Qt.ScrollBarPolicy',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.setViewportMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QAbstractScrollArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBar": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.verticalScrollBarPolicy": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewport": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportMargins": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QAbstractScrollArea.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSlider:
-# class PySide2.QtWidgets.QAbstractSlider.SliderAction:
-# class PySide2.QtWidgets.QAbstractSlider.SliderChange:
-    "PySide2.QtWidgets.QAbstractSlider.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSlider.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.hasTracking": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedAppearance": (),
-    "PySide2.QtWidgets.QAbstractSlider.invertedControls": (),
-    "PySide2.QtWidgets.QAbstractSlider.isSliderDown": (),
-    "PySide2.QtWidgets.QAbstractSlider.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.maximum": (),
-    "PySide2.QtWidgets.QAbstractSlider.minimum": (),
-    "PySide2.QtWidgets.QAbstractSlider.orientation": (),
-    "PySide2.QtWidgets.QAbstractSlider.pageStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.repeatAction": (),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setInvertedControls": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setMaximum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setMinimum": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QAbstractSlider.setPageStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setRepeatAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction', 'int', 'int'),
-    "PySide2.QtWidgets.QAbstractSlider.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderDown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setSliderPosition": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.setTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSlider.setValue": ('int',),
-    "PySide2.QtWidgets.QAbstractSlider.singleStep": (),
-    "PySide2.QtWidgets.QAbstractSlider.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QAbstractSlider.sliderPosition": (),
-    "PySide2.QtWidgets.QAbstractSlider.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSlider.triggerAction": ('PySide2.QtWidgets.QAbstractSlider.SliderAction',),
-    "PySide2.QtWidgets.QAbstractSlider.value": (),
-    "PySide2.QtWidgets.QAbstractSlider.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QAbstractSpinBox:
-# class PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols:
-# class PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabled:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepEnabledFlag:
-# class PySide2.QtWidgets.QAbstractSpinBox.StepType:
-    "PySide2.QtWidgets.QAbstractSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAbstractSpinBox.alignment": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.buttonSymbols": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.clear": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.correctionMode": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hasFrame": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QAbstractSpinBox.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QAbstractSpinBox.interpretText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isAccelerated": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isGroupSeparatorShown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.isReadOnly": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.keyboardTracking": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.lineEdit": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.selectAll": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAccelerated": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setButtonSymbols": ('PySide2.QtWidgets.QAbstractSpinBox.ButtonSymbols',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setCorrectionMode": ('PySide2.QtWidgets.QAbstractSpinBox.CorrectionMode',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setGroupSeparatorShown": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setKeyboardTracking": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setSpecialValueText": ('str',),
-    "PySide2.QtWidgets.QAbstractSpinBox.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QAbstractSpinBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.sizeHint": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.specialValueText": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepBy": ('int',),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepDown": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepEnabled": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.stepUp": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.text": (),
-    "PySide2.QtWidgets.QAbstractSpinBox.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QAbstractSpinBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QAbstractSpinBox.wrapping": (),
-# class PySide2.QtWidgets.QAccessibleWidget:
-    "PySide2.QtWidgets.QAccessibleWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QAccessible.Role', 'str'),
-    "PySide2.QtWidgets.QAccessibleWidget.actionNames": (),
-    "PySide2.QtWidgets.QAccessibleWidget.addControllingSignal": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.backgroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.child": ('int',),
-    "PySide2.QtWidgets.QAccessibleWidget.childCount": (),
-    "PySide2.QtWidgets.QAccessibleWidget.doAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.focusChild": (),
-    "PySide2.QtWidgets.QAccessibleWidget.foregroundColor": (),
-    "PySide2.QtWidgets.QAccessibleWidget.indexOfChild": ('PySide2.QtGui.QAccessibleInterface',),
-    "PySide2.QtWidgets.QAccessibleWidget.interface_cast": ('PySide2.QtGui.QAccessible.InterfaceType',),
-    "PySide2.QtWidgets.QAccessibleWidget.isValid": (),
-    "PySide2.QtWidgets.QAccessibleWidget.keyBindingsForAction": ('str',),
-    "PySide2.QtWidgets.QAccessibleWidget.parent": (),
-    "PySide2.QtWidgets.QAccessibleWidget.parentObject": (),
-    "PySide2.QtWidgets.QAccessibleWidget.rect": (),
-    "PySide2.QtWidgets.QAccessibleWidget.relations": ('PySide2.QtGui.QAccessible.Relation',),
-    "PySide2.QtWidgets.QAccessibleWidget.role": (),
-    "PySide2.QtWidgets.QAccessibleWidget.state": (),
-    "PySide2.QtWidgets.QAccessibleWidget.text": ('PySide2.QtGui.QAccessible.Text',),
-    "PySide2.QtWidgets.QAccessibleWidget.widget": (),
-    "PySide2.QtWidgets.QAccessibleWidget.window": (),
-# class PySide2.QtWidgets.QAction:
-# class PySide2.QtWidgets.QAction.ActionEvent:
-# class PySide2.QtWidgets.QAction.MenuRole:
-# class PySide2.QtWidgets.QAction.Priority:
-    "PySide2.QtWidgets.QAction.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QAction.actionGroup": (),
-    "PySide2.QtWidgets.QAction.activate": ('PySide2.QtWidgets.QAction.ActionEvent',),
-    "PySide2.QtWidgets.QAction.associatedGraphicsWidgets": (),
-    "PySide2.QtWidgets.QAction.associatedWidgets": (),
-    "PySide2.QtWidgets.QAction.autoRepeat": (),
-    "PySide2.QtWidgets.QAction.data": (),
-    "PySide2.QtWidgets.QAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QAction.font": (),
-    "PySide2.QtWidgets.QAction.hover": (),
-    "PySide2.QtWidgets.QAction.icon": (),
-    "PySide2.QtWidgets.QAction.iconText": (),
-    "PySide2.QtWidgets.QAction.isCheckable": (),
-    "PySide2.QtWidgets.QAction.isChecked": (),
-    "PySide2.QtWidgets.QAction.isEnabled": (),
-    "PySide2.QtWidgets.QAction.isIconVisibleInMenu": (),
-    "PySide2.QtWidgets.QAction.isSeparator": (),
-    "PySide2.QtWidgets.QAction.isShortcutVisibleInContextMenu": (),
-    "PySide2.QtWidgets.QAction.isVisible": (),
-    "PySide2.QtWidgets.QAction.menu": (),
-    "PySide2.QtWidgets.QAction.menuRole": (),
-    "PySide2.QtWidgets.QAction.parentWidget": (),
-    "PySide2.QtWidgets.QAction.priority": (),
-    "PySide2.QtWidgets.QAction.setActionGroup": ('PySide2.QtWidgets.QActionGroup',),
-    "PySide2.QtWidgets.QAction.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QAction.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QAction.setChecked": ('bool',),
-    "PySide2.QtWidgets.QAction.setData": ('typing.Any',),
-    "PySide2.QtWidgets.QAction.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QAction.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QAction.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QAction.setIconText": ('str',),
-    "PySide2.QtWidgets.QAction.setIconVisibleInMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QAction.setMenuRole": ('PySide2.QtWidgets.QAction.MenuRole',),
-    "PySide2.QtWidgets.QAction.setPriority": ('PySide2.QtWidgets.QAction.Priority',),
-    "PySide2.QtWidgets.QAction.setSeparator": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcut": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QAction.setShortcutContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QAction.setShortcutVisibleInContextMenu": ('bool',),
-    "PySide2.QtWidgets.QAction.setShortcuts": [('PySide2.QtGui.QKeySequence.StandardKey',), ('typing.Sequence[PySide2.QtGui.QKeySequence]',)],
-    "PySide2.QtWidgets.QAction.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QAction.setText": ('str',),
-    "PySide2.QtWidgets.QAction.setToolTip": ('str',),
-    "PySide2.QtWidgets.QAction.setVisible": ('bool',),
-    "PySide2.QtWidgets.QAction.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QAction.shortcut": (),
-    "PySide2.QtWidgets.QAction.shortcutContext": (),
-    "PySide2.QtWidgets.QAction.shortcuts": (),
-    "PySide2.QtWidgets.QAction.showStatusText": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QAction.statusTip": (),
-    "PySide2.QtWidgets.QAction.text": (),
-    "PySide2.QtWidgets.QAction.toggle": (),
-    "PySide2.QtWidgets.QAction.toolTip": (),
-    "PySide2.QtWidgets.QAction.trigger": (),
-    "PySide2.QtWidgets.QAction.whatsThis": (),
-# class PySide2.QtWidgets.QActionGroup:
-# class PySide2.QtWidgets.QActionGroup.ExclusionPolicy:
-    "PySide2.QtWidgets.QActionGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QActionGroup.actions": (),
-    "PySide2.QtWidgets.QActionGroup.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction',), ('str',)],
-    "PySide2.QtWidgets.QActionGroup.checkedAction": (),
-    "PySide2.QtWidgets.QActionGroup.exclusionPolicy": (),
-    "PySide2.QtWidgets.QActionGroup.isEnabled": (),
-    "PySide2.QtWidgets.QActionGroup.isExclusive": (),
-    "PySide2.QtWidgets.QActionGroup.isVisible": (),
-    "PySide2.QtWidgets.QActionGroup.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QActionGroup.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setExclusionPolicy": ('PySide2.QtWidgets.QActionGroup.ExclusionPolicy',),
-    "PySide2.QtWidgets.QActionGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QActionGroup.setVisible": ('bool',),
-# class PySide2.QtWidgets.QApplication:
-# class PySide2.QtWidgets.QApplication.ColorSpec:
-    "PySide2.QtWidgets.QApplication.__init__": [(), ('typing.Sequence[str]',)],
-    "PySide2.QtWidgets.QApplication.aboutQt": (),
-    "PySide2.QtWidgets.QApplication.activeModalWidget": (),
-    "PySide2.QtWidgets.QApplication.activePopupWidget": (),
-    "PySide2.QtWidgets.QApplication.activeWindow": (),
-    "PySide2.QtWidgets.QApplication.alert": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QApplication.allWidgets": (),
-    "PySide2.QtWidgets.QApplication.autoSipEnabled": (),
-    "PySide2.QtWidgets.QApplication.beep": (),
-    "PySide2.QtWidgets.QApplication.closeAllWindows": (),
-    "PySide2.QtWidgets.QApplication.colorSpec": (),
-    "PySide2.QtWidgets.QApplication.cursorFlashTime": (),
-    "PySide2.QtWidgets.QApplication.desktop": (),
-    "PySide2.QtWidgets.QApplication.doubleClickInterval": (),
-    "PySide2.QtWidgets.QApplication.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QApplication.exec_": (),
-    "PySide2.QtWidgets.QApplication.focusWidget": (),
-    "PySide2.QtWidgets.QApplication.font": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.fontMetrics": (),
-    "PySide2.QtWidgets.QApplication.globalStrut": (),
-    "PySide2.QtWidgets.QApplication.isEffectEnabled": ('PySide2.QtCore.Qt.UIEffect',),
-    "PySide2.QtWidgets.QApplication.keyboardInputInterval": (),
-    "PySide2.QtWidgets.QApplication.notify": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QApplication.palette": [(), ('PySide2.QtWidgets.QWidget',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setActiveWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QApplication.setAutoSipEnabled": ('bool',),
-    "PySide2.QtWidgets.QApplication.setColorSpec": ('int',),
-    "PySide2.QtWidgets.QApplication.setCursorFlashTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setDoubleClickInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setEffectEnabled": ('PySide2.QtCore.Qt.UIEffect', 'bool'),
-    "PySide2.QtWidgets.QApplication.setFont": [('PySide2.QtGui.QFont',), ('PySide2.QtGui.QFont', 'str')],
-    "PySide2.QtWidgets.QApplication.setGlobalStrut": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QApplication.setKeyboardInputInterval": ('int',),
-    "PySide2.QtWidgets.QApplication.setPalette": [('PySide2.QtGui.QPalette',), ('PySide2.QtGui.QPalette', 'str')],
-    "PySide2.QtWidgets.QApplication.setStartDragDistance": ('int',),
-    "PySide2.QtWidgets.QApplication.setStartDragTime": ('int',),
-    "PySide2.QtWidgets.QApplication.setStyle": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QApplication.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QApplication.setWheelScrollLines": ('int',),
-    "PySide2.QtWidgets.QApplication.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QApplication.startDragDistance": (),
-    "PySide2.QtWidgets.QApplication.startDragTime": (),
-    "PySide2.QtWidgets.QApplication.style": (),
-    "PySide2.QtWidgets.QApplication.styleSheet": (),
-    "PySide2.QtWidgets.QApplication.topLevelAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.topLevelWidgets": (),
-    "PySide2.QtWidgets.QApplication.wheelScrollLines": (),
-    "PySide2.QtWidgets.QApplication.widgetAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QApplication.windowIcon": (),
-# class PySide2.QtWidgets.QBoxLayout:
-# class PySide2.QtWidgets.QBoxLayout.Direction:
-    "PySide2.QtWidgets.QBoxLayout.__init__": ('PySide2.QtWidgets.QBoxLayout.Direction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QBoxLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QBoxLayout.addLayout": ('PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.addSpacerItem": ('PySide2.QtWidgets.QSpacerItem',),
-    "PySide2.QtWidgets.QBoxLayout.addSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addStrut": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QBoxLayout.count": (),
-    "PySide2.QtWidgets.QBoxLayout.direction": (),
-    "PySide2.QtWidgets.QBoxLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QBoxLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QBoxLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.insertItem": ('int', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertLayout": ('int', 'PySide2.QtWidgets.QLayout', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacerItem": ('int', 'PySide2.QtWidgets.QSpacerItem'),
-    "PySide2.QtWidgets.QBoxLayout.insertSpacing": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QBoxLayout.invalidate": (),
-    "PySide2.QtWidgets.QBoxLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.maximumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.minimumSize": (),
-    "PySide2.QtWidgets.QBoxLayout.setDirection": ('PySide2.QtWidgets.QBoxLayout.Direction',),
-    "PySide2.QtWidgets.QBoxLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QBoxLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.setStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QBoxLayout.setStretchFactor": [('PySide2.QtWidgets.QLayout', 'int'), ('PySide2.QtWidgets.QWidget', 'int')],
-    "PySide2.QtWidgets.QBoxLayout.sizeHint": (),
-    "PySide2.QtWidgets.QBoxLayout.spacing": (),
-    "PySide2.QtWidgets.QBoxLayout.stretch": ('int',),
-    "PySide2.QtWidgets.QBoxLayout.takeAt": ('int',),
-# class PySide2.QtWidgets.QButtonGroup:
-    "PySide2.QtWidgets.QButtonGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QButtonGroup.addButton": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-    "PySide2.QtWidgets.QButtonGroup.button": ('int',),
-    "PySide2.QtWidgets.QButtonGroup.buttons": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedButton": (),
-    "PySide2.QtWidgets.QButtonGroup.checkedId": (),
-    "PySide2.QtWidgets.QButtonGroup.exclusive": (),
-    "PySide2.QtWidgets.QButtonGroup.id": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QButtonGroup.setExclusive": ('bool',),
-    "PySide2.QtWidgets.QButtonGroup.setId": ('PySide2.QtWidgets.QAbstractButton', 'int'),
-# class PySide2.QtWidgets.QCalendarWidget:
-# class PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat:
-# class PySide2.QtWidgets.QCalendarWidget.SelectionMode:
-# class PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat:
-    "PySide2.QtWidgets.QCalendarWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCalendarWidget.calendar": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateEditAcceptDelay": (),
-    "PySide2.QtWidgets.QCalendarWidget.dateTextFormat": [(), ('PySide2.QtCore.QDate',)],
-    "PySide2.QtWidgets.QCalendarWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCalendarWidget.firstDayOfWeek": (),
-    "PySide2.QtWidgets.QCalendarWidget.headerTextFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.horizontalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.isDateEditEnabled": (),
-    "PySide2.QtWidgets.QCalendarWidget.isGridVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.isNavigationBarVisible": (),
-    "PySide2.QtWidgets.QCalendarWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.maximumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.monthShown": (),
-    "PySide2.QtWidgets.QCalendarWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.paintCell": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QCalendarWidget.selectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.selectionMode": (),
-    "PySide2.QtWidgets.QCalendarWidget.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QCalendarWidget.setCurrentPage": ('int', 'int'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditAcceptDelay": ('int',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateEditEnabled": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QCalendarWidget.setDateTextFormat": ('PySide2.QtCore.QDate', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.setFirstDayOfWeek": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.setGridVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setHeaderTextFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setHorizontalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.HorizontalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setNavigationBarVisible": ('bool',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectedDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.setSelectionMode": ('PySide2.QtWidgets.QCalendarWidget.SelectionMode',),
-    "PySide2.QtWidgets.QCalendarWidget.setVerticalHeaderFormat": ('PySide2.QtWidgets.QCalendarWidget.VerticalHeaderFormat',),
-    "PySide2.QtWidgets.QCalendarWidget.setWeekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek', 'PySide2.QtGui.QTextCharFormat'),
-    "PySide2.QtWidgets.QCalendarWidget.showNextMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showNextYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousMonth": (),
-    "PySide2.QtWidgets.QCalendarWidget.showPreviousYear": (),
-    "PySide2.QtWidgets.QCalendarWidget.showSelectedDate": (),
-    "PySide2.QtWidgets.QCalendarWidget.showToday": (),
-    "PySide2.QtWidgets.QCalendarWidget.sizeHint": (),
-    "PySide2.QtWidgets.QCalendarWidget.updateCell": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QCalendarWidget.updateCells": (),
-    "PySide2.QtWidgets.QCalendarWidget.verticalHeaderFormat": (),
-    "PySide2.QtWidgets.QCalendarWidget.weekdayTextFormat": ('PySide2.QtCore.Qt.DayOfWeek',),
-    "PySide2.QtWidgets.QCalendarWidget.yearShown": (),
-# class PySide2.QtWidgets.QCheckBox:
-    "PySide2.QtWidgets.QCheckBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCheckBox.checkState": (),
-    "PySide2.QtWidgets.QCheckBox.checkStateSet": (),
-    "PySide2.QtWidgets.QCheckBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCheckBox.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QCheckBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QCheckBox.isTristate": (),
-    "PySide2.QtWidgets.QCheckBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCheckBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QCheckBox.nextCheckState": (),
-    "PySide2.QtWidgets.QCheckBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCheckBox.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QCheckBox.setTristate": ('bool',),
-    "PySide2.QtWidgets.QCheckBox.sizeHint": (),
-# class PySide2.QtWidgets.QColorDialog:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOption:
-# class PySide2.QtWidgets.QColorDialog.ColorDialogOptions:
-    "PySide2.QtWidgets.QColorDialog.__init__": [('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QColorDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QColorDialog.currentColor": (),
-    "PySide2.QtWidgets.QColorDialog.customColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.customCount": (),
-    "PySide2.QtWidgets.QColorDialog.done": ('int',),
-    "PySide2.QtWidgets.QColorDialog.getColor": ('PySide2.QtGui.QColor', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QColorDialog.ColorDialogOptions'),
-    "PySide2.QtWidgets.QColorDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QColorDialog.options": (),
-    "PySide2.QtWidgets.QColorDialog.selectedColor": (),
-    "PySide2.QtWidgets.QColorDialog.setCurrentColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColorDialog.setCustomColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption', 'bool'),
-    "PySide2.QtWidgets.QColorDialog.setOptions": ('PySide2.QtWidgets.QColorDialog.ColorDialogOptions',),
-    "PySide2.QtWidgets.QColorDialog.setStandardColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QColorDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QColorDialog.standardColor": ('int',),
-    "PySide2.QtWidgets.QColorDialog.testOption": ('PySide2.QtWidgets.QColorDialog.ColorDialogOption',),
-# class PySide2.QtWidgets.QColormap:
-# class PySide2.QtWidgets.QColormap.Mode:
-    "PySide2.QtWidgets.QColormap.__init__": ('PySide2.QtWidgets.QColormap',),
-    "PySide2.QtWidgets.QColormap.__copy__": (),
-    "PySide2.QtWidgets.QColormap.cleanup": (),
-    "PySide2.QtWidgets.QColormap.colorAt": ('int',),
-    "PySide2.QtWidgets.QColormap.colormap": (),
-    "PySide2.QtWidgets.QColormap.depth": (),
-    "PySide2.QtWidgets.QColormap.initialize": (),
-    "PySide2.QtWidgets.QColormap.instance": ('int',),
-    "PySide2.QtWidgets.QColormap.mode": (),
-    "PySide2.QtWidgets.QColormap.pixel": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QColormap.size": (),
-# class PySide2.QtWidgets.QColumnView:
-    "PySide2.QtWidgets.QColumnView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.columnWidths": (),
-    "PySide2.QtWidgets.QColumnView.createColumn": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QColumnView.horizontalOffset": (),
-    "PySide2.QtWidgets.QColumnView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QColumnView.initializeColumn": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QColumnView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QColumnView.previewWidget": (),
-    "PySide2.QtWidgets.QColumnView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QColumnView.resizeGripsVisible": (),
-    "PySide2.QtWidgets.QColumnView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QColumnView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QColumnView.selectAll": (),
-    "PySide2.QtWidgets.QColumnView.setColumnWidths": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QColumnView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QColumnView.setPreviewWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QColumnView.setResizeGripsVisible": ('bool',),
-    "PySide2.QtWidgets.QColumnView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QColumnView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QColumnView.sizeHint": (),
-    "PySide2.QtWidgets.QColumnView.verticalOffset": (),
-    "PySide2.QtWidgets.QColumnView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QColumnView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QComboBox:
-# class PySide2.QtWidgets.QComboBox.InsertPolicy:
-# class PySide2.QtWidgets.QComboBox.SizeAdjustPolicy:
-    "PySide2.QtWidgets.QComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QComboBox.addItem": [('PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QComboBox.autoCompletion": (),
-    "PySide2.QtWidgets.QComboBox.autoCompletionCaseSensitivity": (),
-    "PySide2.QtWidgets.QComboBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.clear": (),
-    "PySide2.QtWidgets.QComboBox.clearEditText": (),
-    "PySide2.QtWidgets.QComboBox.completer": (),
-    "PySide2.QtWidgets.QComboBox.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QComboBox.count": (),
-    "PySide2.QtWidgets.QComboBox.currentData": ('int',),
-    "PySide2.QtWidgets.QComboBox.currentIndex": (),
-    "PySide2.QtWidgets.QComboBox.currentText": (),
-    "PySide2.QtWidgets.QComboBox.duplicatesEnabled": (),
-    "PySide2.QtWidgets.QComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QComboBox.findData": ('typing.Any', 'int', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.findText": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QComboBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QComboBox.hasFrame": (),
-    "PySide2.QtWidgets.QComboBox.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QComboBox.hidePopup": (),
-    "PySide2.QtWidgets.QComboBox.iconSize": (),
-    "PySide2.QtWidgets.QComboBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionComboBox',),
-    "PySide2.QtWidgets.QComboBox.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QComboBox.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItem": [('int', 'PySide2.QtGui.QIcon', 'str', 'typing.Any'), ('int', 'str', 'typing.Any')],
-    "PySide2.QtWidgets.QComboBox.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QComboBox.insertPolicy": (),
-    "PySide2.QtWidgets.QComboBox.insertSeparator": ('int',),
-    "PySide2.QtWidgets.QComboBox.isEditable": (),
-    "PySide2.QtWidgets.QComboBox.itemData": ('int', 'int'),
-    "PySide2.QtWidgets.QComboBox.itemDelegate": (),
-    "PySide2.QtWidgets.QComboBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QComboBox.itemText": ('int',),
-    "PySide2.QtWidgets.QComboBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QComboBox.lineEdit": (),
-    "PySide2.QtWidgets.QComboBox.maxCount": (),
-    "PySide2.QtWidgets.QComboBox.maxVisibleItems": (),
-    "PySide2.QtWidgets.QComboBox.minimumContentsLength": (),
-    "PySide2.QtWidgets.QComboBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QComboBox.model": (),
-    "PySide2.QtWidgets.QComboBox.modelColumn": (),
-    "PySide2.QtWidgets.QComboBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QComboBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QComboBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QComboBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QComboBox.rootModelIndex": (),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletion": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setAutoCompletionCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QComboBox.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QComboBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QComboBox.setCurrentText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setDuplicatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setEditText": ('str',),
-    "PySide2.QtWidgets.QComboBox.setEditable": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setFrame": ('bool',),
-    "PySide2.QtWidgets.QComboBox.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QComboBox.setInsertPolicy": ('PySide2.QtWidgets.QComboBox.InsertPolicy',),
-    "PySide2.QtWidgets.QComboBox.setItemData": ('int', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QComboBox.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QComboBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QComboBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QComboBox.setLineEdit": ('PySide2.QtWidgets.QLineEdit',),
-    "PySide2.QtWidgets.QComboBox.setMaxCount": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QComboBox.setMinimumContentsLength": ('int',),
-    "PySide2.QtWidgets.QComboBox.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QComboBox.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QComboBox.setRootModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QComboBox.setSizeAdjustPolicy": ('PySide2.QtWidgets.QComboBox.SizeAdjustPolicy',),
-    "PySide2.QtWidgets.QComboBox.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QComboBox.setView": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QComboBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QComboBox.showPopup": (),
-    "PySide2.QtWidgets.QComboBox.sizeAdjustPolicy": (),
-    "PySide2.QtWidgets.QComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QComboBox.validator": (),
-    "PySide2.QtWidgets.QComboBox.view": (),
-    "PySide2.QtWidgets.QComboBox.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QCommandLinkButton:
-    "PySide2.QtWidgets.QCommandLinkButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget'), ('str', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QCommandLinkButton.description": (),
-    "PySide2.QtWidgets.QCommandLinkButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QCommandLinkButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QCommandLinkButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QCommandLinkButton.setDescription": ('str',),
-    "PySide2.QtWidgets.QCommandLinkButton.sizeHint": (),
-# class PySide2.QtWidgets.QCommonStyle:
-    "PySide2.QtWidgets.QCommonStyle.__init__": (),
-    "PySide2.QtWidgets.QCommonStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QCommonStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QCommonStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QCommonStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QCommonStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QCompleter:
-# class PySide2.QtWidgets.QCompleter.CompletionMode:
-# class PySide2.QtWidgets.QCompleter.ModelSorting:
-    "PySide2.QtWidgets.QCompleter.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QCompleter.caseSensitivity": (),
-    "PySide2.QtWidgets.QCompleter.complete": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QCompleter.completionColumn": (),
-    "PySide2.QtWidgets.QCompleter.completionCount": (),
-    "PySide2.QtWidgets.QCompleter.completionMode": (),
-    "PySide2.QtWidgets.QCompleter.completionModel": (),
-    "PySide2.QtWidgets.QCompleter.completionPrefix": (),
-    "PySide2.QtWidgets.QCompleter.completionRole": (),
-    "PySide2.QtWidgets.QCompleter.currentCompletion": (),
-    "PySide2.QtWidgets.QCompleter.currentIndex": (),
-    "PySide2.QtWidgets.QCompleter.currentRow": (),
-    "PySide2.QtWidgets.QCompleter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QCompleter.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QCompleter.filterMode": (),
-    "PySide2.QtWidgets.QCompleter.maxVisibleItems": (),
-    "PySide2.QtWidgets.QCompleter.model": (),
-    "PySide2.QtWidgets.QCompleter.modelSorting": (),
-    "PySide2.QtWidgets.QCompleter.pathFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QCompleter.popup": (),
-    "PySide2.QtWidgets.QCompleter.setCaseSensitivity": ('PySide2.QtCore.Qt.CaseSensitivity',),
-    "PySide2.QtWidgets.QCompleter.setCompletionColumn": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCompletionMode": ('PySide2.QtWidgets.QCompleter.CompletionMode',),
-    "PySide2.QtWidgets.QCompleter.setCompletionPrefix": ('str',),
-    "PySide2.QtWidgets.QCompleter.setCompletionRole": ('int',),
-    "PySide2.QtWidgets.QCompleter.setCurrentRow": ('int',),
-    "PySide2.QtWidgets.QCompleter.setFilterMode": ('PySide2.QtCore.Qt.MatchFlags',),
-    "PySide2.QtWidgets.QCompleter.setMaxVisibleItems": ('int',),
-    "PySide2.QtWidgets.QCompleter.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QCompleter.setModelSorting": ('PySide2.QtWidgets.QCompleter.ModelSorting',),
-    "PySide2.QtWidgets.QCompleter.setPopup": ('PySide2.QtWidgets.QAbstractItemView',),
-    "PySide2.QtWidgets.QCompleter.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QCompleter.setWrapAround": ('bool',),
-    "PySide2.QtWidgets.QCompleter.splitPath": ('str',),
-    "PySide2.QtWidgets.QCompleter.widget": (),
-    "PySide2.QtWidgets.QCompleter.wrapAround": (),
-# class PySide2.QtWidgets.QDataWidgetMapper:
-# class PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy:
-    "PySide2.QtWidgets.QDataWidgetMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QDataWidgetMapper.addMapping": [('PySide2.QtWidgets.QWidget', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtWidgets.QDataWidgetMapper.clearMapping": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.currentIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.itemDelegate": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedPropertyName": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedSection": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.mappedWidgetAt": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.model": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.orientation": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.removeMapping": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDataWidgetMapper.revert": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.rootIndex": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setCurrentModelIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDataWidgetMapper.setSubmitPolicy": ('PySide2.QtWidgets.QDataWidgetMapper.SubmitPolicy',),
-    "PySide2.QtWidgets.QDataWidgetMapper.submit": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.submitPolicy": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toFirst": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toLast": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toNext": (),
-    "PySide2.QtWidgets.QDataWidgetMapper.toPrevious": (),
-# class PySide2.QtWidgets.QDateEdit:
-    "PySide2.QtWidgets.QDateEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDateTimeEdit:
-# class PySide2.QtWidgets.QDateTimeEdit.Section:
-# class PySide2.QtWidgets.QDateTimeEdit.Sections:
-    "PySide2.QtWidgets.QDateTimeEdit.__init__": [('PySide2.QtCore.QDate', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QDateTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('typing.Any', 'type', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QDateTimeEdit.calendar": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarPopup": (),
-    "PySide2.QtWidgets.QDateTimeEdit.calendarWidget": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clear": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMaximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.clearMinimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSection": (),
-    "PySide2.QtWidgets.QDateTimeEdit.currentSectionIndex": (),
-    "PySide2.QtWidgets.QDateTimeEdit.date": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.dateTimeFromText": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.displayFormat": (),
-    "PySide2.QtWidgets.QDateTimeEdit.displayedSections": (),
-    "PySide2.QtWidgets.QDateTimeEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.fixup": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSpinBox',),
-    "PySide2.QtWidgets.QDateTimeEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.maximumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDate": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumDateTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.minimumTime": (),
-    "PySide2.QtWidgets.QDateTimeEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionAt": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionCount": (),
-    "PySide2.QtWidgets.QDateTimeEdit.sectionText": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendar": ('PySide2.QtCore.QCalendar',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarPopup": ('bool',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCalendarWidget": ('PySide2.QtWidgets.QCalendarWidget',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setCurrentSectionIndex": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateRange": ('PySide2.QtCore.QDate', 'PySide2.QtCore.QDate'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setDateTimeRange": ('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setDisplayFormat": ('str',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMaximumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDate": ('PySide2.QtCore.QDate',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setMinimumTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setSelectedSection": ('PySide2.QtWidgets.QDateTimeEdit.Section',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTime": ('PySide2.QtCore.QTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeRange": ('PySide2.QtCore.QTime', 'PySide2.QtCore.QTime'),
-    "PySide2.QtWidgets.QDateTimeEdit.setTimeSpec": ('PySide2.QtCore.Qt.TimeSpec',),
-    "PySide2.QtWidgets.QDateTimeEdit.sizeHint": (),
-    "PySide2.QtWidgets.QDateTimeEdit.stepBy": ('int',),
-    "PySide2.QtWidgets.QDateTimeEdit.stepEnabled": (),
-    "PySide2.QtWidgets.QDateTimeEdit.textFromDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtWidgets.QDateTimeEdit.time": (),
-    "PySide2.QtWidgets.QDateTimeEdit.timeSpec": (),
-    "PySide2.QtWidgets.QDateTimeEdit.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDateTimeEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QDesktopWidget:
-    "PySide2.QtWidgets.QDesktopWidget.__init__": (),
-    "PySide2.QtWidgets.QDesktopWidget.availableGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.isVirtualDesktop": (),
-    "PySide2.QtWidgets.QDesktopWidget.numScreens": (),
-    "PySide2.QtWidgets.QDesktopWidget.primaryScreen": (),
-    "PySide2.QtWidgets.QDesktopWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDesktopWidget.screen": [(), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenCount": (),
-    "PySide2.QtWidgets.QDesktopWidget.screenGeometry": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QDesktopWidget.screenNumber": [('PySide2.QtCore.QPoint',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QDial:
-    "PySide2.QtWidgets.QDial.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDial.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDial.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QDial.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDial.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QDial.notchSize": (),
-    "PySide2.QtWidgets.QDial.notchTarget": (),
-    "PySide2.QtWidgets.QDial.notchesVisible": (),
-    "PySide2.QtWidgets.QDial.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDial.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDial.setNotchTarget": ('float',),
-    "PySide2.QtWidgets.QDial.setNotchesVisible": ('bool',),
-    "PySide2.QtWidgets.QDial.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QDial.sizeHint": (),
-    "PySide2.QtWidgets.QDial.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QDial.wrapping": (),
-# class PySide2.QtWidgets.QDialog:
-# class PySide2.QtWidgets.QDialog.DialogCode:
-    "PySide2.QtWidgets.QDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QDialog.accept": (),
-    "PySide2.QtWidgets.QDialog.adjustPosition": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDialog.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QDialog.done": ('int',),
-    "PySide2.QtWidgets.QDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QDialog.exec_": (),
-    "PySide2.QtWidgets.QDialog.extension": (),
-    "PySide2.QtWidgets.QDialog.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QDialog.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QDialog.open": (),
-    "PySide2.QtWidgets.QDialog.orientation": (),
-    "PySide2.QtWidgets.QDialog.reject": (),
-    "PySide2.QtWidgets.QDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QDialog.result": (),
-    "PySide2.QtWidgets.QDialog.setExtension": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDialog.setModal": ('bool',),
-    "PySide2.QtWidgets.QDialog.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialog.setResult": ('int',),
-    "PySide2.QtWidgets.QDialog.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QDialog.showExtension": ('bool',),
-    "PySide2.QtWidgets.QDialog.sizeHint": (),
-# class PySide2.QtWidgets.QDialogButtonBox:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonLayout:
-# class PySide2.QtWidgets.QDialogButtonBox.ButtonRole:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButton:
-# class PySide2.QtWidgets.QDialogButtonBox.StandardButtons:
-    "PySide2.QtWidgets.QDialogButtonBox.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QDialogButtonBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole'), ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',), ('str', 'PySide2.QtWidgets.QDialogButtonBox.ButtonRole')],
-    "PySide2.QtWidgets.QDialogButtonBox.button": ('PySide2.QtWidgets.QDialogButtonBox.StandardButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.buttons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.centerButtons": (),
-    "PySide2.QtWidgets.QDialogButtonBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.clear": (),
-    "PySide2.QtWidgets.QDialogButtonBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDialogButtonBox.orientation": (),
-    "PySide2.QtWidgets.QDialogButtonBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.setCenterButtons": ('bool',),
-    "PySide2.QtWidgets.QDialogButtonBox.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QDialogButtonBox.setStandardButtons": ('PySide2.QtWidgets.QDialogButtonBox.StandardButtons',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QDialogButtonBox.standardButtons": (),
-# class PySide2.QtWidgets.QDirModel:
-# class PySide2.QtWidgets.QDirModel.Roles:
-    "PySide2.QtWidgets.QDirModel.__init__": [('PySide2.QtCore.QObject',), ('typing.Sequence[str]', 'PySide2.QtCore.QDir.Filters', 'PySide2.QtCore.QDir.SortFlags', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QDirModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QDirModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QDirModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.filter": (),
-    "PySide2.QtWidgets.QDirModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QDirModel.iconProvider": (),
-    "PySide2.QtWidgets.QDirModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QDirModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.isReadOnly": (),
-    "PySide2.QtWidgets.QDirModel.lazyChildCount": (),
-    "PySide2.QtWidgets.QDirModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QDirModel.mimeTypes": (),
-    "PySide2.QtWidgets.QDirModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QDirModel.nameFilters": (),
-    "PySide2.QtWidgets.QDirModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QDirModel.refresh": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QDirModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QDirModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QDirModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QDirModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QDirModel.setLazyChildCount": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QDirModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QDirModel.setSorting": ('PySide2.QtCore.QDir.SortFlags',),
-    "PySide2.QtWidgets.QDirModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QDirModel.sorting": (),
-    "PySide2.QtWidgets.QDirModel.supportedDropActions": (),
-# class PySide2.QtWidgets.QDockWidget:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeature:
-# class PySide2.QtWidgets.QDockWidget.DockWidgetFeatures:
-    "PySide2.QtWidgets.QDockWidget.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QDockWidget.allowedAreas": (),
-    "PySide2.QtWidgets.QDockWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QDockWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QDockWidget.features": (),
-    "PySide2.QtWidgets.QDockWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionDockWidget',),
-    "PySide2.QtWidgets.QDockWidget.isAreaAllowed": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QDockWidget.isFloating": (),
-    "PySide2.QtWidgets.QDockWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QDockWidget.setAllowedAreas": ('PySide2.QtCore.Qt.DockWidgetAreas',),
-    "PySide2.QtWidgets.QDockWidget.setFeatures": ('PySide2.QtWidgets.QDockWidget.DockWidgetFeatures',),
-    "PySide2.QtWidgets.QDockWidget.setFloating": ('bool',),
-    "PySide2.QtWidgets.QDockWidget.setTitleBarWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDockWidget.titleBarWidget": (),
-    "PySide2.QtWidgets.QDockWidget.toggleViewAction": (),
-    "PySide2.QtWidgets.QDockWidget.widget": (),
-# class PySide2.QtWidgets.QDoubleSpinBox:
-    "PySide2.QtWidgets.QDoubleSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QDoubleSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.decimals": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.maximum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.minimum": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.prefix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.setDecimals": ('int',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMaximum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setMinimum": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setRange": ('float', 'float'),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSingleStep": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QDoubleSpinBox.setValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.stepType": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.suffix": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.textFromValue": ('float',),
-    "PySide2.QtWidgets.QDoubleSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QDoubleSpinBox.value": (),
-    "PySide2.QtWidgets.QDoubleSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QErrorMessage:
-    "PySide2.QtWidgets.QErrorMessage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QErrorMessage.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QErrorMessage.done": ('int',),
-    "PySide2.QtWidgets.QErrorMessage.qtHandler": (),
-    "PySide2.QtWidgets.QErrorMessage.showMessage": [('str',), ('str', 'str')],
-# class PySide2.QtWidgets.QFileDialog:
-# class PySide2.QtWidgets.QFileDialog.AcceptMode:
-# class PySide2.QtWidgets.QFileDialog.DialogLabel:
-# class PySide2.QtWidgets.QFileDialog.FileMode:
-# class PySide2.QtWidgets.QFileDialog.Option:
-# class PySide2.QtWidgets.QFileDialog.Options:
-# class PySide2.QtWidgets.QFileDialog.ViewMode:
-    "PySide2.QtWidgets.QFileDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str')],
-    "PySide2.QtWidgets.QFileDialog.accept": (),
-    "PySide2.QtWidgets.QFileDialog.acceptMode": (),
-    "PySide2.QtWidgets.QFileDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileDialog.confirmOverwrite": (),
-    "PySide2.QtWidgets.QFileDialog.defaultSuffix": (),
-    "PySide2.QtWidgets.QFileDialog.directory": (),
-    "PySide2.QtWidgets.QFileDialog.directoryUrl": (),
-    "PySide2.QtWidgets.QFileDialog.done": ('int',),
-    "PySide2.QtWidgets.QFileDialog.fileMode": (),
-    "PySide2.QtWidgets.QFileDialog.filter": (),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectory": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getExistingDirectoryUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileNames": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getOpenFileUrls": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileName": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtWidgets.QFileDialog.Options'),
-    "PySide2.QtWidgets.QFileDialog.getSaveFileUrl": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.QUrl', 'str', 'PySide2.QtWidgets.QFileDialog.Options', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QFileDialog.history": (),
-    "PySide2.QtWidgets.QFileDialog.iconProvider": (),
-    "PySide2.QtWidgets.QFileDialog.isNameFilterDetailsVisible": (),
-    "PySide2.QtWidgets.QFileDialog.isReadOnly": (),
-    "PySide2.QtWidgets.QFileDialog.itemDelegate": (),
-    "PySide2.QtWidgets.QFileDialog.labelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel',),
-    "PySide2.QtWidgets.QFileDialog.mimeTypeFilters": (),
-    "PySide2.QtWidgets.QFileDialog.nameFilters": (),
-    "PySide2.QtWidgets.QFileDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFileDialog.options": (),
-    "PySide2.QtWidgets.QFileDialog.proxyModel": (),
-    "PySide2.QtWidgets.QFileDialog.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileDialog.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QFileDialog.saveFileContent": ('PySide2.QtCore.QByteArray', 'str'),
-    "PySide2.QtWidgets.QFileDialog.saveState": (),
-    "PySide2.QtWidgets.QFileDialog.selectFile": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectMimeTypeFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.selectUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.selectedFiles": (),
-    "PySide2.QtWidgets.QFileDialog.selectedMimeTypeFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedNameFilter": (),
-    "PySide2.QtWidgets.QFileDialog.selectedUrls": (),
-    "PySide2.QtWidgets.QFileDialog.setAcceptMode": ('PySide2.QtWidgets.QFileDialog.AcceptMode',),
-    "PySide2.QtWidgets.QFileDialog.setConfirmOverwrite": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setDefaultSuffix": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setDirectory": [('PySide2.QtCore.QDir',), ('str',)],
-    "PySide2.QtWidgets.QFileDialog.setDirectoryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWidgets.QFileDialog.setFileMode": ('PySide2.QtWidgets.QFileDialog.FileMode',),
-    "PySide2.QtWidgets.QFileDialog.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileDialog.setHistory": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileDialog.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "PySide2.QtWidgets.QFileDialog.setLabelText": ('PySide2.QtWidgets.QFileDialog.DialogLabel', 'str'),
-    "PySide2.QtWidgets.QFileDialog.setMimeTypeFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilter": ('str',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilterDetailsVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setOption": ('PySide2.QtWidgets.QFileDialog.Option', 'bool'),
-    "PySide2.QtWidgets.QFileDialog.setOptions": ('PySide2.QtWidgets.QFileDialog.Options',),
-    "PySide2.QtWidgets.QFileDialog.setProxyModel": ('PySide2.QtCore.QAbstractProxyModel',),
-    "PySide2.QtWidgets.QFileDialog.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.setSidebarUrls": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWidgets.QFileDialog.setSupportedSchemes": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileDialog.setViewMode": ('PySide2.QtWidgets.QFileDialog.ViewMode',),
-    "PySide2.QtWidgets.QFileDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFileDialog.sidebarUrls": (),
-    "PySide2.QtWidgets.QFileDialog.supportedSchemes": (),
-    "PySide2.QtWidgets.QFileDialog.testOption": ('PySide2.QtWidgets.QFileDialog.Option',),
-    "PySide2.QtWidgets.QFileDialog.viewMode": (),
-# class PySide2.QtWidgets.QFileIconProvider:
-# class PySide2.QtWidgets.QFileIconProvider.IconType:
-# class PySide2.QtWidgets.QFileIconProvider.Option:
-# class PySide2.QtWidgets.QFileIconProvider.Options:
-    "PySide2.QtWidgets.QFileIconProvider.__init__": (),
-    "PySide2.QtWidgets.QFileIconProvider.icon": [('PySide2.QtCore.QFileInfo',), ('PySide2.QtWidgets.QFileIconProvider.IconType',)],
-    "PySide2.QtWidgets.QFileIconProvider.options": (),
-    "PySide2.QtWidgets.QFileIconProvider.setOptions": ('PySide2.QtWidgets.QFileIconProvider.Options',),
-    "PySide2.QtWidgets.QFileIconProvider.type": ('PySide2.QtCore.QFileInfo',),
-# class PySide2.QtWidgets.QFileSystemModel:
-# class PySide2.QtWidgets.QFileSystemModel.Option:
-# class PySide2.QtWidgets.QFileSystemModel.Options:
-# class PySide2.QtWidgets.QFileSystemModel.Roles:
-    "PySide2.QtWidgets.QFileSystemModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QFileSystemModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.dropMimeData": ('PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction', 'int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileIcon": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileInfo": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.fileName": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filePath": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.filter": (),
-    "PySide2.QtWidgets.QFileSystemModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.iconProvider": (),
-    "PySide2.QtWidgets.QFileSystemModel.index": [('int', 'int', 'PySide2.QtCore.QModelIndex'), ('str', 'int')],
-    "PySide2.QtWidgets.QFileSystemModel.isDir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.isReadOnly": (),
-    "PySide2.QtWidgets.QFileSystemModel.lastModified": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeData": ('typing.List[int]',),
-    "PySide2.QtWidgets.QFileSystemModel.mimeTypes": (),
-    "PySide2.QtWidgets.QFileSystemModel.mkdir": ('PySide2.QtCore.QModelIndex', 'str'),
-    "PySide2.QtWidgets.QFileSystemModel.myComputer": ('int',),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilterDisables": (),
-    "PySide2.QtWidgets.QFileSystemModel.nameFilters": (),
-    "PySide2.QtWidgets.QFileSystemModel.options": (),
-    "PySide2.QtWidgets.QFileSystemModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtWidgets.QFileSystemModel.remove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.resolveSymlinks": (),
-    "PySide2.QtWidgets.QFileSystemModel.rmdir": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.rootDirectory": (),
-    "PySide2.QtWidgets.QFileSystemModel.rootPath": (),
-    "PySide2.QtWidgets.QFileSystemModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtWidgets.QFileSystemModel.setFilter": ('PySide2.QtCore.QDir.Filters',),
-    "PySide2.QtWidgets.QFileSystemModel.setIconProvider": ('PySide2.QtWidgets.QFileIconProvider',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilterDisables": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setNameFilters": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QFileSystemModel.setOption": ('PySide2.QtWidgets.QFileSystemModel.Option', 'bool'),
-    "PySide2.QtWidgets.QFileSystemModel.setOptions": ('PySide2.QtWidgets.QFileSystemModel.Options',),
-    "PySide2.QtWidgets.QFileSystemModel.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setResolveSymlinks": ('bool',),
-    "PySide2.QtWidgets.QFileSystemModel.setRootPath": ('str',),
-    "PySide2.QtWidgets.QFileSystemModel.sibling": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QFileSystemModel.size": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QFileSystemModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QFileSystemModel.supportedDropActions": (),
-    "PySide2.QtWidgets.QFileSystemModel.testOption": ('PySide2.QtWidgets.QFileSystemModel.Option',),
-    "PySide2.QtWidgets.QFileSystemModel.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QFileSystemModel.type": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtWidgets.QFocusFrame:
-    "PySide2.QtWidgets.QFocusFrame.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFocusFrame.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFocusFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QFocusFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFocusFrame.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFocusFrame.widget": (),
-# class PySide2.QtWidgets.QFontComboBox:
-# class PySide2.QtWidgets.QFontComboBox.FontFilter:
-# class PySide2.QtWidgets.QFontComboBox.FontFilters:
-    "PySide2.QtWidgets.QFontComboBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFontComboBox.currentFont": (),
-    "PySide2.QtWidgets.QFontComboBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontComboBox.fontFilters": (),
-    "PySide2.QtWidgets.QFontComboBox.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontComboBox.setFontFilters": ('PySide2.QtWidgets.QFontComboBox.FontFilters',),
-    "PySide2.QtWidgets.QFontComboBox.setWritingSystem": ('PySide2.QtGui.QFontDatabase.WritingSystem',),
-    "PySide2.QtWidgets.QFontComboBox.sizeHint": (),
-    "PySide2.QtWidgets.QFontComboBox.writingSystem": (),
-# class PySide2.QtWidgets.QFontDialog:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOption:
-# class PySide2.QtWidgets.QFontDialog.FontDialogOptions:
-    "PySide2.QtWidgets.QFontDialog.__init__": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFontDialog.currentFont": (),
-    "PySide2.QtWidgets.QFontDialog.done": ('int',),
-    "PySide2.QtWidgets.QFontDialog.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QFontDialog.getFont": [('PySide2.QtGui.QFont', 'PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtWidgets.QFontDialog.FontDialogOptions'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFontDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QFontDialog.options": (),
-    "PySide2.QtWidgets.QFontDialog.selectedFont": (),
-    "PySide2.QtWidgets.QFontDialog.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QFontDialog.setOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption', 'bool'),
-    "PySide2.QtWidgets.QFontDialog.setOptions": ('PySide2.QtWidgets.QFontDialog.FontDialogOptions',),
-    "PySide2.QtWidgets.QFontDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QFontDialog.testOption": ('PySide2.QtWidgets.QFontDialog.FontDialogOption',),
-# class PySide2.QtWidgets.QFormLayout:
-# class PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy:
-# class PySide2.QtWidgets.QFormLayout.ItemRole:
-# class PySide2.QtWidgets.QFormLayout.RowWrapPolicy:
-    "PySide2.QtWidgets.QFormLayout.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QFormLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QFormLayout.addRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QLayout'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.count": (),
-    "PySide2.QtWidgets.QFormLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QFormLayout.fieldGrowthPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.formAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.getItemPosition": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getLayoutPosition": ('PySide2.QtWidgets.QLayout', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.getWidgetPosition": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QFormLayout.ItemRole'),
-    "PySide2.QtWidgets.QFormLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QFormLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QFormLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QFormLayout.insertRow": [('int', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QLayout'), ('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'), ('int', 'str', 'PySide2.QtWidgets.QLayout'), ('int', 'str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QFormLayout.invalidate": (),
-    "PySide2.QtWidgets.QFormLayout.itemAt": [('int',), ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole')],
-    "PySide2.QtWidgets.QFormLayout.labelAlignment": (),
-    "PySide2.QtWidgets.QFormLayout.labelForField": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QFormLayout.minimumSize": (),
-    "PySide2.QtWidgets.QFormLayout.removeRow": [('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',), ('int',)],
-    "PySide2.QtWidgets.QFormLayout.rowCount": (),
-    "PySide2.QtWidgets.QFormLayout.rowWrapPolicy": (),
-    "PySide2.QtWidgets.QFormLayout.setFieldGrowthPolicy": ('PySide2.QtWidgets.QFormLayout.FieldGrowthPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setFormAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFormLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setItem": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayoutItem'),
-    "PySide2.QtWidgets.QFormLayout.setLabelAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QFormLayout.setLayout": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QLayout'),
-    "PySide2.QtWidgets.QFormLayout.setRowWrapPolicy": ('PySide2.QtWidgets.QFormLayout.RowWrapPolicy',),
-    "PySide2.QtWidgets.QFormLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QFormLayout.setWidget": ('int', 'PySide2.QtWidgets.QFormLayout.ItemRole', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QFormLayout.sizeHint": (),
-    "PySide2.QtWidgets.QFormLayout.spacing": (),
-    "PySide2.QtWidgets.QFormLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QFormLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QFrame:
-# class PySide2.QtWidgets.QFrame.Shadow:
-# class PySide2.QtWidgets.QFrame.Shape:
-# class PySide2.QtWidgets.QFrame.StyleMask:
-    "PySide2.QtWidgets.QFrame.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QFrame.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.drawFrame": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QFrame.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QFrame.frameRect": (),
-    "PySide2.QtWidgets.QFrame.frameShadow": (),
-    "PySide2.QtWidgets.QFrame.frameShape": (),
-    "PySide2.QtWidgets.QFrame.frameStyle": (),
-    "PySide2.QtWidgets.QFrame.frameWidth": (),
-    "PySide2.QtWidgets.QFrame.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QFrame.lineWidth": (),
-    "PySide2.QtWidgets.QFrame.midLineWidth": (),
-    "PySide2.QtWidgets.QFrame.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QFrame.setFrameRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QFrame.setFrameShadow": ('PySide2.QtWidgets.QFrame.Shadow',),
-    "PySide2.QtWidgets.QFrame.setFrameShape": ('PySide2.QtWidgets.QFrame.Shape',),
-    "PySide2.QtWidgets.QFrame.setFrameStyle": ('int',),
-    "PySide2.QtWidgets.QFrame.setLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.setMidLineWidth": ('int',),
-    "PySide2.QtWidgets.QFrame.sizeHint": (),
-# class PySide2.QtWidgets.QGesture:
-# class PySide2.QtWidgets.QGesture.GestureCancelPolicy:
-    "PySide2.QtWidgets.QGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGesture.gestureCancelPolicy": (),
-    "PySide2.QtWidgets.QGesture.gestureType": (),
-    "PySide2.QtWidgets.QGesture.hasHotSpot": (),
-    "PySide2.QtWidgets.QGesture.hotSpot": (),
-    "PySide2.QtWidgets.QGesture.setGestureCancelPolicy": ('PySide2.QtWidgets.QGesture.GestureCancelPolicy',),
-    "PySide2.QtWidgets.QGesture.setHotSpot": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGesture.state": (),
-    "PySide2.QtWidgets.QGesture.unsetHotSpot": (),
-# class PySide2.QtWidgets.QGestureEvent:
-    "PySide2.QtWidgets.QGestureEvent.__init__": ('typing.Sequence[PySide2.QtWidgets.QGesture]',),
-    "PySide2.QtWidgets.QGestureEvent.accept": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.activeGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.canceledGestures": (),
-    "PySide2.QtWidgets.QGestureEvent.gesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGestureEvent.gestures": (),
-    "PySide2.QtWidgets.QGestureEvent.ignore": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.isAccepted": [(), ('PySide2.QtCore.Qt.GestureType',), ('PySide2.QtWidgets.QGesture',)],
-    "PySide2.QtWidgets.QGestureEvent.mapToGraphicsScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGestureEvent.setAccepted": [('PySide2.QtCore.Qt.GestureType', 'bool'), ('PySide2.QtWidgets.QGesture', 'bool'), ('bool',)],
-    "PySide2.QtWidgets.QGestureEvent.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGestureEvent.widget": (),
-# class PySide2.QtWidgets.QGestureRecognizer:
-# class PySide2.QtWidgets.QGestureRecognizer.Result:
-# class PySide2.QtWidgets.QGestureRecognizer.ResultFlag:
-    "PySide2.QtWidgets.QGestureRecognizer.__init__": (),
-    "PySide2.QtWidgets.QGestureRecognizer.create": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGestureRecognizer.recognize": ('PySide2.QtWidgets.QGesture', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGestureRecognizer.registerRecognizer": ('PySide2.QtWidgets.QGestureRecognizer',),
-    "PySide2.QtWidgets.QGestureRecognizer.reset": ('PySide2.QtWidgets.QGesture',),
-    "PySide2.QtWidgets.QGestureRecognizer.unregisterRecognizer": ('PySide2.QtCore.Qt.GestureType',),
-# class PySide2.QtWidgets.QGraphicsAnchor:
-    "PySide2.QtWidgets.QGraphicsAnchor.setSizePolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QGraphicsAnchor.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchor.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.spacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchor.unsetSpacing": (),
-# class PySide2.QtWidgets.QGraphicsAnchorLayout:
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Orientations'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.addCornerAnchors": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.anchor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint', 'PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.AnchorPoint'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsAnchorLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsBlurEffect:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHint:
-# class PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints:
-    "PySide2.QtWidgets.QGraphicsBlurEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurHints": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurHints": ('PySide2.QtWidgets.QGraphicsBlurEffect.BlurHints',),
-    "PySide2.QtWidgets.QGraphicsBlurEffect.setBlurRadius": ('float',),
-# class PySide2.QtWidgets.QGraphicsColorizeEffect:
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.setStrength": ('float',),
-    "PySide2.QtWidgets.QGraphicsColorizeEffect.strength": (),
-# class PySide2.QtWidgets.QGraphicsDropShadowEffect:
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.blurRadius": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.color": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.offset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setBlurRadius": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setOffset": [('PySide2.QtCore.QPointF',), ('float',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setXOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.setYOffset": ('float',),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.xOffset": (),
-    "PySide2.QtWidgets.QGraphicsDropShadowEffect.yOffset": (),
-# class PySide2.QtWidgets.QGraphicsEffect:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlag:
-# class PySide2.QtWidgets.QGraphicsEffect.ChangeFlags:
-# class PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode:
-    "PySide2.QtWidgets.QGraphicsEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEffect.boundingRectFor": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.drawSource": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsEffect.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsEffect.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceBoundingRect": ('PySide2.QtCore.Qt.CoordinateSystem',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceChanged": ('PySide2.QtWidgets.QGraphicsEffect.ChangeFlags',),
-    "PySide2.QtWidgets.QGraphicsEffect.sourceIsPixmap": (),
-    "PySide2.QtWidgets.QGraphicsEffect.sourcePixmap": ('PySide2.QtCore.Qt.CoordinateSystem', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QGraphicsEffect.PixmapPadMode'),
-    "PySide2.QtWidgets.QGraphicsEffect.update": (),
-    "PySide2.QtWidgets.QGraphicsEffect.updateBoundingRect": (),
-# class PySide2.QtWidgets.QGraphicsEllipseItem:
-    "PySide2.QtWidgets.QGraphicsEllipseItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setSpanAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.setStartAngle": ('int',),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.spanAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.startAngle": (),
-    "PySide2.QtWidgets.QGraphicsEllipseItem.type": (),
-# class PySide2.QtWidgets.QGraphicsGridLayout:
-    "PySide2.QtWidgets.QGraphicsGridLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.addItem": [('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnPreferredWidth": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.columnStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.itemAt": [('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowAlignment": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowPreferredHeight": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.rowStretchFactor": ('int',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnFixedWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMaximumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnMinimumWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnPreferredWidth": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setColumnStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setHorizontalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowAlignment": ('int', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowFixedHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMaximumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowMinimumHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowPreferredHeight": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setRowStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.setVerticalSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsGridLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGraphicsItem:
-# class PySide2.QtWidgets.QGraphicsItem.CacheMode:
-# class PySide2.QtWidgets.QGraphicsItem.Extension:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag:
-# class PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags:
-# class PySide2.QtWidgets.QGraphicsItem.PanelModality:
-    "PySide2.QtWidgets.QGraphicsItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.acceptDrops": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptHoverEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptTouchEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.acceptedMouseButtons": (),
-    "PySide2.QtWidgets.QGraphicsItem.addToIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.advance": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegion": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.boundingRegionGranularity": (),
-    "PySide2.QtWidgets.QGraphicsItem.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsItem.childItems": (),
-    "PySide2.QtWidgets.QGraphicsItem.childrenBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.clipPath": (),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidesWithPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsItem.collidingItems": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsItem.commonAncestorItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.cursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.data": ('int',),
-    "PySide2.QtWidgets.QGraphicsItem.deviceTransform": ('PySide2.QtGui.QTransform',),
-    "PySide2.QtWidgets.QGraphicsItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.effectiveOpacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsItem.filtersChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.flags": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.focusProxy": (),
-    "PySide2.QtWidgets.QGraphicsItem.focusScopeItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.grabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.graphicsEffect": (),
-    "PySide2.QtWidgets.QGraphicsItem.group": (),
-    "PySide2.QtWidgets.QGraphicsItem.handlesChildEvents": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.hide": (),
-    "PySide2.QtWidgets.QGraphicsItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodHints": (),
-    "PySide2.QtWidgets.QGraphicsItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsItem.installSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isActive": (),
-    "PySide2.QtWidgets.QGraphicsItem.isAncestorOf": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isBlockedByModalPanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isClipped": (),
-    "PySide2.QtWidgets.QGraphicsItem.isEnabled": (),
-    "PySide2.QtWidgets.QGraphicsItem.isObscured": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isPanel": (),
-    "PySide2.QtWidgets.QGraphicsItem.isSelected": (),
-    "PySide2.QtWidgets.QGraphicsItem.isUnderMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisible": (),
-    "PySide2.QtWidgets.QGraphicsItem.isVisibleTo": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.isWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.isWindow": (),
-    "PySide2.QtWidgets.QGraphicsItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.itemTransform": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mapFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectFromScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToParent": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapRectToScene": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToItem": [('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QPointF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QRectF'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPainterPath'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtGui.QPolygonF'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float'), ('PySide2.QtWidgets.QGraphicsItem', 'float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToParent": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.mapToScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.matrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.moveBy": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItem.opacity": (),
-    "PySide2.QtWidgets.QGraphicsItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItem.panel": (),
-    "PySide2.QtWidgets.QGraphicsItem.panelModality": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.parentWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.pos": (),
-    "PySide2.QtWidgets.QGraphicsItem.prepareGeometryChange": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeFromIndex": (),
-    "PySide2.QtWidgets.QGraphicsItem.removeSceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.rotation": (),
-    "PySide2.QtWidgets.QGraphicsItem.scale": (),
-    "PySide2.QtWidgets.QGraphicsItem.scene": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.sceneEventFilter": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsItem.sceneMatrix": (),
-    "PySide2.QtWidgets.QGraphicsItem.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsItem.sceneTransform": (),
-    "PySide2.QtWidgets.QGraphicsItem.scroll": ('float', 'float', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsItem.setActive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setBoundingRegionGranularity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setCacheMode": ('PySide2.QtWidgets.QGraphicsItem.CacheMode', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QGraphicsItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QGraphicsItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsItem.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFiltersChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setFlag": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setFlags": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemFlags',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsItem.setFocusProxy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QGraphicsItem.setGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsItem.setHandlesChildEvents": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QGraphicsItem.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setPanelModality": ('PySide2.QtWidgets.QGraphicsItem.PanelModality',),
-    "PySide2.QtWidgets.QGraphicsItem.setParentItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.setPos": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setRotation": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QGraphicsItem.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsItem.setTransformOriginPoint": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.setTransformations": ('typing.Sequence[PySide2.QtWidgets.QGraphicsTransform]',),
-    "PySide2.QtWidgets.QGraphicsItem.setVisible": ('bool',),
-    "PySide2.QtWidgets.QGraphicsItem.setX": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setY": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.setZValue": ('float',),
-    "PySide2.QtWidgets.QGraphicsItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsItem.show": (),
-    "PySide2.QtWidgets.QGraphicsItem.stackBefore": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItem.toGraphicsObject": (),
-    "PySide2.QtWidgets.QGraphicsItem.toolTip": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelItem": (),
-    "PySide2.QtWidgets.QGraphicsItem.topLevelWidget": (),
-    "PySide2.QtWidgets.QGraphicsItem.transform": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformOriginPoint": (),
-    "PySide2.QtWidgets.QGraphicsItem.transformations": (),
-    "PySide2.QtWidgets.QGraphicsItem.type": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabKeyboard": (),
-    "PySide2.QtWidgets.QGraphicsItem.ungrabMouse": (),
-    "PySide2.QtWidgets.QGraphicsItem.unsetCursor": (),
-    "PySide2.QtWidgets.QGraphicsItem.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsItem.updateMicroFocus": (),
-    "PySide2.QtWidgets.QGraphicsItem.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsItem.window": (),
-    "PySide2.QtWidgets.QGraphicsItem.x": (),
-    "PySide2.QtWidgets.QGraphicsItem.y": (),
-    "PySide2.QtWidgets.QGraphicsItem.zValue": (),
-# class PySide2.QtWidgets.QGraphicsItemAnimation:
-    "PySide2.QtWidgets.QGraphicsItemAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.afterAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.beforeAnimationStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.clear": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.horizontalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.item": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.matrixAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.posList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.reset": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.rotationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.scaleList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setPosAt": ('float', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setRotationAt": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setScaleAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setShearAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setStep": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTimeLine": ('PySide2.QtCore.QTimeLine',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.setTranslationAt": ('float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.shearList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.timeLine": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.transformAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.translationList": (),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalScaleAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.verticalShearAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.xTranslationAt": ('float',),
-    "PySide2.QtWidgets.QGraphicsItemAnimation.yTranslationAt": ('float',),
-# class PySide2.QtWidgets.QGraphicsItemGroup:
-    "PySide2.QtWidgets.QGraphicsItemGroup.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.addToGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsItemGroup.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsItemGroup.removeFromGroup": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsItemGroup.type": (),
-# class PySide2.QtWidgets.QGraphicsLayout:
-    "PySide2.QtWidgets.QGraphicsLayout.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.activate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.addChildLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayout.instantInvalidatePropagation": (),
-    "PySide2.QtWidgets.QGraphicsLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLayout.isActivated": (),
-    "PySide2.QtWidgets.QGraphicsLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLayout.setContentsMargins": ('float', 'float', 'float', 'float'),
-    "PySide2.QtWidgets.QGraphicsLayout.setInstantInvalidatePropagation": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayout.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QGraphicsLayoutItem:
-    "PySide2.QtWidgets.QGraphicsLayoutItem.__init__": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'bool'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.contentsRect": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.effectiveSizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.graphicsItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.isLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.maximumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.minimumWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.ownedByLayout": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.parentLayoutItem": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredHeight": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredSize": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.preferredWidth": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setGraphicsItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMaximumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setMinimumWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setOwnedByLayout": ('bool',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setParentLayoutItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredHeight": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredSize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setPreferredWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.sizePolicy": (),
-    "PySide2.QtWidgets.QGraphicsLayoutItem.updateGeometry": (),
-# class PySide2.QtWidgets.QGraphicsLineItem:
-    "PySide2.QtWidgets.QGraphicsLineItem.__init__": [('PySide2.QtCore.QLineF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsLineItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsLineItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsLineItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsLineItem.line": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsLineItem.pen": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.setLine": [('PySide2.QtCore.QLineF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsLineItem.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtWidgets.QGraphicsLineItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsLineItem.type": (),
-# class PySide2.QtWidgets.QGraphicsLinearLayout:
-    "PySide2.QtWidgets.QGraphicsLinearLayout.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QGraphicsLayoutItem'), ('PySide2.QtWidgets.QGraphicsLayoutItem',)],
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.addStretch": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.alignment": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.count": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.dump": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertItem": ('int', 'PySide2.QtWidgets.QGraphicsLayoutItem'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.insertStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.invalidate": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.itemSpacing": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.orientation": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeAt": ('int',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.removeItem": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setAlignment": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setItemSpacing": ('int', 'float'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setSpacing": ('float',),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.setStretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem', 'int'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.spacing": (),
-    "PySide2.QtWidgets.QGraphicsLinearLayout.stretchFactor": ('PySide2.QtWidgets.QGraphicsLayoutItem',),
-# class PySide2.QtWidgets.QGraphicsObject:
-    "PySide2.QtWidgets.QGraphicsObject.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsObject.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsObject.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QGraphicsObject.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QGraphicsObject.updateMicroFocus": (),
-# class PySide2.QtWidgets.QGraphicsOpacityEffect:
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.draw": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacity": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.opacityMask": (),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacity": ('float',),
-    "PySide2.QtWidgets.QGraphicsOpacityEffect.setOpacityMask": ('PySide2.QtGui.QBrush',),
-# class PySide2.QtWidgets.QGraphicsPathItem:
-    "PySide2.QtWidgets.QGraphicsPathItem.__init__": [('PySide2.QtGui.QPainterPath', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPathItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPathItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPathItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPathItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPathItem.path": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.setPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QGraphicsPathItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPathItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPixmapItem:
-# class PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode:
-    "PySide2.QtWidgets.QGraphicsPixmapItem.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.offset": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.pixmap": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setOffset": [('PySide2.QtCore.QPointF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setShapeMode": ('PySide2.QtWidgets.QGraphicsPixmapItem.ShapeMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.setTransformationMode": ('PySide2.QtCore.Qt.TransformationMode',),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.shapeMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.transformationMode": (),
-    "PySide2.QtWidgets.QGraphicsPixmapItem.type": (),
-# class PySide2.QtWidgets.QGraphicsPolygonItem:
-    "PySide2.QtWidgets.QGraphicsPolygonItem.__init__": [('PySide2.QtGui.QPolygonF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',)],
-    "PySide2.QtWidgets.QGraphicsPolygonItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.fillRule": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.polygon": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setFillRule": ('PySide2.QtCore.Qt.FillRule',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.setPolygon": ('PySide2.QtGui.QPolygonF',),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsPolygonItem.type": (),
-# class PySide2.QtWidgets.QGraphicsProxyWidget:
-    "PySide2.QtWidgets.QGraphicsProxyWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.createProxyForChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.newProxyWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setGeometry": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.subWidgetRect": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsProxyWidget.widget": (),
-# class PySide2.QtWidgets.QGraphicsRectItem:
-    "PySide2.QtWidgets.QGraphicsRectItem.__init__": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsItem'), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsRectItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsRectItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsRectItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsRectItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsRectItem.rect": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsRectItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsRectItem.type": (),
-# class PySide2.QtWidgets.QGraphicsRotation:
-    "PySide2.QtWidgets.QGraphicsRotation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsRotation.angle": (),
-    "PySide2.QtWidgets.QGraphicsRotation.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsRotation.axis": (),
-    "PySide2.QtWidgets.QGraphicsRotation.origin": (),
-    "PySide2.QtWidgets.QGraphicsRotation.setAngle": ('float',),
-    "PySide2.QtWidgets.QGraphicsRotation.setAxis": [('PySide2.QtCore.Qt.Axis',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtWidgets.QGraphicsRotation.setOrigin": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtWidgets.QGraphicsScale:
-    "PySide2.QtWidgets.QGraphicsScale.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsScale.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsScale.origin": (),
-    "PySide2.QtWidgets.QGraphicsScale.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtWidgets.QGraphicsScale.setXScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setYScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.setZScale": ('float',),
-    "PySide2.QtWidgets.QGraphicsScale.xScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.yScale": (),
-    "PySide2.QtWidgets.QGraphicsScale.zScale": (),
-# class PySide2.QtWidgets.QGraphicsScene:
-# class PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayer:
-# class PySide2.QtWidgets.QGraphicsScene.SceneLayers:
-    "PySide2.QtWidgets.QGraphicsScene.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QGraphicsScene.activePanel": (),
-    "PySide2.QtWidgets.QGraphicsScene.activeWindow": (),
-    "PySide2.QtWidgets.QGraphicsScene.addEllipse": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.addLine": [('PySide2.QtCore.QLineF', 'PySide2.QtGui.QPen'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen')],
-    "PySide2.QtWidgets.QGraphicsScene.addPath": ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QGraphicsScene.addPolygon": ('PySide2.QtGui.QPolygonF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QGraphicsScene.addRect": [('PySide2.QtCore.QRectF', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush'), ('float', 'float', 'float', 'float', 'PySide2.QtGui.QPen', 'PySide2.QtGui.QBrush')],
-    "PySide2.QtWidgets.QGraphicsScene.addSimpleText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addText": ('str', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QGraphicsScene.addWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsScene.advance": (),
-    "PySide2.QtWidgets.QGraphicsScene.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.bspTreeDepth": (),
-    "PySide2.QtWidgets.QGraphicsScene.clear": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.clearSelection": (),
-    "PySide2.QtWidgets.QGraphicsScene.collidingItems": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.ItemSelectionMode'),
-    "PySide2.QtWidgets.QGraphicsScene.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.createItemGroup": ('typing.Sequence[PySide2.QtWidgets.QGraphicsItem]',),
-    "PySide2.QtWidgets.QGraphicsScene.destroyItemGroup": ('PySide2.QtWidgets.QGraphicsItemGroup',),
-    "PySide2.QtWidgets.QGraphicsScene.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsScene.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.focusItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.focusOnTouch": (),
-    "PySide2.QtWidgets.QGraphicsScene.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.font": (),
-    "PySide2.QtWidgets.QGraphicsScene.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsScene.hasFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.height": (),
-    "PySide2.QtWidgets.QGraphicsScene.helpEvent": ('PySide2.QtWidgets.QGraphicsSceneHelpEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsScene.invalidate": [('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'), ('float', 'float', 'float', 'float', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers')],
-    "PySide2.QtWidgets.QGraphicsScene.isActive": (),
-    "PySide2.QtWidgets.QGraphicsScene.isSortCacheEnabled": (),
-    "PySide2.QtWidgets.QGraphicsScene.itemAt": [('PySide2.QtCore.QPointF', 'PySide2.QtGui.QTransform'), ('float', 'float', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemIndexMethod": (),
-    "PySide2.QtWidgets.QGraphicsScene.items": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtCore.Qt.SortOrder',), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPolygonF', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtCore.Qt.SortOrder', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.itemsBoundingRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.minimumRenderSize": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseGrabberItem": (),
-    "PySide2.QtWidgets.QGraphicsScene.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.palette": (),
-    "PySide2.QtWidgets.QGraphicsScene.removeItem": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.render": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'),
-    "PySide2.QtWidgets.QGraphicsScene.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectedItems": (),
-    "PySide2.QtWidgets.QGraphicsScene.selectionArea": (),
-    "PySide2.QtWidgets.QGraphicsScene.sendEvent": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QGraphicsScene.setActivePanel": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsScene.setActiveWindow": ('PySide2.QtWidgets.QGraphicsWidget',),
-    "PySide2.QtWidgets.QGraphicsScene.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setBspTreeDepth": ('int',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocus": ('PySide2.QtCore.Qt.FocusReason',),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusItem": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.FocusReason'),
-    "PySide2.QtWidgets.QGraphicsScene.setFocusOnTouch": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsScene.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsScene.setItemIndexMethod": ('PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod',),
-    "PySide2.QtWidgets.QGraphicsScene.setMinimumRenderSize": ('float',),
-    "PySide2.QtWidgets.QGraphicsScene.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsScene.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.setSelectionArea": [('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionOperation', 'PySide2.QtCore.Qt.ItemSelectionMode', 'PySide2.QtGui.QTransform'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtGui.QTransform')],
-    "PySide2.QtWidgets.QGraphicsScene.setSortCacheEnabled": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStickyFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsScene.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsScene.stickyFocus": (),
-    "PySide2.QtWidgets.QGraphicsScene.style": (),
-    "PySide2.QtWidgets.QGraphicsScene.update": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsScene.views": (),
-    "PySide2.QtWidgets.QGraphicsScene.wheelEvent": ('PySide2.QtWidgets.QGraphicsSceneWheelEvent',),
-    "PySide2.QtWidgets.QGraphicsScene.width": (),
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent:
-# class PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason:
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.reason": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setReason": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.Reason',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneContextMenuEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneDragDropEvent:
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.acceptProposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.dropAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.mimeData": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.possibleActions": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.proposedAction": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setDropAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setPossibleActions": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setProposedAction": ('PySide2.QtCore.Qt.DropAction',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneDragDropEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneEvent:
-    "PySide2.QtWidgets.QGraphicsSceneEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneEvent.widget": (),
-# class PySide2.QtWidgets.QGraphicsSceneHelpEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHelpEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneHoverEvent:
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneHoverEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSceneMouseEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.button": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScenePos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.flags": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.lastScreenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScenePos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtonDownScreenPos": ('PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setFlags": ('PySide2.QtCore.Qt.MouseEventFlags',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setLastScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.setSource": ('PySide2.QtCore.Qt.MouseEventSource',),
-    "PySide2.QtWidgets.QGraphicsSceneMouseEvent.source": (),
-# class PySide2.QtWidgets.QGraphicsSceneMoveEvent:
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.newPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.oldPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setNewPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneMoveEvent.setOldPos": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QGraphicsSceneResizeEvent:
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.__init__": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.newSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.oldSize": (),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setNewSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtWidgets.QGraphicsSceneResizeEvent.setOldSize": ('PySide2.QtCore.QSizeF',),
-# class PySide2.QtWidgets.QGraphicsSceneWheelEvent:
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.__init__": ('PySide2.QtCore.QEvent.Type',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.buttons": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.delta": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.modifiers": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.orientation": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.pos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.scenePos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.screenPos": (),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setDelta": ('int',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setModifiers": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setPos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScenePos": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSceneWheelEvent.setScreenPos": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtWidgets.QGraphicsSimpleTextItem:
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.setText": ('str',),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.text": (),
-    "PySide2.QtWidgets.QGraphicsSimpleTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTextItem:
-    "PySide2.QtWidgets.QGraphicsTextItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtWidgets.QGraphicsTextItem.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsTextItem.contextMenuEvent": ('PySide2.QtWidgets.QGraphicsSceneContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.defaultTextColor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.document": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dragMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.dropEvent": ('PySide2.QtWidgets.QGraphicsSceneDragDropEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.extension": ('typing.Any',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.font": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverEnterEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsTextItem.isObscuredBy": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseDoubleClickEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mousePressEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.mouseReleaseEvent": ('PySide2.QtWidgets.QGraphicsSceneMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.opaqueArea": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.openExternalLinks": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsTextItem.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDefaultTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setHtml": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setPlainText": ('str',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QGraphicsTextItem.setTextWidth": ('float',),
-    "PySide2.QtWidgets.QGraphicsTextItem.shape": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.tabChangesFocus": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textCursor": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textInteractionFlags": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.textWidth": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toHtml": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.toPlainText": (),
-    "PySide2.QtWidgets.QGraphicsTextItem.type": (),
-# class PySide2.QtWidgets.QGraphicsTransform:
-    "PySide2.QtWidgets.QGraphicsTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QGraphicsTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtWidgets.QGraphicsTransform.update": (),
-# class PySide2.QtWidgets.QGraphicsView:
-# class PySide2.QtWidgets.QGraphicsView.CacheMode:
-# class PySide2.QtWidgets.QGraphicsView.CacheModeFlag:
-# class PySide2.QtWidgets.QGraphicsView.DragMode:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlag:
-# class PySide2.QtWidgets.QGraphicsView.OptimizationFlags:
-# class PySide2.QtWidgets.QGraphicsView.ViewportAnchor:
-# class PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode:
-    "PySide2.QtWidgets.QGraphicsView.__init__": [('PySide2.QtWidgets.QGraphicsScene', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGraphicsView.alignment": (),
-    "PySide2.QtWidgets.QGraphicsView.backgroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.cacheMode": (),
-    "PySide2.QtWidgets.QGraphicsView.centerOn": [('PySide2.QtCore.QPointF',), ('PySide2.QtWidgets.QGraphicsItem',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.dragMode": (),
-    "PySide2.QtWidgets.QGraphicsView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsView.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawForeground": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtWidgets.QGraphicsView.drawItems": ('PySide2.QtGui.QPainter', 'int', 'typing.Sequence[PySide2.QtWidgets.QGraphicsItem]', 'typing.Sequence[PySide2.QtWidgets.QStyleOptionGraphicsItem]'),
-    "PySide2.QtWidgets.QGraphicsView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QGraphicsView.ensureVisible": [('PySide2.QtCore.QRectF', 'int', 'int'), ('PySide2.QtWidgets.QGraphicsItem', 'int', 'int'), ('float', 'float', 'float', 'float', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.fitInView": [('PySide2.QtCore.QRectF', 'PySide2.QtCore.Qt.AspectRatioMode'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.AspectRatioMode'), ('float', 'float', 'float', 'float', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsView.foregroundBrush": (),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QGraphicsView.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QGraphicsView.invalidateScene": ('PySide2.QtCore.QRectF', 'PySide2.QtWidgets.QGraphicsScene.SceneLayers'),
-    "PySide2.QtWidgets.QGraphicsView.isInteractive": (),
-    "PySide2.QtWidgets.QGraphicsView.isTransformed": (),
-    "PySide2.QtWidgets.QGraphicsView.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.items": [(), ('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPainterPath', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('PySide2.QtGui.QPolygon', 'PySide2.QtCore.Qt.ItemSelectionMode'), ('int', 'int'), ('int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.ItemSelectionMode')],
-    "PySide2.QtWidgets.QGraphicsView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mapFromScene": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QRectF',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygonF',), ('float', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.mapToScene": [('PySide2.QtCore.QPoint',), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QPainterPath',), ('PySide2.QtGui.QPolygon',), ('int', 'int'), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QGraphicsView.matrix": (),
-    "PySide2.QtWidgets.QGraphicsView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGraphicsView.optimizationFlags": (),
-    "PySide2.QtWidgets.QGraphicsView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGraphicsView.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.AspectRatioMode')],
-    "PySide2.QtWidgets.QGraphicsView.renderHints": (),
-    "PySide2.QtWidgets.QGraphicsView.resetCachedContent": (),
-    "PySide2.QtWidgets.QGraphicsView.resetMatrix": (),
-    "PySide2.QtWidgets.QGraphicsView.resetTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsView.rotate": ('float',),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandRect": (),
-    "PySide2.QtWidgets.QGraphicsView.rubberBandSelectionMode": (),
-    "PySide2.QtWidgets.QGraphicsView.scale": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.scene": (),
-    "PySide2.QtWidgets.QGraphicsView.sceneRect": (),
-    "PySide2.QtWidgets.QGraphicsView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QGraphicsView.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QGraphicsView.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setCacheMode": ('PySide2.QtWidgets.QGraphicsView.CacheMode',),
-    "PySide2.QtWidgets.QGraphicsView.setDragMode": ('PySide2.QtWidgets.QGraphicsView.DragMode',),
-    "PySide2.QtWidgets.QGraphicsView.setForegroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QGraphicsView.setInteractive": ('bool',),
-    "PySide2.QtWidgets.QGraphicsView.setMatrix": ('PySide2.QtGui.QMatrix', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlag": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlag', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setOptimizationFlags": ('PySide2.QtWidgets.QGraphicsView.OptimizationFlags',),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHint": ('PySide2.QtGui.QPainter.RenderHint', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setRenderHints": ('PySide2.QtGui.QPainter.RenderHints',),
-    "PySide2.QtWidgets.QGraphicsView.setResizeAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setRubberBandSelectionMode": ('PySide2.QtCore.Qt.ItemSelectionMode',),
-    "PySide2.QtWidgets.QGraphicsView.setScene": ('PySide2.QtWidgets.QGraphicsScene',),
-    "PySide2.QtWidgets.QGraphicsView.setSceneRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsView.setTransform": ('PySide2.QtGui.QTransform', 'bool'),
-    "PySide2.QtWidgets.QGraphicsView.setTransformationAnchor": ('PySide2.QtWidgets.QGraphicsView.ViewportAnchor',),
-    "PySide2.QtWidgets.QGraphicsView.setViewportUpdateMode": ('PySide2.QtWidgets.QGraphicsView.ViewportUpdateMode',),
-    "PySide2.QtWidgets.QGraphicsView.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QGraphicsView.shear": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsView.sizeHint": (),
-    "PySide2.QtWidgets.QGraphicsView.transform": (),
-    "PySide2.QtWidgets.QGraphicsView.transformationAnchor": (),
-    "PySide2.QtWidgets.QGraphicsView.translate": ('float', 'float'),
-    "PySide2.QtWidgets.QGraphicsView.updateScene": ('typing.Sequence[PySide2.QtCore.QRectF]',),
-    "PySide2.QtWidgets.QGraphicsView.updateSceneRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtWidgets.QGraphicsView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsView.viewportTransform": (),
-    "PySide2.QtWidgets.QGraphicsView.viewportUpdateMode": (),
-    "PySide2.QtWidgets.QGraphicsView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QGraphicsWidget:
-    "PySide2.QtWidgets.QGraphicsWidget.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QGraphicsWidget.actions": (),
-    "PySide2.QtWidgets.QGraphicsWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QGraphicsWidget.adjustSize": (),
-    "PySide2.QtWidgets.QGraphicsWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QGraphicsWidget.boundingRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.close": (),
-    "PySide2.QtWidgets.QGraphicsWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QGraphicsWidget.focusWidget": (),
-    "PySide2.QtWidgets.QGraphicsWidget.font": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.getWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.grabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QGraphicsWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverLeaveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.hoverMoveEvent": ('PySide2.QtWidgets.QGraphicsSceneHoverEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOption',),
-    "PySide2.QtWidgets.QGraphicsWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QGraphicsWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QGraphicsWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QGraphicsWidget.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.layout": (),
-    "PySide2.QtWidgets.QGraphicsWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.moveEvent": ('PySide2.QtWidgets.QGraphicsSceneMoveEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.paintWindowFrame": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.palette": (),
-    "PySide2.QtWidgets.QGraphicsWidget.polishEvent": (),
-    "PySide2.QtWidgets.QGraphicsWidget.propertyChange": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QGraphicsWidget.rect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QGraphicsWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QGraphicsWidget.resize": [('PySide2.QtCore.QSizeF',), ('float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.resizeEvent": ('PySide2.QtWidgets.QGraphicsSceneResizeEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.sceneEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QGraphicsWidget.setContentsMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QGraphicsWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QGraphicsWidget.setGeometry": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setLayout": ('PySide2.QtWidgets.QGraphicsLayout',),
-    "PySide2.QtWidgets.QGraphicsWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QGraphicsWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QGraphicsWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QGraphicsWidget.setTabOrder": ('PySide2.QtWidgets.QGraphicsWidget', 'PySide2.QtWidgets.QGraphicsWidget'),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowFrameMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtWidgets.QGraphicsWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QGraphicsWidget.shape": (),
-    "PySide2.QtWidgets.QGraphicsWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.size": (),
-    "PySide2.QtWidgets.QGraphicsWidget.sizeHint": ('PySide2.QtCore.Qt.SizeHint', 'PySide2.QtCore.QSizeF'),
-    "PySide2.QtWidgets.QGraphicsWidget.style": (),
-    "PySide2.QtWidgets.QGraphicsWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QGraphicsWidget.type": (),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabKeyboardEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.ungrabMouseEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QGraphicsWidget.unsetWindowFrameMargins": (),
-    "PySide2.QtWidgets.QGraphicsWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFlags": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameGeometry": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameRect": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowFrameSectionAt": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QGraphicsWidget.windowTitle": (),
-    "PySide2.QtWidgets.QGraphicsWidget.windowType": (),
-# class PySide2.QtWidgets.QGridLayout:
-    "PySide2.QtWidgets.QGridLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QGridLayout.addItem": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QLayoutItem', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addLayout": [('PySide2.QtWidgets.QLayout', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QLayout', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.addWidget": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QGridLayout.cellRect": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.columnCount": (),
-    "PySide2.QtWidgets.QGridLayout.columnMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.columnStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.count": (),
-    "PySide2.QtWidgets.QGridLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QGridLayout.getItemPosition": ('int',),
-    "PySide2.QtWidgets.QGridLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QGridLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.horizontalSpacing": (),
-    "PySide2.QtWidgets.QGridLayout.invalidate": (),
-    "PySide2.QtWidgets.QGridLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.itemAtPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.maximumSize": (),
-    "PySide2.QtWidgets.QGridLayout.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QGridLayout.minimumSize": (),
-    "PySide2.QtWidgets.QGridLayout.originCorner": (),
-    "PySide2.QtWidgets.QGridLayout.rowCount": (),
-    "PySide2.QtWidgets.QGridLayout.rowMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QGridLayout.rowStretch": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setColumnMinimumWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setColumnStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setDefaultPositioning": ('int', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QGridLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QGridLayout.setHorizontalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setOriginCorner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QGridLayout.setRowMinimumHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setRowStretch": ('int', 'int'),
-    "PySide2.QtWidgets.QGridLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.setVerticalSpacing": ('int',),
-    "PySide2.QtWidgets.QGridLayout.sizeHint": (),
-    "PySide2.QtWidgets.QGridLayout.spacing": (),
-    "PySide2.QtWidgets.QGridLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QGridLayout.verticalSpacing": (),
-# class PySide2.QtWidgets.QGroupBox:
-    "PySide2.QtWidgets.QGroupBox.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QGroupBox.alignment": (),
-    "PySide2.QtWidgets.QGroupBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QGroupBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QGroupBox.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QGroupBox.initStyleOption": ('PySide2.QtWidgets.QStyleOptionGroupBox',),
-    "PySide2.QtWidgets.QGroupBox.isCheckable": (),
-    "PySide2.QtWidgets.QGroupBox.isChecked": (),
-    "PySide2.QtWidgets.QGroupBox.isFlat": (),
-    "PySide2.QtWidgets.QGroupBox.minimumSizeHint": (),
-    "PySide2.QtWidgets.QGroupBox.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QGroupBox.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QGroupBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QGroupBox.setAlignment": ('int',),
-    "PySide2.QtWidgets.QGroupBox.setCheckable": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setChecked": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setFlat": ('bool',),
-    "PySide2.QtWidgets.QGroupBox.setTitle": ('str',),
-    "PySide2.QtWidgets.QGroupBox.title": (),
-# class PySide2.QtWidgets.QHBoxLayout:
-    "PySide2.QtWidgets.QHBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QHeaderView:
-# class PySide2.QtWidgets.QHeaderView.ResizeMode:
-    "PySide2.QtWidgets.QHeaderView.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QHeaderView.cascadingSectionResizes": (),
-    "PySide2.QtWidgets.QHeaderView.count": (),
-    "PySide2.QtWidgets.QHeaderView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QHeaderView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QHeaderView.defaultAlignment": (),
-    "PySide2.QtWidgets.QHeaderView.defaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.doItemsLayout": (),
-    "PySide2.QtWidgets.QHeaderView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.headerDataChanged": ('PySide2.QtCore.Qt.Orientation', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.hiddenSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.hideSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.highlightSections": (),
-    "PySide2.QtWidgets.QHeaderView.horizontalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QHeaderView.initStyleOption": [('PySide2.QtWidgets.QStyleOptionFrame',), ('PySide2.QtWidgets.QStyleOptionHeader',)],
-    "PySide2.QtWidgets.QHeaderView.initialize": (),
-    "PySide2.QtWidgets.QHeaderView.initializeSections": [(), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.isFirstSectionMovable": (),
-    "PySide2.QtWidgets.QHeaderView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.isSectionHidden": ('int',),
-    "PySide2.QtWidgets.QHeaderView.isSortIndicatorShown": (),
-    "PySide2.QtWidgets.QHeaderView.length": (),
-    "PySide2.QtWidgets.QHeaderView.logicalIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.logicalIndexAt": [('PySide2.QtCore.QPoint',), ('int',), ('int', 'int')],
-    "PySide2.QtWidgets.QHeaderView.maximumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.minimumSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QHeaderView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QHeaderView.moveSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.offset": (),
-    "PySide2.QtWidgets.QHeaderView.orientation": (),
-    "PySide2.QtWidgets.QHeaderView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QHeaderView.paintSection": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int'),
-    "PySide2.QtWidgets.QHeaderView.reset": (),
-    "PySide2.QtWidgets.QHeaderView.resetDefaultSectionSize": (),
-    "PySide2.QtWidgets.QHeaderView.resizeContentsPrecision": (),
-    "PySide2.QtWidgets.QHeaderView.resizeSection": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.resizeSections": [(), ('PySide2.QtWidgets.QHeaderView.ResizeMode',)],
-    "PySide2.QtWidgets.QHeaderView.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QHeaderView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.saveState": (),
-    "PySide2.QtWidgets.QHeaderView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QHeaderView.sectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionResizeMode": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeFromContents": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionSizeHint": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionViewportPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sectionsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsClickable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsHidden": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.sectionsMovable": (),
-    "PySide2.QtWidgets.QHeaderView.sectionsMoved": (),
-    "PySide2.QtWidgets.QHeaderView.setCascadingSectionResizes": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QHeaderView.setDefaultSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setFirstSectionMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setHighlightSections": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setMaximumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setMinimumSectionSize": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QHeaderView.setOffset": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.setOffsetToSectionPosition": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setResizeContentsPrecision": ('int',),
-    "PySide2.QtWidgets.QHeaderView.setSectionHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QHeaderView.setSectionResizeMode": [('PySide2.QtWidgets.QHeaderView.ResizeMode',), ('int', 'PySide2.QtWidgets.QHeaderView.ResizeMode')],
-    "PySide2.QtWidgets.QHeaderView.setSectionsClickable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSectionsMovable": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicator": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QHeaderView.setSortIndicatorShown": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setStretchLastSection": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.setVisible": ('bool',),
-    "PySide2.QtWidgets.QHeaderView.showSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.sizeHint": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorOrder": (),
-    "PySide2.QtWidgets.QHeaderView.sortIndicatorSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchLastSection": (),
-    "PySide2.QtWidgets.QHeaderView.stretchSectionCount": (),
-    "PySide2.QtWidgets.QHeaderView.swapSections": ('int', 'int'),
-    "PySide2.QtWidgets.QHeaderView.updateGeometries": (),
-    "PySide2.QtWidgets.QHeaderView.updateSection": ('int',),
-    "PySide2.QtWidgets.QHeaderView.verticalOffset": (),
-    "PySide2.QtWidgets.QHeaderView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QHeaderView.visualIndex": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualIndexAt": ('int',),
-    "PySide2.QtWidgets.QHeaderView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QHeaderView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-# class PySide2.QtWidgets.QInputDialog:
-# class PySide2.QtWidgets.QInputDialog.InputDialogOption:
-# class PySide2.QtWidgets.QInputDialog.InputMode:
-    "PySide2.QtWidgets.QInputDialog.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.cancelButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.comboBoxItems": (),
-    "PySide2.QtWidgets.QInputDialog.done": ('int',),
-    "PySide2.QtWidgets.QInputDialog.doubleDecimals": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.doubleStep": (),
-    "PySide2.QtWidgets.QInputDialog.doubleValue": (),
-    "PySide2.QtWidgets.QInputDialog.getDouble": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'float', 'float', 'float', 'int', 'PySide2.QtCore.Qt.WindowFlags', 'float')],
-    "PySide2.QtWidgets.QInputDialog.getInt": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'int', 'int', 'int', 'int', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QInputDialog.getItem": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'typing.Sequence[str]', 'int', 'bool', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getMultiLineText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.getText": ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QLineEdit.EchoMode', 'str', 'PySide2.QtCore.Qt.WindowFlags', 'PySide2.QtCore.Qt.InputMethodHints'),
-    "PySide2.QtWidgets.QInputDialog.inputMode": (),
-    "PySide2.QtWidgets.QInputDialog.intMaximum": (),
-    "PySide2.QtWidgets.QInputDialog.intMinimum": (),
-    "PySide2.QtWidgets.QInputDialog.intStep": (),
-    "PySide2.QtWidgets.QInputDialog.intValue": (),
-    "PySide2.QtWidgets.QInputDialog.isComboBoxEditable": (),
-    "PySide2.QtWidgets.QInputDialog.labelText": (),
-    "PySide2.QtWidgets.QInputDialog.minimumSizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.okButtonText": (),
-    "PySide2.QtWidgets.QInputDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QInputDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxEditable": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.setComboBoxItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleDecimals": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMaximum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleMinimum": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleRange": ('float', 'float'),
-    "PySide2.QtWidgets.QInputDialog.setDoubleStep": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setDoubleValue": ('float',),
-    "PySide2.QtWidgets.QInputDialog.setInputMode": ('PySide2.QtWidgets.QInputDialog.InputMode',),
-    "PySide2.QtWidgets.QInputDialog.setIntMaximum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntMinimum": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntRange": ('int', 'int'),
-    "PySide2.QtWidgets.QInputDialog.setIntStep": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setIntValue": ('int',),
-    "PySide2.QtWidgets.QInputDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOkButtonText": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption', 'bool'),
-    "PySide2.QtWidgets.QInputDialog.setTextEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QInputDialog.setTextValue": ('str',),
-    "PySide2.QtWidgets.QInputDialog.setVisible": ('bool',),
-    "PySide2.QtWidgets.QInputDialog.sizeHint": (),
-    "PySide2.QtWidgets.QInputDialog.testOption": ('PySide2.QtWidgets.QInputDialog.InputDialogOption',),
-    "PySide2.QtWidgets.QInputDialog.textEchoMode": (),
-    "PySide2.QtWidgets.QInputDialog.textValue": (),
-# class PySide2.QtWidgets.QItemDelegate:
-    "PySide2.QtWidgets.QItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.decoration": ('PySide2.QtWidgets.QStyleOptionViewItem', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.doCheck": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'typing.Any'),
-    "PySide2.QtWidgets.QItemDelegate.drawBackground": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.drawCheck": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QItemDelegate.drawDecoration": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QItemDelegate.drawDisplay": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.drawFocus": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QItemDelegate.hasClipping": (),
-    "PySide2.QtWidgets.QItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.rect": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QItemDelegate.selectedPixmap": ('PySide2.QtGui.QPixmap', 'PySide2.QtGui.QPalette', 'bool'),
-    "PySide2.QtWidgets.QItemDelegate.setClipping": ('bool',),
-    "PySide2.QtWidgets.QItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.setOptions": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QStyleOptionViewItem'),
-    "PySide2.QtWidgets.QItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QItemDelegate.textRectangle": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtGui.QFont', 'str'),
-    "PySide2.QtWidgets.QItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QItemEditorCreatorBase:
-    "PySide2.QtWidgets.QItemEditorCreatorBase.__init__": (),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QItemEditorCreatorBase.valuePropertyName": (),
-# class PySide2.QtWidgets.QItemEditorFactory:
-    "PySide2.QtWidgets.QItemEditorFactory.__init__": (),
-    "PySide2.QtWidgets.QItemEditorFactory.createEditor": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QItemEditorFactory.defaultFactory": (),
-    "PySide2.QtWidgets.QItemEditorFactory.registerEditor": ('int', 'PySide2.QtWidgets.QItemEditorCreatorBase'),
-    "PySide2.QtWidgets.QItemEditorFactory.setDefaultFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QItemEditorFactory.valuePropertyName": ('int',),
-# class PySide2.QtWidgets.QKeyEventTransition:
-    "PySide2.QtWidgets.QKeyEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QKeyEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.key": (),
-    "PySide2.QtWidgets.QKeyEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QKeyEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeyEventTransition.setKey": ('int',),
-    "PySide2.QtWidgets.QKeyEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QKeySequenceEdit:
-    "PySide2.QtWidgets.QKeySequenceEdit.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QKeySequenceEdit.clear": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QKeySequenceEdit.keySequence": (),
-    "PySide2.QtWidgets.QKeySequenceEdit.setKeySequence": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QKeySequenceEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QLCDNumber:
-# class PySide2.QtWidgets.QLCDNumber.Mode:
-# class PySide2.QtWidgets.QLCDNumber.SegmentStyle:
-    "PySide2.QtWidgets.QLCDNumber.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLCDNumber.checkOverflow": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLCDNumber.digitCount": (),
-    "PySide2.QtWidgets.QLCDNumber.display": [('float',), ('int',), ('str',)],
-    "PySide2.QtWidgets.QLCDNumber.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLCDNumber.intValue": (),
-    "PySide2.QtWidgets.QLCDNumber.mode": (),
-    "PySide2.QtWidgets.QLCDNumber.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLCDNumber.segmentStyle": (),
-    "PySide2.QtWidgets.QLCDNumber.setBinMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDecMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setDigitCount": ('int',),
-    "PySide2.QtWidgets.QLCDNumber.setHexMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setMode": ('PySide2.QtWidgets.QLCDNumber.Mode',),
-    "PySide2.QtWidgets.QLCDNumber.setOctMode": (),
-    "PySide2.QtWidgets.QLCDNumber.setSegmentStyle": ('PySide2.QtWidgets.QLCDNumber.SegmentStyle',),
-    "PySide2.QtWidgets.QLCDNumber.setSmallDecimalPoint": ('bool',),
-    "PySide2.QtWidgets.QLCDNumber.sizeHint": (),
-    "PySide2.QtWidgets.QLCDNumber.smallDecimalPoint": (),
-    "PySide2.QtWidgets.QLCDNumber.value": (),
-# class PySide2.QtWidgets.QLabel:
-    "PySide2.QtWidgets.QLabel.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QLabel.alignment": (),
-    "PySide2.QtWidgets.QLabel.buddy": (),
-    "PySide2.QtWidgets.QLabel.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.clear": (),
-    "PySide2.QtWidgets.QLabel.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLabel.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLabel.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QLabel.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLabel.hasScaledContents": (),
-    "PySide2.QtWidgets.QLabel.hasSelectedText": (),
-    "PySide2.QtWidgets.QLabel.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLabel.indent": (),
-    "PySide2.QtWidgets.QLabel.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLabel.margin": (),
-    "PySide2.QtWidgets.QLabel.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLabel.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLabel.movie": (),
-    "PySide2.QtWidgets.QLabel.openExternalLinks": (),
-    "PySide2.QtWidgets.QLabel.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLabel.picture": (),
-    "PySide2.QtWidgets.QLabel.pixmap": (),
-    "PySide2.QtWidgets.QLabel.selectedText": (),
-    "PySide2.QtWidgets.QLabel.selectionStart": (),
-    "PySide2.QtWidgets.QLabel.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLabel.setBuddy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLabel.setIndent": ('int',),
-    "PySide2.QtWidgets.QLabel.setMargin": ('int',),
-    "PySide2.QtWidgets.QLabel.setMovie": ('PySide2.QtGui.QMovie',),
-    "PySide2.QtWidgets.QLabel.setNum": [('float',), ('int',)],
-    "PySide2.QtWidgets.QLabel.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QLabel.setPicture": ('PySide2.QtGui.QPicture',),
-    "PySide2.QtWidgets.QLabel.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QLabel.setScaledContents": ('bool',),
-    "PySide2.QtWidgets.QLabel.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLabel.setText": ('str',),
-    "PySide2.QtWidgets.QLabel.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QLabel.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QLabel.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QLabel.sizeHint": (),
-    "PySide2.QtWidgets.QLabel.text": (),
-    "PySide2.QtWidgets.QLabel.textFormat": (),
-    "PySide2.QtWidgets.QLabel.textInteractionFlags": (),
-    "PySide2.QtWidgets.QLabel.wordWrap": (),
-# class PySide2.QtWidgets.QLayout:
-# class PySide2.QtWidgets.QLayout.SizeConstraint:
-    "PySide2.QtWidgets.QLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.activate": (),
-    "PySide2.QtWidgets.QLayout.addChildLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.addChildWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.adoptLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QLayout.alignmentRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QLayout.closestAcceptableSize": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QLayout.contentsMargins": (),
-    "PySide2.QtWidgets.QLayout.contentsRect": (),
-    "PySide2.QtWidgets.QLayout.controlTypes": (),
-    "PySide2.QtWidgets.QLayout.count": (),
-    "PySide2.QtWidgets.QLayout.expandingDirections": (),
-    "PySide2.QtWidgets.QLayout.geometry": (),
-    "PySide2.QtWidgets.QLayout.getContentsMargins": (),
-    "PySide2.QtWidgets.QLayout.indexOf": [('PySide2.QtWidgets.QLayoutItem',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QLayout.invalidate": (),
-    "PySide2.QtWidgets.QLayout.isEmpty": (),
-    "PySide2.QtWidgets.QLayout.isEnabled": (),
-    "PySide2.QtWidgets.QLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QLayout.layout": (),
-    "PySide2.QtWidgets.QLayout.margin": (),
-    "PySide2.QtWidgets.QLayout.maximumSize": (),
-    "PySide2.QtWidgets.QLayout.menuBar": (),
-    "PySide2.QtWidgets.QLayout.minimumSize": (),
-    "PySide2.QtWidgets.QLayout.parentWidget": (),
-    "PySide2.QtWidgets.QLayout.removeItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QLayout.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.replaceWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.FindChildOptions'),
-    "PySide2.QtWidgets.QLayout.setAlignment": [('PySide2.QtCore.Qt.Alignment',), ('PySide2.QtWidgets.QLayout', 'PySide2.QtCore.Qt.Alignment'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtWidgets.QLayout.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLayout.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayout.setMargin": ('int',),
-    "PySide2.QtWidgets.QLayout.setMenuBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QLayout.setSizeConstraint": ('PySide2.QtWidgets.QLayout.SizeConstraint',),
-    "PySide2.QtWidgets.QLayout.setSpacing": ('int',),
-    "PySide2.QtWidgets.QLayout.sizeConstraint": (),
-    "PySide2.QtWidgets.QLayout.spacing": (),
-    "PySide2.QtWidgets.QLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QLayout.totalHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayout.totalMaximumSize": (),
-    "PySide2.QtWidgets.QLayout.totalMinimumSize": (),
-    "PySide2.QtWidgets.QLayout.totalSizeHint": (),
-    "PySide2.QtWidgets.QLayout.update": (),
-    "PySide2.QtWidgets.QLayout.widgetEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QLayoutItem:
-    "PySide2.QtWidgets.QLayoutItem.__init__": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.alignment": (),
-    "PySide2.QtWidgets.QLayoutItem.controlTypes": (),
-    "PySide2.QtWidgets.QLayoutItem.expandingDirections": (),
-    "PySide2.QtWidgets.QLayoutItem.geometry": (),
-    "PySide2.QtWidgets.QLayoutItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QLayoutItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.invalidate": (),
-    "PySide2.QtWidgets.QLayoutItem.isEmpty": (),
-    "PySide2.QtWidgets.QLayoutItem.layout": (),
-    "PySide2.QtWidgets.QLayoutItem.maximumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.minimumHeightForWidth": ('int',),
-    "PySide2.QtWidgets.QLayoutItem.minimumSize": (),
-    "PySide2.QtWidgets.QLayoutItem.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLayoutItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QLayoutItem.sizeHint": (),
-    "PySide2.QtWidgets.QLayoutItem.spacerItem": (),
-    "PySide2.QtWidgets.QLayoutItem.widget": (),
-# class PySide2.QtWidgets.QLineEdit:
-# class PySide2.QtWidgets.QLineEdit.ActionPosition:
-# class PySide2.QtWidgets.QLineEdit.EchoMode:
-    "PySide2.QtWidgets.QLineEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QLineEdit.addAction": [('PySide2.QtGui.QIcon', 'PySide2.QtWidgets.QLineEdit.ActionPosition'), ('PySide2.QtWidgets.QAction',), ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QLineEdit.ActionPosition')],
-    "PySide2.QtWidgets.QLineEdit.alignment": (),
-    "PySide2.QtWidgets.QLineEdit.backspace": (),
-    "PySide2.QtWidgets.QLineEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.clear": (),
-    "PySide2.QtWidgets.QLineEdit.completer": (),
-    "PySide2.QtWidgets.QLineEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QLineEdit.copy": (),
-    "PySide2.QtWidgets.QLineEdit.createStandardContextMenu": (),
-    "PySide2.QtWidgets.QLineEdit.cursorBackward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorForward": ('bool', 'int'),
-    "PySide2.QtWidgets.QLineEdit.cursorMoveStyle": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPosition": (),
-    "PySide2.QtWidgets.QLineEdit.cursorPositionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QLineEdit.cursorRect": (),
-    "PySide2.QtWidgets.QLineEdit.cursorWordBackward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cursorWordForward": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.cut": (),
-    "PySide2.QtWidgets.QLineEdit.del_": (),
-    "PySide2.QtWidgets.QLineEdit.deselect": (),
-    "PySide2.QtWidgets.QLineEdit.displayText": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QLineEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QLineEdit.echoMode": (),
-    "PySide2.QtWidgets.QLineEdit.end": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QLineEdit.getTextMargins": (),
-    "PySide2.QtWidgets.QLineEdit.hasAcceptableInput": (),
-    "PySide2.QtWidgets.QLineEdit.hasFrame": (),
-    "PySide2.QtWidgets.QLineEdit.hasSelectedText": (),
-    "PySide2.QtWidgets.QLineEdit.home": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.initStyleOption": ('PySide2.QtWidgets.QStyleOptionFrame',),
-    "PySide2.QtWidgets.QLineEdit.inputMask": (),
-    "PySide2.QtWidgets.QLineEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QLineEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QLineEdit.insert": ('str',),
-    "PySide2.QtWidgets.QLineEdit.isClearButtonEnabled": (),
-    "PySide2.QtWidgets.QLineEdit.isModified": (),
-    "PySide2.QtWidgets.QLineEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QLineEdit.isRedoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.isUndoAvailable": (),
-    "PySide2.QtWidgets.QLineEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QLineEdit.maxLength": (),
-    "PySide2.QtWidgets.QLineEdit.minimumSizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QLineEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QLineEdit.paste": (),
-    "PySide2.QtWidgets.QLineEdit.placeholderText": (),
-    "PySide2.QtWidgets.QLineEdit.redo": (),
-    "PySide2.QtWidgets.QLineEdit.selectAll": (),
-    "PySide2.QtWidgets.QLineEdit.selectedText": (),
-    "PySide2.QtWidgets.QLineEdit.selectionEnd": (),
-    "PySide2.QtWidgets.QLineEdit.selectionLength": (),
-    "PySide2.QtWidgets.QLineEdit.selectionStart": (),
-    "PySide2.QtWidgets.QLineEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QLineEdit.setClearButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setCompleter": ('PySide2.QtWidgets.QCompleter',),
-    "PySide2.QtWidgets.QLineEdit.setCursorMoveStyle": ('PySide2.QtCore.Qt.CursorMoveStyle',),
-    "PySide2.QtWidgets.QLineEdit.setCursorPosition": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setDragEnabled": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setEchoMode": ('PySide2.QtWidgets.QLineEdit.EchoMode',),
-    "PySide2.QtWidgets.QLineEdit.setFrame": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setInputMask": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setMaxLength": ('int',),
-    "PySide2.QtWidgets.QLineEdit.setModified": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QLineEdit.setSelection": ('int', 'int'),
-    "PySide2.QtWidgets.QLineEdit.setText": ('str',),
-    "PySide2.QtWidgets.QLineEdit.setTextMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QLineEdit.setValidator": ('PySide2.QtGui.QValidator',),
-    "PySide2.QtWidgets.QLineEdit.sizeHint": (),
-    "PySide2.QtWidgets.QLineEdit.text": (),
-    "PySide2.QtWidgets.QLineEdit.textMargins": (),
-    "PySide2.QtWidgets.QLineEdit.undo": (),
-    "PySide2.QtWidgets.QLineEdit.validator": (),
-# class PySide2.QtWidgets.QListView:
-# class PySide2.QtWidgets.QListView.Flow:
-# class PySide2.QtWidgets.QListView.LayoutMode:
-# class PySide2.QtWidgets.QListView.Movement:
-# class PySide2.QtWidgets.QListView.ResizeMode:
-# class PySide2.QtWidgets.QListView.ViewMode:
-    "PySide2.QtWidgets.QListView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListView.batchSize": (),
-    "PySide2.QtWidgets.QListView.clearPropertyFlags": (),
-    "PySide2.QtWidgets.QListView.contentsSize": (),
-    "PySide2.QtWidgets.QListView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QListView.doItemsLayout": (),
-    "PySide2.QtWidgets.QListView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QListView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QListView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListView.flow": (),
-    "PySide2.QtWidgets.QListView.gridSize": (),
-    "PySide2.QtWidgets.QListView.horizontalOffset": (),
-    "PySide2.QtWidgets.QListView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QListView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QListView.isSelectionRectVisible": (),
-    "PySide2.QtWidgets.QListView.isWrapping": (),
-    "PySide2.QtWidgets.QListView.itemAlignment": (),
-    "PySide2.QtWidgets.QListView.layoutMode": (),
-    "PySide2.QtWidgets.QListView.modelColumn": (),
-    "PySide2.QtWidgets.QListView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QListView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QListView.movement": (),
-    "PySide2.QtWidgets.QListView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QListView.rectForIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.reset": (),
-    "PySide2.QtWidgets.QListView.resizeContents": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QListView.resizeMode": (),
-    "PySide2.QtWidgets.QListView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QListView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListView.selectedIndexes": (),
-    "PySide2.QtWidgets.QListView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QListView.setBatchSize": ('int',),
-    "PySide2.QtWidgets.QListView.setFlow": ('PySide2.QtWidgets.QListView.Flow',),
-    "PySide2.QtWidgets.QListView.setGridSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListView.setItemAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QListView.setLayoutMode": ('PySide2.QtWidgets.QListView.LayoutMode',),
-    "PySide2.QtWidgets.QListView.setModelColumn": ('int',),
-    "PySide2.QtWidgets.QListView.setMovement": ('PySide2.QtWidgets.QListView.Movement',),
-    "PySide2.QtWidgets.QListView.setPositionForIndex": ('PySide2.QtCore.QPoint', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QListView.setResizeMode": ('PySide2.QtWidgets.QListView.ResizeMode',),
-    "PySide2.QtWidgets.QListView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QListView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QListView.setSelectionRectVisible": ('bool',),
-    "PySide2.QtWidgets.QListView.setSpacing": ('int',),
-    "PySide2.QtWidgets.QListView.setUniformItemSizes": ('bool',),
-    "PySide2.QtWidgets.QListView.setViewMode": ('PySide2.QtWidgets.QListView.ViewMode',),
-    "PySide2.QtWidgets.QListView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QListView.setWrapping": ('bool',),
-    "PySide2.QtWidgets.QListView.spacing": (),
-    "PySide2.QtWidgets.QListView.startDrag": ('PySide2.QtCore.Qt.DropActions',),
-    "PySide2.QtWidgets.QListView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QListView.uniformItemSizes": (),
-    "PySide2.QtWidgets.QListView.updateGeometries": (),
-    "PySide2.QtWidgets.QListView.verticalOffset": (),
-    "PySide2.QtWidgets.QListView.viewMode": (),
-    "PySide2.QtWidgets.QListView.viewOptions": (),
-    "PySide2.QtWidgets.QListView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QListView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QListView.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QListView.wordWrap": (),
-# class PySide2.QtWidgets.QListWidget:
-    "PySide2.QtWidgets.QListWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QListWidget.addItem": [('PySide2.QtWidgets.QListWidgetItem',), ('str',)],
-    "PySide2.QtWidgets.QListWidget.addItems": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QListWidget.clear": (),
-    "PySide2.QtWidgets.QListWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.count": (),
-    "PySide2.QtWidgets.QListWidget.currentItem": (),
-    "PySide2.QtWidgets.QListWidget.currentRow": (),
-    "PySide2.QtWidgets.QListWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QListWidget.dropMimeData": ('int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QListWidget.editItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QListWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QListWidget.indexFromItem": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.insertItem": [('int', 'PySide2.QtWidgets.QListWidgetItem'), ('int', 'str')],
-    "PySide2.QtWidgets.QListWidget.insertItems": ('int', 'typing.Sequence[str]'),
-    "PySide2.QtWidgets.QListWidget.isItemHidden": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isItemSelected": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QListWidget.item": ('int',),
-    "PySide2.QtWidgets.QListWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QListWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QListWidget.itemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QListWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QListWidgetItem]',),
-    "PySide2.QtWidgets.QListWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QListWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QListWidgetItem',)],
-    "PySide2.QtWidgets.QListWidget.removeItemWidget": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.row": ('PySide2.QtWidgets.QListWidgetItem',),
-    "PySide2.QtWidgets.QListWidget.scrollToItem": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QListWidget.selectedItems": (),
-    "PySide2.QtWidgets.QListWidget.setCurrentItem": [('PySide2.QtWidgets.QListWidgetItem',), ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setCurrentRow": [('int',), ('int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QListWidget.setItemHidden": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemSelected": ('PySide2.QtWidgets.QListWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QListWidget.setItemWidget": ('PySide2.QtWidgets.QListWidgetItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QListWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QListWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QListWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QListWidget.sortItems": ('PySide2.QtCore.Qt.SortOrder',),
-    "PySide2.QtWidgets.QListWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QListWidget.takeItem": ('int',),
-    "PySide2.QtWidgets.QListWidget.visualItemRect": ('PySide2.QtWidgets.QListWidgetItem',),
-# class PySide2.QtWidgets.QListWidgetItem:
-# class PySide2.QtWidgets.QListWidgetItem.ItemType:
-    "PySide2.QtWidgets.QListWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidget', 'int'), ('PySide2.QtWidgets.QListWidgetItem',), ('str', 'PySide2.QtWidgets.QListWidget', 'int')],
-    "PySide2.QtWidgets.QListWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.background": (),
-    "PySide2.QtWidgets.QListWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QListWidgetItem.clone": (),
-    "PySide2.QtWidgets.QListWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.flags": (),
-    "PySide2.QtWidgets.QListWidgetItem.font": (),
-    "PySide2.QtWidgets.QListWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QListWidgetItem.icon": (),
-    "PySide2.QtWidgets.QListWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QListWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QListWidgetItem.listWidget": (),
-    "PySide2.QtWidgets.QListWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QListWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QListWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QListWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QListWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QListWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QListWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QListWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QListWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QListWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QListWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QListWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QListWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.text": (),
-    "PySide2.QtWidgets.QListWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QListWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QListWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QListWidgetItem.type": (),
-    "PySide2.QtWidgets.QListWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QListWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QMainWindow:
-# class PySide2.QtWidgets.QMainWindow.DockOption:
-# class PySide2.QtWidgets.QMainWindow.DockOptions:
-    "PySide2.QtWidgets.QMainWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMainWindow.addDockWidget": [('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget'), ('PySide2.QtCore.Qt.DockWidgetArea', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation')],
-    "PySide2.QtWidgets.QMainWindow.addToolBar": [('PySide2.QtCore.Qt.ToolBarArea', 'PySide2.QtWidgets.QToolBar'), ('PySide2.QtWidgets.QToolBar',), ('str',)],
-    "PySide2.QtWidgets.QMainWindow.addToolBarBreak": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QMainWindow.centralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMainWindow.corner": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMainWindow.createPopupMenu": (),
-    "PySide2.QtWidgets.QMainWindow.dockOptions": (),
-    "PySide2.QtWidgets.QMainWindow.dockWidgetArea": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.documentMode": (),
-    "PySide2.QtWidgets.QMainWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMainWindow.iconSize": (),
-    "PySide2.QtWidgets.QMainWindow.insertToolBar": ('PySide2.QtWidgets.QToolBar', 'PySide2.QtWidgets.QToolBar'),
-    "PySide2.QtWidgets.QMainWindow.insertToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.isAnimated": (),
-    "PySide2.QtWidgets.QMainWindow.isDockNestingEnabled": (),
-    "PySide2.QtWidgets.QMainWindow.isSeparator": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMainWindow.menuBar": (),
-    "PySide2.QtWidgets.QMainWindow.menuWidget": (),
-    "PySide2.QtWidgets.QMainWindow.removeDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBar": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.removeToolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.resizeDocks": ('typing.Sequence[PySide2.QtWidgets.QDockWidget]', 'typing.Sequence[int]', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.restoreDockWidget": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.restoreState": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QMainWindow.saveState": ('int',),
-    "PySide2.QtWidgets.QMainWindow.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setCentralWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setCorner": ('PySide2.QtCore.Qt.Corner', 'PySide2.QtCore.Qt.DockWidgetArea'),
-    "PySide2.QtWidgets.QMainWindow.setDockNestingEnabled": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setDockOptions": ('PySide2.QtWidgets.QMainWindow.DockOptions',),
-    "PySide2.QtWidgets.QMainWindow.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QMainWindow.setMenuBar": ('PySide2.QtWidgets.QMenuBar',),
-    "PySide2.QtWidgets.QMainWindow.setMenuWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMainWindow.setStatusBar": ('PySide2.QtWidgets.QStatusBar',),
-    "PySide2.QtWidgets.QMainWindow.setTabPosition": ('PySide2.QtCore.Qt.DockWidgetAreas', 'PySide2.QtWidgets.QTabWidget.TabPosition'),
-    "PySide2.QtWidgets.QMainWindow.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMainWindow.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QMainWindow.setUnifiedTitleAndToolBarOnMac": ('bool',),
-    "PySide2.QtWidgets.QMainWindow.splitDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget', 'PySide2.QtCore.Qt.Orientation'),
-    "PySide2.QtWidgets.QMainWindow.statusBar": (),
-    "PySide2.QtWidgets.QMainWindow.tabPosition": ('PySide2.QtCore.Qt.DockWidgetArea',),
-    "PySide2.QtWidgets.QMainWindow.tabShape": (),
-    "PySide2.QtWidgets.QMainWindow.tabifiedDockWidgets": ('PySide2.QtWidgets.QDockWidget',),
-    "PySide2.QtWidgets.QMainWindow.tabifyDockWidget": ('PySide2.QtWidgets.QDockWidget', 'PySide2.QtWidgets.QDockWidget'),
-    "PySide2.QtWidgets.QMainWindow.takeCentralWidget": (),
-    "PySide2.QtWidgets.QMainWindow.toolBarArea": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolBarBreak": ('PySide2.QtWidgets.QToolBar',),
-    "PySide2.QtWidgets.QMainWindow.toolButtonStyle": (),
-    "PySide2.QtWidgets.QMainWindow.unifiedTitleAndToolBarOnMac": (),
-# class PySide2.QtWidgets.QMdiArea:
-# class PySide2.QtWidgets.QMdiArea.AreaOption:
-# class PySide2.QtWidgets.QMdiArea.AreaOptions:
-# class PySide2.QtWidgets.QMdiArea.ViewMode:
-# class PySide2.QtWidgets.QMdiArea.WindowOrder:
-    "PySide2.QtWidgets.QMdiArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.activateNextSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activatePreviousSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.activationOrder": (),
-    "PySide2.QtWidgets.QMdiArea.activeSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.addSubWindow": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiArea.background": (),
-    "PySide2.QtWidgets.QMdiArea.cascadeSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiArea.closeActiveSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.closeAllSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.currentSubWindow": (),
-    "PySide2.QtWidgets.QMdiArea.documentMode": (),
-    "PySide2.QtWidgets.QMdiArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiArea.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiArea.removeSubWindow": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QMdiArea.setActivationOrder": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.setActiveSubWindow": ('PySide2.QtWidgets.QMdiSubWindow',),
-    "PySide2.QtWidgets.QMdiArea.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QMdiArea.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setOption": ('PySide2.QtWidgets.QMdiArea.AreaOption', 'bool'),
-    "PySide2.QtWidgets.QMdiArea.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QMdiArea.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QMdiArea.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setTabsMovable": ('bool',),
-    "PySide2.QtWidgets.QMdiArea.setViewMode": ('PySide2.QtWidgets.QMdiArea.ViewMode',),
-    "PySide2.QtWidgets.QMdiArea.setupViewport": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiArea.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiArea.sizeHint": (),
-    "PySide2.QtWidgets.QMdiArea.subWindowList": ('PySide2.QtWidgets.QMdiArea.WindowOrder',),
-    "PySide2.QtWidgets.QMdiArea.tabPosition": (),
-    "PySide2.QtWidgets.QMdiArea.tabShape": (),
-    "PySide2.QtWidgets.QMdiArea.tabsClosable": (),
-    "PySide2.QtWidgets.QMdiArea.tabsMovable": (),
-    "PySide2.QtWidgets.QMdiArea.testOption": ('PySide2.QtWidgets.QMdiArea.AreaOption',),
-    "PySide2.QtWidgets.QMdiArea.tileSubWindows": (),
-    "PySide2.QtWidgets.QMdiArea.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiArea.viewMode": (),
-    "PySide2.QtWidgets.QMdiArea.viewportEvent": ('PySide2.QtCore.QEvent',),
-# class PySide2.QtWidgets.QMdiSubWindow:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOption:
-# class PySide2.QtWidgets.QMdiSubWindow.SubWindowOptions:
-    "PySide2.QtWidgets.QMdiSubWindow.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QMdiSubWindow.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMdiSubWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.isShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardPageStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.keyboardSingleStep": (),
-    "PySide2.QtWidgets.QMdiSubWindow.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedButtonsWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.maximizedSystemMenuIconWidget": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mdiArea": (),
-    "PySide2.QtWidgets.QMdiSubWindow.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardPageStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setKeyboardSingleStep": ('int',),
-    "PySide2.QtWidgets.QMdiSubWindow.setOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption', 'bool'),
-    "PySide2.QtWidgets.QMdiSubWindow.setSystemMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QMdiSubWindow.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMdiSubWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.showShaded": (),
-    "PySide2.QtWidgets.QMdiSubWindow.showSystemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.sizeHint": (),
-    "PySide2.QtWidgets.QMdiSubWindow.systemMenu": (),
-    "PySide2.QtWidgets.QMdiSubWindow.testOption": ('PySide2.QtWidgets.QMdiSubWindow.SubWindowOption',),
-    "PySide2.QtWidgets.QMdiSubWindow.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMdiSubWindow.widget": (),
-# class PySide2.QtWidgets.QMenu:
-    "PySide2.QtWidgets.QMenu.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenu.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenu.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.activeAction": (),
-    "PySide2.QtWidgets.QMenu.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtGui.QIcon', 'str', 'object', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtGui.QKeySequence'), ('str', 'object', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtWidgets.QMenu.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSection": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QMenu.addSeparator": (),
-    "PySide2.QtWidgets.QMenu.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.clear": (),
-    "PySide2.QtWidgets.QMenu.columnCount": (),
-    "PySide2.QtWidgets.QMenu.defaultAction": (),
-    "PySide2.QtWidgets.QMenu.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.exec_": [(), ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'), ('typing.Sequence[PySide2.QtWidgets.QAction]', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QMenu.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QMenu.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QMenu.hideTearOffMenu": (),
-    "PySide2.QtWidgets.QMenu.icon": (),
-    "PySide2.QtWidgets.QMenu.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenu.insertSection": [('PySide2.QtWidgets.QAction', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QAction', 'str')],
-    "PySide2.QtWidgets.QMenu.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.isEmpty": (),
-    "PySide2.QtWidgets.QMenu.isTearOffEnabled": (),
-    "PySide2.QtWidgets.QMenu.isTearOffMenuVisible": (),
-    "PySide2.QtWidgets.QMenu.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenu.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenu.menuAction": (),
-    "PySide2.QtWidgets.QMenu.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenu.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenu.popup": ('PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenu.separatorsCollapsible": (),
-    "PySide2.QtWidgets.QMenu.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenu.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QMenu.setSeparatorsCollapsible": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTearOffEnabled": ('bool',),
-    "PySide2.QtWidgets.QMenu.setTitle": ('str',),
-    "PySide2.QtWidgets.QMenu.setToolTipsVisible": ('bool',),
-    "PySide2.QtWidgets.QMenu.showTearOffMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QMenu.sizeHint": (),
-    "PySide2.QtWidgets.QMenu.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QMenu.title": (),
-    "PySide2.QtWidgets.QMenu.toolTipsVisible": (),
-    "PySide2.QtWidgets.QMenu.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QMenuBar:
-    "PySide2.QtWidgets.QMenuBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QMenuBar.actionAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QMenuBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QMenuBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.activeAction": (),
-    "PySide2.QtWidgets.QMenuBar.addAction": [('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str'), ('str', 'object')],
-    "PySide2.QtWidgets.QMenuBar.addMenu": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QMenu',), ('str',)],
-    "PySide2.QtWidgets.QMenuBar.addSeparator": (),
-    "PySide2.QtWidgets.QMenuBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.clear": (),
-    "PySide2.QtWidgets.QMenuBar.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QMenuBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QMenuBar.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QMenuBar.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QMenuBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionMenuItem', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QMenuBar.insertMenu": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QMenu'),
-    "PySide2.QtWidgets.QMenuBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.isDefaultUp": (),
-    "PySide2.QtWidgets.QMenuBar.isNativeMenuBar": (),
-    "PySide2.QtWidgets.QMenuBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMenuBar.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMenuBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QMenuBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QMenuBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMenuBar.setActiveAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QMenuBar.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QMenuBar.setDefaultUp": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setNativeMenuBar": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.setVisible": ('bool',),
-    "PySide2.QtWidgets.QMenuBar.sizeHint": (),
-    "PySide2.QtWidgets.QMenuBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtWidgets.QMessageBox:
-# class PySide2.QtWidgets.QMessageBox.ButtonRole:
-# class PySide2.QtWidgets.QMessageBox.Icon:
-# class PySide2.QtWidgets.QMessageBox.StandardButton:
-# class PySide2.QtWidgets.QMessageBox.StandardButtons:
-    "PySide2.QtWidgets.QMessageBox.__init__": [('PySide2.QtWidgets.QMessageBox.Icon', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QMessageBox.about": ('PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QMessageBox.aboutQt": ('PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtWidgets.QMessageBox.addButton": [('PySide2.QtWidgets.QAbstractButton', 'PySide2.QtWidgets.QMessageBox.ButtonRole'), ('PySide2.QtWidgets.QMessageBox.StandardButton',), ('str', 'PySide2.QtWidgets.QMessageBox.ButtonRole')],
-    "PySide2.QtWidgets.QMessageBox.button": ('PySide2.QtWidgets.QMessageBox.StandardButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonRole": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.buttonText": ('int',),
-    "PySide2.QtWidgets.QMessageBox.buttons": (),
-    "PySide2.QtWidgets.QMessageBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.checkBox": (),
-    "PySide2.QtWidgets.QMessageBox.clickedButton": (),
-    "PySide2.QtWidgets.QMessageBox.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QMessageBox.critical": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.defaultButton": (),
-    "PySide2.QtWidgets.QMessageBox.detailedText": (),
-    "PySide2.QtWidgets.QMessageBox.escapeButton": (),
-    "PySide2.QtWidgets.QMessageBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMessageBox.icon": (),
-    "PySide2.QtWidgets.QMessageBox.iconPixmap": (),
-    "PySide2.QtWidgets.QMessageBox.information": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.informativeText": (),
-    "PySide2.QtWidgets.QMessageBox.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QMessageBox.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QMessageBox.question": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-    "PySide2.QtWidgets.QMessageBox.removeButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QMessageBox.setButtonText": ('int', 'str'),
-    "PySide2.QtWidgets.QMessageBox.setCheckBox": ('PySide2.QtWidgets.QCheckBox',),
-    "PySide2.QtWidgets.QMessageBox.setDefaultButton": [('PySide2.QtWidgets.QMessageBox.StandardButton',), ('PySide2.QtWidgets.QPushButton',)],
-    "PySide2.QtWidgets.QMessageBox.setDetailedText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setEscapeButton": [('PySide2.QtWidgets.QAbstractButton',), ('PySide2.QtWidgets.QMessageBox.StandardButton',)],
-    "PySide2.QtWidgets.QMessageBox.setIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.setIconPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QMessageBox.setInformativeText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setStandardButtons": ('PySide2.QtWidgets.QMessageBox.StandardButtons',),
-    "PySide2.QtWidgets.QMessageBox.setText": ('str',),
-    "PySide2.QtWidgets.QMessageBox.setTextFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QMessageBox.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QMessageBox.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QMessageBox.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QMessageBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QMessageBox.standardButton": ('PySide2.QtWidgets.QAbstractButton',),
-    "PySide2.QtWidgets.QMessageBox.standardButtons": (),
-    "PySide2.QtWidgets.QMessageBox.standardIcon": ('PySide2.QtWidgets.QMessageBox.Icon',),
-    "PySide2.QtWidgets.QMessageBox.text": (),
-    "PySide2.QtWidgets.QMessageBox.textFormat": (),
-    "PySide2.QtWidgets.QMessageBox.textInteractionFlags": (),
-    "PySide2.QtWidgets.QMessageBox.warning": [('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButton', 'PySide2.QtWidgets.QMessageBox.StandardButton'), ('PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtWidgets.QMessageBox.StandardButtons', 'PySide2.QtWidgets.QMessageBox.StandardButton')],
-# class PySide2.QtWidgets.QMouseEventTransition:
-    "PySide2.QtWidgets.QMouseEventTransition.__init__": [('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent.Type', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.QState'), ('PySide2.QtCore.QState',)],
-    "PySide2.QtWidgets.QMouseEventTransition.button": (),
-    "PySide2.QtWidgets.QMouseEventTransition.eventTest": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.hitTestPath": (),
-    "PySide2.QtWidgets.QMouseEventTransition.modifierMask": (),
-    "PySide2.QtWidgets.QMouseEventTransition.onTransition": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QMouseEventTransition.setButton": ('PySide2.QtCore.Qt.MouseButton',),
-    "PySide2.QtWidgets.QMouseEventTransition.setHitTestPath": ('PySide2.QtGui.QPainterPath',),
-    "PySide2.QtWidgets.QMouseEventTransition.setModifierMask": ('PySide2.QtCore.Qt.KeyboardModifiers',),
-# class PySide2.QtWidgets.QOpenGLWidget:
-# class PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior:
-    "PySide2.QtWidgets.QOpenGLWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QOpenGLWidget.context": (),
-    "PySide2.QtWidgets.QOpenGLWidget.defaultFramebufferObject": (),
-    "PySide2.QtWidgets.QOpenGLWidget.doneCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.format": (),
-    "PySide2.QtWidgets.QOpenGLWidget.grabFramebuffer": (),
-    "PySide2.QtWidgets.QOpenGLWidget.initializeGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.isValid": (),
-    "PySide2.QtWidgets.QOpenGLWidget.makeCurrent": (),
-    "PySide2.QtWidgets.QOpenGLWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEngine": (),
-    "PySide2.QtWidgets.QOpenGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.paintGL": (),
-    "PySide2.QtWidgets.QOpenGLWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QOpenGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtWidgets.QOpenGLWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtWidgets.QOpenGLWidget.setTextureFormat": ('int',),
-    "PySide2.QtWidgets.QOpenGLWidget.setUpdateBehavior": ('PySide2.QtWidgets.QOpenGLWidget.UpdateBehavior',),
-    "PySide2.QtWidgets.QOpenGLWidget.textureFormat": (),
-    "PySide2.QtWidgets.QOpenGLWidget.updateBehavior": (),
-# class PySide2.QtWidgets.QPanGesture:
-    "PySide2.QtWidgets.QPanGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPanGesture.acceleration": (),
-    "PySide2.QtWidgets.QPanGesture.delta": (),
-    "PySide2.QtWidgets.QPanGesture.lastOffset": (),
-    "PySide2.QtWidgets.QPanGesture.offset": (),
-    "PySide2.QtWidgets.QPanGesture.setAcceleration": ('float',),
-    "PySide2.QtWidgets.QPanGesture.setLastOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPanGesture.setOffset": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QPinchGesture:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlag:
-# class PySide2.QtWidgets.QPinchGesture.ChangeFlags:
-    "PySide2.QtWidgets.QPinchGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QPinchGesture.centerPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.changeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.lastCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.lastRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.lastScaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.rotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.scaleFactor": (),
-    "PySide2.QtWidgets.QPinchGesture.setCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setLastCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setLastRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setLastScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setStartCenterPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalChangeFlags": ('PySide2.QtWidgets.QPinchGesture.ChangeFlags',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalRotationAngle": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.setTotalScaleFactor": ('float',),
-    "PySide2.QtWidgets.QPinchGesture.startCenterPoint": (),
-    "PySide2.QtWidgets.QPinchGesture.totalChangeFlags": (),
-    "PySide2.QtWidgets.QPinchGesture.totalRotationAngle": (),
-    "PySide2.QtWidgets.QPinchGesture.totalScaleFactor": (),
-# class PySide2.QtWidgets.QPlainTextDocumentLayout:
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.__init__": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentChanged": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.documentSize": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.draw": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QAbstractTextDocumentLayout.PaintContext'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.ensureBlockLayout": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.frameBoundingRect": ('PySide2.QtGui.QTextFrame',),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.hitTest": ('PySide2.QtCore.QPointF', 'PySide2.QtCore.Qt.HitTestAccuracy'),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.pageCount": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.requestUpdate": (),
-    "PySide2.QtWidgets.QPlainTextDocumentLayout.setCursorWidth": ('int',),
-# class PySide2.QtWidgets.QPlainTextEdit:
-# class PySide2.QtWidgets.QPlainTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QPlainTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPlainTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendHtml": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.appendPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.backgroundVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingGeometry": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockBoundingRect": ('PySide2.QtGui.QTextBlock',),
-    "PySide2.QtWidgets.QPlainTextEdit.blockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.centerOnScroll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.clear": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contentOffset": (),
-    "PySide2.QtWidgets.QPlainTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.copy": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QPlainTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QPlainTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QPlainTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QPlainTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.cut": (),
-    "PySide2.QtWidgets.QPlainTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.document": (),
-    "PySide2.QtWidgets.QPlainTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QPlainTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QPlainTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QPlainTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QPlainTextEdit.firstVisibleBlock": (),
-    "PySide2.QtWidgets.QPlainTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.getPaintContext": (),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QPlainTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QPlainTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QPlainTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QPlainTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QPlainTextEdit.maximumBlockCount": (),
-    "PySide2.QtWidgets.QPlainTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QPlainTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.paste": (),
-    "PySide2.QtWidgets.QPlainTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QPlainTextEdit.redo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QPlainTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QPlainTextEdit.setBackgroundVisible": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCenterOnScroll": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QPlainTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QPlainTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QPlainTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QPlainTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.setMaximumBlockCount": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QPlainTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QPlainTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QPlainTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QPlainTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QPlainTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QPlainTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QPlainTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QPlainTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QPlainTextEdit.undo": (),
-    "PySide2.QtWidgets.QPlainTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QPlainTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QPlainTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QProgressBar:
-# class PySide2.QtWidgets.QProgressBar.Direction:
-    "PySide2.QtWidgets.QProgressBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QProgressBar.alignment": (),
-    "PySide2.QtWidgets.QProgressBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressBar.format": (),
-    "PySide2.QtWidgets.QProgressBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionProgressBar',),
-    "PySide2.QtWidgets.QProgressBar.invertedAppearance": (),
-    "PySide2.QtWidgets.QProgressBar.isTextVisible": (),
-    "PySide2.QtWidgets.QProgressBar.maximum": (),
-    "PySide2.QtWidgets.QProgressBar.minimum": (),
-    "PySide2.QtWidgets.QProgressBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.orientation": (),
-    "PySide2.QtWidgets.QProgressBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QProgressBar.reset": (),
-    "PySide2.QtWidgets.QProgressBar.resetFormat": (),
-    "PySide2.QtWidgets.QProgressBar.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QProgressBar.setFormat": ('str',),
-    "PySide2.QtWidgets.QProgressBar.setInvertedAppearance": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QProgressBar.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressBar.setTextDirection": ('PySide2.QtWidgets.QProgressBar.Direction',),
-    "PySide2.QtWidgets.QProgressBar.setTextVisible": ('bool',),
-    "PySide2.QtWidgets.QProgressBar.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressBar.sizeHint": (),
-    "PySide2.QtWidgets.QProgressBar.text": (),
-    "PySide2.QtWidgets.QProgressBar.textDirection": (),
-    "PySide2.QtWidgets.QProgressBar.value": (),
-# class PySide2.QtWidgets.QProgressDialog:
-    "PySide2.QtWidgets.QProgressDialog.__init__": [('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('str', 'str', 'int', 'int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QProgressDialog.autoClose": (),
-    "PySide2.QtWidgets.QProgressDialog.autoReset": (),
-    "PySide2.QtWidgets.QProgressDialog.cancel": (),
-    "PySide2.QtWidgets.QProgressDialog.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProgressDialog.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QProgressDialog.forceShow": (),
-    "PySide2.QtWidgets.QProgressDialog.labelText": (),
-    "PySide2.QtWidgets.QProgressDialog.maximum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimum": (),
-    "PySide2.QtWidgets.QProgressDialog.minimumDuration": (),
-    "PySide2.QtWidgets.QProgressDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QProgressDialog.reset": (),
-    "PySide2.QtWidgets.QProgressDialog.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoClose": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setAutoReset": ('bool',),
-    "PySide2.QtWidgets.QProgressDialog.setBar": ('PySide2.QtWidgets.QProgressBar',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButton": ('PySide2.QtWidgets.QPushButton',),
-    "PySide2.QtWidgets.QProgressDialog.setCancelButtonText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setLabel": ('PySide2.QtWidgets.QLabel',),
-    "PySide2.QtWidgets.QProgressDialog.setLabelText": ('str',),
-    "PySide2.QtWidgets.QProgressDialog.setMaximum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimum": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setMinimumDuration": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QProgressDialog.setValue": ('int',),
-    "PySide2.QtWidgets.QProgressDialog.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QProgressDialog.sizeHint": (),
-    "PySide2.QtWidgets.QProgressDialog.value": (),
-    "PySide2.QtWidgets.QProgressDialog.wasCanceled": (),
-# class PySide2.QtWidgets.QProxyStyle:
-    "PySide2.QtWidgets.QProxyStyle.__init__": [('PySide2.QtWidgets.QStyle',), ('str',)],
-    "PySide2.QtWidgets.QProxyStyle.baseStyle": (),
-    "PySide2.QtWidgets.QProxyStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QProxyStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QProxyStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QProxyStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QProxyStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QProxyStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QProxyStyle.setBaseStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QProxyStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.standardPalette": (),
-    "PySide2.QtWidgets.QProxyStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QProxyStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QProxyStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QPushButton:
-    "PySide2.QtWidgets.QPushButton.__init__": [('PySide2.QtGui.QIcon', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QPushButton.autoDefault": (),
-    "PySide2.QtWidgets.QPushButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QPushButton.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QPushButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QPushButton.isDefault": (),
-    "PySide2.QtWidgets.QPushButton.isFlat": (),
-    "PySide2.QtWidgets.QPushButton.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QPushButton.menu": (),
-    "PySide2.QtWidgets.QPushButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QPushButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QPushButton.setAutoDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setDefault": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setFlat": ('bool',),
-    "PySide2.QtWidgets.QPushButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QPushButton.showMenu": (),
-    "PySide2.QtWidgets.QPushButton.sizeHint": (),
-# class PySide2.QtWidgets.QRadioButton:
-    "PySide2.QtWidgets.QRadioButton.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QRadioButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRadioButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QRadioButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionButton',),
-    "PySide2.QtWidgets.QRadioButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QRadioButton.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QRadioButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRadioButton.sizeHint": (),
-# class PySide2.QtWidgets.QRubberBand:
-# class PySide2.QtWidgets.QRubberBand.Shape:
-    "PySide2.QtWidgets.QRubberBand.__init__": ('PySide2.QtWidgets.QRubberBand.Shape', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QRubberBand.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QRubberBand.initStyleOption": ('PySide2.QtWidgets.QStyleOptionRubberBand',),
-    "PySide2.QtWidgets.QRubberBand.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QRubberBand.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QRubberBand.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QRubberBand.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QRubberBand.shape": (),
-    "PySide2.QtWidgets.QRubberBand.showEvent": ('PySide2.QtGui.QShowEvent',),
-# class PySide2.QtWidgets.QScrollArea:
-    "PySide2.QtWidgets.QScrollArea.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.alignment": (),
-    "PySide2.QtWidgets.QScrollArea.ensureVisible": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.ensureWidgetVisible": ('PySide2.QtWidgets.QWidget', 'int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollArea.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QScrollArea.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QScrollArea.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QScrollArea.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QScrollArea.setWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QScrollArea.setWidgetResizable": ('bool',),
-    "PySide2.QtWidgets.QScrollArea.sizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.takeWidget": (),
-    "PySide2.QtWidgets.QScrollArea.viewportSizeHint": (),
-    "PySide2.QtWidgets.QScrollArea.widget": (),
-    "PySide2.QtWidgets.QScrollArea.widgetResizable": (),
-# class PySide2.QtWidgets.QScrollBar:
-    "PySide2.QtWidgets.QScrollBar.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QScrollBar.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QScrollBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QScrollBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QScrollBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QScrollBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QScrollBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QScrollBar.sizeHint": (),
-    "PySide2.QtWidgets.QScrollBar.sliderChange": ('PySide2.QtWidgets.QAbstractSlider.SliderChange',),
-    "PySide2.QtWidgets.QScrollBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QScroller:
-# class PySide2.QtWidgets.QScroller.Input:
-# class PySide2.QtWidgets.QScroller.ScrollerGestureType:
-# class PySide2.QtWidgets.QScroller.State:
-    "PySide2.QtWidgets.QScroller.activeScrollers": (),
-    "PySide2.QtWidgets.QScroller.ensureVisible": [('PySide2.QtCore.QRectF', 'float', 'float'), ('PySide2.QtCore.QRectF', 'float', 'float', 'int')],
-    "PySide2.QtWidgets.QScroller.finalPosition": (),
-    "PySide2.QtWidgets.QScroller.grabGesture": ('PySide2.QtCore.QObject', 'PySide2.QtWidgets.QScroller.ScrollerGestureType'),
-    "PySide2.QtWidgets.QScroller.grabbedGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.handleInput": ('PySide2.QtWidgets.QScroller.Input', 'PySide2.QtCore.QPointF', 'int'),
-    "PySide2.QtWidgets.QScroller.hasScroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.pixelPerMeter": (),
-    "PySide2.QtWidgets.QScroller.resendPrepareEvent": (),
-    "PySide2.QtWidgets.QScroller.scrollTo": [('PySide2.QtCore.QPointF',), ('PySide2.QtCore.QPointF', 'int')],
-    "PySide2.QtWidgets.QScroller.scroller": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.scrollerProperties": (),
-    "PySide2.QtWidgets.QScroller.setScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScroller.setSnapPositionsX": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.setSnapPositionsY": [('float', 'float'), ('typing.Sequence[float]',)],
-    "PySide2.QtWidgets.QScroller.state": (),
-    "PySide2.QtWidgets.QScroller.stop": (),
-    "PySide2.QtWidgets.QScroller.target": (),
-    "PySide2.QtWidgets.QScroller.ungrabGesture": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QScroller.velocity": (),
-# class PySide2.QtWidgets.QScrollerProperties:
-# class PySide2.QtWidgets.QScrollerProperties.FrameRates:
-# class PySide2.QtWidgets.QScrollerProperties.OvershootPolicy:
-# class PySide2.QtWidgets.QScrollerProperties.ScrollMetric:
-    "PySide2.QtWidgets.QScrollerProperties.__init__": [(), ('PySide2.QtWidgets.QScrollerProperties',)],
-    "PySide2.QtWidgets.QScrollerProperties.__copy__": (),
-    "PySide2.QtWidgets.QScrollerProperties.scrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric',),
-    "PySide2.QtWidgets.QScrollerProperties.setDefaultScrollerProperties": ('PySide2.QtWidgets.QScrollerProperties',),
-    "PySide2.QtWidgets.QScrollerProperties.setScrollMetric": ('PySide2.QtWidgets.QScrollerProperties.ScrollMetric', 'typing.Any'),
-    "PySide2.QtWidgets.QScrollerProperties.unsetDefaultScrollerProperties": (),
-# class PySide2.QtWidgets.QShortcut:
-    "PySide2.QtWidgets.QShortcut.__init__": [('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'str', 'str', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtGui.QKeySequence', 'PySide2.QtWidgets.QWidget', 'typing.Callable', 'PySide2.QtCore.Qt.ShortcutContext'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QShortcut.autoRepeat": (),
-    "PySide2.QtWidgets.QShortcut.context": (),
-    "PySide2.QtWidgets.QShortcut.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QShortcut.id": (),
-    "PySide2.QtWidgets.QShortcut.isEnabled": (),
-    "PySide2.QtWidgets.QShortcut.key": (),
-    "PySide2.QtWidgets.QShortcut.parentWidget": (),
-    "PySide2.QtWidgets.QShortcut.setAutoRepeat": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setContext": ('PySide2.QtCore.Qt.ShortcutContext',),
-    "PySide2.QtWidgets.QShortcut.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QShortcut.setKey": ('PySide2.QtGui.QKeySequence',),
-    "PySide2.QtWidgets.QShortcut.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QShortcut.whatsThis": (),
-# class PySide2.QtWidgets.QSizeGrip:
-    "PySide2.QtWidgets.QSizeGrip.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSizeGrip.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSizeGrip.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QSizeGrip.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSizeGrip.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QSizeGrip.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSizeGrip.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSizeGrip.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QSizeGrip.sizeHint": (),
-# class PySide2.QtWidgets.QSizePolicy:
-# class PySide2.QtWidgets.QSizePolicy.ControlType:
-# class PySide2.QtWidgets.QSizePolicy.ControlTypes:
-# class PySide2.QtWidgets.QSizePolicy.Policy:
-# class PySide2.QtWidgets.QSizePolicy.PolicyFlag:
-    "PySide2.QtWidgets.QSizePolicy.__init__": [(), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.ControlType')],
-    "PySide2.QtWidgets.QSizePolicy.__copy__": (),
-    "PySide2.QtWidgets.QSizePolicy.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QSizePolicy.controlType": (),
-    "PySide2.QtWidgets.QSizePolicy.expandingDirections": (),
-    "PySide2.QtWidgets.QSizePolicy.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QSizePolicy.hasWidthForHeight": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.horizontalStretch": (),
-    "PySide2.QtWidgets.QSizePolicy.retainSizeWhenHidden": (),
-    "PySide2.QtWidgets.QSizePolicy.setControlType": ('PySide2.QtWidgets.QSizePolicy.ControlType',),
-    "PySide2.QtWidgets.QSizePolicy.setHeightForWidth": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setHorizontalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setRetainSizeWhenHidden": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalPolicy": ('PySide2.QtWidgets.QSizePolicy.Policy',),
-    "PySide2.QtWidgets.QSizePolicy.setVerticalStretch": ('int',),
-    "PySide2.QtWidgets.QSizePolicy.setWidthForHeight": ('bool',),
-    "PySide2.QtWidgets.QSizePolicy.transpose": (),
-    "PySide2.QtWidgets.QSizePolicy.transposed": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalPolicy": (),
-    "PySide2.QtWidgets.QSizePolicy.verticalStretch": (),
-# class PySide2.QtWidgets.QSlider:
-# class PySide2.QtWidgets.QSlider.TickPosition:
-    "PySide2.QtWidgets.QSlider.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSlider.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSlider.initStyleOption": ('PySide2.QtWidgets.QStyleOptionSlider',),
-    "PySide2.QtWidgets.QSlider.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSlider.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSlider.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSlider.setTickInterval": ('int',),
-    "PySide2.QtWidgets.QSlider.setTickPosition": ('PySide2.QtWidgets.QSlider.TickPosition',),
-    "PySide2.QtWidgets.QSlider.sizeHint": (),
-    "PySide2.QtWidgets.QSlider.tickInterval": (),
-    "PySide2.QtWidgets.QSlider.tickPosition": (),
-# class PySide2.QtWidgets.QSpacerItem:
-    "PySide2.QtWidgets.QSpacerItem.__init__": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.changeSize": ('int', 'int', 'PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy'),
-    "PySide2.QtWidgets.QSpacerItem.expandingDirections": (),
-    "PySide2.QtWidgets.QSpacerItem.geometry": (),
-    "PySide2.QtWidgets.QSpacerItem.isEmpty": (),
-    "PySide2.QtWidgets.QSpacerItem.maximumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.minimumSize": (),
-    "PySide2.QtWidgets.QSpacerItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QSpacerItem.sizeHint": (),
-    "PySide2.QtWidgets.QSpacerItem.sizePolicy": (),
-    "PySide2.QtWidgets.QSpacerItem.spacerItem": (),
-# class PySide2.QtWidgets.QSpinBox:
-    "PySide2.QtWidgets.QSpinBox.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSpinBox.cleanText": (),
-    "PySide2.QtWidgets.QSpinBox.displayIntegerBase": (),
-    "PySide2.QtWidgets.QSpinBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSpinBox.fixup": ('str',),
-    "PySide2.QtWidgets.QSpinBox.maximum": (),
-    "PySide2.QtWidgets.QSpinBox.minimum": (),
-    "PySide2.QtWidgets.QSpinBox.prefix": (),
-    "PySide2.QtWidgets.QSpinBox.setDisplayIntegerBase": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMaximum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setMinimum": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setPrefix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setRange": ('int', 'int'),
-    "PySide2.QtWidgets.QSpinBox.setSingleStep": ('int',),
-    "PySide2.QtWidgets.QSpinBox.setStepType": ('PySide2.QtWidgets.QAbstractSpinBox.StepType',),
-    "PySide2.QtWidgets.QSpinBox.setSuffix": ('str',),
-    "PySide2.QtWidgets.QSpinBox.setValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.singleStep": (),
-    "PySide2.QtWidgets.QSpinBox.stepType": (),
-    "PySide2.QtWidgets.QSpinBox.suffix": (),
-    "PySide2.QtWidgets.QSpinBox.textFromValue": ('int',),
-    "PySide2.QtWidgets.QSpinBox.validate": ('str', 'int'),
-    "PySide2.QtWidgets.QSpinBox.value": (),
-    "PySide2.QtWidgets.QSpinBox.valueFromText": ('str',),
-# class PySide2.QtWidgets.QSplashScreen:
-    "PySide2.QtWidgets.QSplashScreen.__init__": [('PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QPixmap', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QSplashScreen.clearMessage": (),
-    "PySide2.QtWidgets.QSplashScreen.drawContents": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QSplashScreen.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplashScreen.finish": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplashScreen.message": (),
-    "PySide2.QtWidgets.QSplashScreen.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplashScreen.pixmap": (),
-    "PySide2.QtWidgets.QSplashScreen.setPixmap": ('PySide2.QtGui.QPixmap',),
-    "PySide2.QtWidgets.QSplashScreen.showMessage": ('str', 'int', 'PySide2.QtGui.QColor'),
-# class PySide2.QtWidgets.QSplitter:
-    "PySide2.QtWidgets.QSplitter.__init__": [('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QSplitter.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.__rshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtWidgets.QSplitter.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.childEvent": ('PySide2.QtCore.QChildEvent',),
-    "PySide2.QtWidgets.QSplitter.childrenCollapsible": (),
-    "PySide2.QtWidgets.QSplitter.closestLegalPosition": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.count": (),
-    "PySide2.QtWidgets.QSplitter.createHandle": (),
-    "PySide2.QtWidgets.QSplitter.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitter.getRange": ('int',),
-    "PySide2.QtWidgets.QSplitter.handle": ('int',),
-    "PySide2.QtWidgets.QSplitter.handleWidth": (),
-    "PySide2.QtWidgets.QSplitter.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QSplitter.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.isCollapsible": ('int',),
-    "PySide2.QtWidgets.QSplitter.minimumSizeHint": (),
-    "PySide2.QtWidgets.QSplitter.moveSplitter": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitter.orientation": (),
-    "PySide2.QtWidgets.QSplitter.refresh": (),
-    "PySide2.QtWidgets.QSplitter.replaceWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QSplitter.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitter.restoreState": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QSplitter.saveState": (),
-    "PySide2.QtWidgets.QSplitter.setChildrenCollapsible": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setCollapsible": ('int', 'bool'),
-    "PySide2.QtWidgets.QSplitter.setHandleWidth": ('int',),
-    "PySide2.QtWidgets.QSplitter.setOpaqueResize": ('bool',),
-    "PySide2.QtWidgets.QSplitter.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitter.setRubberBand": ('int',),
-    "PySide2.QtWidgets.QSplitter.setSizes": ('typing.Sequence[int]',),
-    "PySide2.QtWidgets.QSplitter.setStretchFactor": ('int', 'int'),
-    "PySide2.QtWidgets.QSplitter.sizeHint": (),
-    "PySide2.QtWidgets.QSplitter.sizes": (),
-    "PySide2.QtWidgets.QSplitter.widget": ('int',),
-# class PySide2.QtWidgets.QSplitterHandle:
-    "PySide2.QtWidgets.QSplitterHandle.__init__": ('PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QSplitter'),
-    "PySide2.QtWidgets.QSplitterHandle.closestLegalPosition": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.moveSplitter": ('int',),
-    "PySide2.QtWidgets.QSplitterHandle.opaqueResize": (),
-    "PySide2.QtWidgets.QSplitterHandle.orientation": (),
-    "PySide2.QtWidgets.QSplitterHandle.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QSplitterHandle.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QSplitterHandle.sizeHint": (),
-    "PySide2.QtWidgets.QSplitterHandle.splitter": (),
-# class PySide2.QtWidgets.QStackedLayout:
-# class PySide2.QtWidgets.QStackedLayout.StackingMode:
-    "PySide2.QtWidgets.QStackedLayout.__init__": [(), ('PySide2.QtWidgets.QLayout',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStackedLayout.addItem": ('PySide2.QtWidgets.QLayoutItem',),
-    "PySide2.QtWidgets.QStackedLayout.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.count": (),
-    "PySide2.QtWidgets.QStackedLayout.currentIndex": (),
-    "PySide2.QtWidgets.QStackedLayout.currentWidget": (),
-    "PySide2.QtWidgets.QStackedLayout.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QStackedLayout.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedLayout.itemAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.minimumSize": (),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedLayout.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QStackedLayout.setStackingMode": ('PySide2.QtWidgets.QStackedLayout.StackingMode',),
-    "PySide2.QtWidgets.QStackedLayout.sizeHint": (),
-    "PySide2.QtWidgets.QStackedLayout.stackingMode": (),
-    "PySide2.QtWidgets.QStackedLayout.takeAt": ('int',),
-    "PySide2.QtWidgets.QStackedLayout.widget": [(), ('int',)],
-# class PySide2.QtWidgets.QStackedWidget:
-    "PySide2.QtWidgets.QStackedWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.count": (),
-    "PySide2.QtWidgets.QStackedWidget.currentIndex": (),
-    "PySide2.QtWidgets.QStackedWidget.currentWidget": (),
-    "PySide2.QtWidgets.QStackedWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStackedWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.insertWidget": ('int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStackedWidget.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QStackedWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStackedWidget.widget": ('int',),
-# class PySide2.QtWidgets.QStatusBar:
-    "PySide2.QtWidgets.QStatusBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.addPermanentWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.addWidget": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.clearMessage": (),
-    "PySide2.QtWidgets.QStatusBar.currentMessage": (),
-    "PySide2.QtWidgets.QStatusBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QStatusBar.hideOrShow": (),
-    "PySide2.QtWidgets.QStatusBar.insertPermanentWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.insertWidget": ('int', 'PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtWidgets.QStatusBar.isSizeGripEnabled": (),
-    "PySide2.QtWidgets.QStatusBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QStatusBar.reformat": (),
-    "PySide2.QtWidgets.QStatusBar.removeWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStatusBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QStatusBar.setSizeGripEnabled": ('bool',),
-    "PySide2.QtWidgets.QStatusBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QStatusBar.showMessage": ('str', 'int'),
-# class PySide2.QtWidgets.QStyle:
-# class PySide2.QtWidgets.QStyle.ComplexControl:
-# class PySide2.QtWidgets.QStyle.ContentsType:
-# class PySide2.QtWidgets.QStyle.ControlElement:
-# class PySide2.QtWidgets.QStyle.PixelMetric:
-# class PySide2.QtWidgets.QStyle.PrimitiveElement:
-# class PySide2.QtWidgets.QStyle.RequestSoftwareInputPanel:
-# class PySide2.QtWidgets.QStyle.StandardPixmap:
-# class PySide2.QtWidgets.QStyle.State:
-# class PySide2.QtWidgets.QStyle.StateFlag:
-# class PySide2.QtWidgets.QStyle.StyleHint:
-# class PySide2.QtWidgets.QStyle.SubControl:
-# class PySide2.QtWidgets.QStyle.SubControls:
-# class PySide2.QtWidgets.QStyle.SubElement:
-    "PySide2.QtWidgets.QStyle.__init__": (),
-    "PySide2.QtWidgets.QStyle.alignedRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QRect'),
-    "PySide2.QtWidgets.QStyle.combinedLayoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtWidgets.QSizePolicy.ControlTypes', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.drawItemPixmap": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.drawItemText": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStyle.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.generatedIconPixmap": ('PySide2.QtGui.QIcon.Mode', 'PySide2.QtGui.QPixmap', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStyle.hitTestComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.itemPixmapRect": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStyle.itemTextRect": ('PySide2.QtGui.QFontMetrics', 'PySide2.QtCore.QRect', 'int', 'bool', 'str'),
-    "PySide2.QtWidgets.QStyle.layoutSpacing": ('PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtWidgets.QSizePolicy.ControlType', 'PySide2.QtCore.Qt.Orientation', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.pixelMetric": ('PySide2.QtWidgets.QStyle.PixelMetric', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.polish": [('PySide2.QtGui.QPalette',), ('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.proxy": (),
-    "PySide2.QtWidgets.QStyle.sizeFromContents": ('PySide2.QtWidgets.QStyle.ContentsType', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtCore.QSize', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.sliderPositionFromValue": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.sliderValueFromPosition": ('int', 'int', 'int', 'int', 'bool'),
-    "PySide2.QtWidgets.QStyle.standardIcon": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.standardPalette": (),
-    "PySide2.QtWidgets.QStyle.standardPixmap": ('PySide2.QtWidgets.QStyle.StandardPixmap', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.styleHint": ('PySide2.QtWidgets.QStyle.StyleHint', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleHintReturn'),
-    "PySide2.QtWidgets.QStyle.subControlRect": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex', 'PySide2.QtWidgets.QStyle.SubControl', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.subElementRect": ('PySide2.QtWidgets.QStyle.SubElement', 'PySide2.QtWidgets.QStyleOption', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QStyle.unpolish": [('PySide2.QtWidgets.QApplication',), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStyle.visualAlignment": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtWidgets.QStyle.visualPos": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QStyle.visualRect": ('PySide2.QtCore.Qt.LayoutDirection', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QRect'),
-# class PySide2.QtWidgets.QStyleFactory:
-    "PySide2.QtWidgets.QStyleFactory.__init__": (),
-    "PySide2.QtWidgets.QStyleFactory.create": ('str',),
-    "PySide2.QtWidgets.QStyleFactory.keys": (),
-# class PySide2.QtWidgets.QStyleHintReturn:
-# class PySide2.QtWidgets.QStyleHintReturn.HintReturnType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturn.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturn.__init__": ('int', 'int'),
-# class PySide2.QtWidgets.QStyleHintReturnMask:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnMask.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnMask.__init__": (),
-# class PySide2.QtWidgets.QStyleHintReturnVariant:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionType:
-# class PySide2.QtWidgets.QStyleHintReturnVariant.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleHintReturnVariant.__init__": (),
-# class PySide2.QtWidgets.QStyleOption:
-# class PySide2.QtWidgets.QStyleOption.OptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOption.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOption.__init__": [('PySide2.QtWidgets.QStyleOption',), ('int', 'int')],
-    "PySide2.QtWidgets.QStyleOption.init": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QStyleOption.initFrom": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QStyleOptionButton:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionButton.ButtonFeatures:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionButton.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComboBox:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComboBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComboBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionComboBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionComplex:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionComplex.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionComplex.__init__": [('PySide2.QtWidgets.QStyleOptionComplex',), ('int', 'int')],
-# class PySide2.QtWidgets.QStyleOptionDockWidget:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionDockWidget.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionDockWidget.__init__": [(), ('PySide2.QtWidgets.QStyleOptionDockWidget',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFocusRect:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFocusRect.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFocusRect.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFocusRect',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionFrame:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeature:
-# class PySide2.QtWidgets.QStyleOptionFrame.FrameFeatures:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGraphicsItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGraphicsItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionGraphicsItem.levelOfDetailFromTransform": ('PySide2.QtGui.QTransform',),
-# class PySide2.QtWidgets.QStyleOptionGroupBox:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionGroupBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionGroupBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionGroupBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionHeader:
-# class PySide2.QtWidgets.QStyleOptionHeader.SectionPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionHeader.SortIndicator:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionHeader.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionHeader.__init__": [(), ('PySide2.QtWidgets.QStyleOptionHeader',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionMenuItem:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.CheckType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.MenuItemType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionMenuItem.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionMenuItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionMenuItem',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionProgressBar:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionProgressBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionProgressBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionProgressBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionRubberBand:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionRubberBand.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionRubberBand.__init__": [(), ('PySide2.QtWidgets.QStyleOptionRubberBand',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSizeGrip:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSizeGrip.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSizeGrip.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSizeGrip',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSlider:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSlider.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSlider.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSlider',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionSpinBox:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionSpinBox.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionSpinBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionSpinBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTab:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidget:
-# class PySide2.QtWidgets.QStyleOptionTab.CornerWidgets:
-# class PySide2.QtWidgets.QStyleOptionTab.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTab.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeature:
-# class PySide2.QtWidgets.QStyleOptionTab.TabFeatures:
-# class PySide2.QtWidgets.QStyleOptionTab.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionTab.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTab',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabBarBase:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabBarBase.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabBarBase.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabBarBase',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTabWidgetFrame.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTabWidgetFrame.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionTitleBar:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionTitleBar.StyleOptionVersion:
-    "PySide2.QtWidgets.QStyleOptionTitleBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionTitleBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBar:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBar.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeature:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarFeatures:
-# class PySide2.QtWidgets.QStyleOptionToolBar.ToolBarPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBar.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBar',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolBox:
-# class PySide2.QtWidgets.QStyleOptionToolBox.SelectedPosition:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolBox.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolBox.TabPosition:
-    "PySide2.QtWidgets.QStyleOptionToolBox.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolBox',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionToolButton:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionToolButton.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeature:
-# class PySide2.QtWidgets.QStyleOptionToolButton.ToolButtonFeatures:
-    "PySide2.QtWidgets.QStyleOptionToolButton.__init__": [(), ('PySide2.QtWidgets.QStyleOptionToolButton',), ('int',)],
-# class PySide2.QtWidgets.QStyleOptionViewItem:
-# class PySide2.QtWidgets.QStyleOptionViewItem.Position:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionType:
-# class PySide2.QtWidgets.QStyleOptionViewItem.StyleOptionVersion:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeature:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemFeatures:
-# class PySide2.QtWidgets.QStyleOptionViewItem.ViewItemPosition:
-    "PySide2.QtWidgets.QStyleOptionViewItem.__init__": [(), ('PySide2.QtWidgets.QStyleOptionViewItem',), ('int',)],
-    "PySide2.QtWidgets.QStyleOptionViewItem.__copy__": (),
-# class PySide2.QtWidgets.QStylePainter:
-    "PySide2.QtWidgets.QStylePainter.__init__": [(), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.begin": [('PySide2.QtGui.QPaintDevice',), ('PySide2.QtGui.QPaintDevice', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QStylePainter.drawComplexControl": ('PySide2.QtWidgets.QStyle.ComplexControl', 'PySide2.QtWidgets.QStyleOptionComplex'),
-    "PySide2.QtWidgets.QStylePainter.drawControl": ('PySide2.QtWidgets.QStyle.ControlElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.drawItemPixmap": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QStylePainter.drawItemText": ('PySide2.QtCore.QRect', 'int', 'PySide2.QtGui.QPalette', 'bool', 'str', 'PySide2.QtGui.QPalette.ColorRole'),
-    "PySide2.QtWidgets.QStylePainter.drawPrimitive": ('PySide2.QtWidgets.QStyle.PrimitiveElement', 'PySide2.QtWidgets.QStyleOption'),
-    "PySide2.QtWidgets.QStylePainter.style": (),
-# class PySide2.QtWidgets.QStyledItemDelegate:
-    "PySide2.QtWidgets.QStyledItemDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QStyledItemDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.displayText": ('typing.Any', 'PySide2.QtCore.QLocale'),
-    "PySide2.QtWidgets.QStyledItemDelegate.editorEvent": ('PySide2.QtCore.QEvent', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QStyledItemDelegate.initStyleOption": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.itemEditorFactory": (),
-    "PySide2.QtWidgets.QStyledItemDelegate.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.setItemEditorFactory": ('PySide2.QtWidgets.QItemEditorFactory',),
-    "PySide2.QtWidgets.QStyledItemDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.sizeHint": ('PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QStyledItemDelegate.updateEditorGeometry": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtWidgets.QSwipeGesture:
-# class PySide2.QtWidgets.QSwipeGesture.SwipeDirection:
-    "PySide2.QtWidgets.QSwipeGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QSwipeGesture.horizontalDirection": (),
-    "PySide2.QtWidgets.QSwipeGesture.setSwipeAngle": ('float',),
-    "PySide2.QtWidgets.QSwipeGesture.swipeAngle": (),
-    "PySide2.QtWidgets.QSwipeGesture.verticalDirection": (),
-# class PySide2.QtWidgets.QSystemTrayIcon:
-# class PySide2.QtWidgets.QSystemTrayIcon.ActivationReason:
-# class PySide2.QtWidgets.QSystemTrayIcon.MessageIcon:
-    "PySide2.QtWidgets.QSystemTrayIcon.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QIcon', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWidgets.QSystemTrayIcon.contextMenu": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QSystemTrayIcon.geometry": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.hide": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.icon": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isSystemTrayAvailable": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.isVisible": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.setContextMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setToolTip": ('str',),
-    "PySide2.QtWidgets.QSystemTrayIcon.setVisible": ('bool',),
-    "PySide2.QtWidgets.QSystemTrayIcon.show": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.showMessage": [('str', 'str', 'PySide2.QtGui.QIcon', 'int'), ('str', 'str', 'PySide2.QtWidgets.QSystemTrayIcon.MessageIcon', 'int')],
-    "PySide2.QtWidgets.QSystemTrayIcon.supportsMessages": (),
-    "PySide2.QtWidgets.QSystemTrayIcon.toolTip": (),
-# class PySide2.QtWidgets.QTabBar:
-# class PySide2.QtWidgets.QTabBar.ButtonPosition:
-# class PySide2.QtWidgets.QTabBar.SelectionBehavior:
-# class PySide2.QtWidgets.QTabBar.Shape:
-    "PySide2.QtWidgets.QTabBar.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabBar.accessibleTabName": ('int',),
-    "PySide2.QtWidgets.QTabBar.addTab": [('PySide2.QtGui.QIcon', 'str'), ('str',)],
-    "PySide2.QtWidgets.QTabBar.autoHide": (),
-    "PySide2.QtWidgets.QTabBar.changeCurrentOnDrag": (),
-    "PySide2.QtWidgets.QTabBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.count": (),
-    "PySide2.QtWidgets.QTabBar.currentIndex": (),
-    "PySide2.QtWidgets.QTabBar.documentMode": (),
-    "PySide2.QtWidgets.QTabBar.drawBase": (),
-    "PySide2.QtWidgets.QTabBar.elideMode": (),
-    "PySide2.QtWidgets.QTabBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabBar.expanding": (),
-    "PySide2.QtWidgets.QTabBar.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QTabBar.iconSize": (),
-    "PySide2.QtWidgets.QTabBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTab', 'int'),
-    "PySide2.QtWidgets.QTabBar.insertTab": [('int', 'PySide2.QtGui.QIcon', 'str'), ('int', 'str')],
-    "PySide2.QtWidgets.QTabBar.isMovable": (),
-    "PySide2.QtWidgets.QTabBar.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabBar.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabBar.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabBar.minimumTabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTabBar.moveTab": ('int', 'int'),
-    "PySide2.QtWidgets.QTabBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabBar.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabBar.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabBar.selectionBehaviorOnRemove": (),
-    "PySide2.QtWidgets.QTabBar.setAccessibleTabName": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setChangeCurrentOnDrag": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabBar.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setDrawBase": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabBar.setExpanding": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setSelectionBehaviorOnRemove": ('PySide2.QtWidgets.QTabBar.SelectionBehavior',),
-    "PySide2.QtWidgets.QTabBar.setShape": ('PySide2.QtWidgets.QTabBar.Shape',),
-    "PySide2.QtWidgets.QTabBar.setTabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTabBar.setTabData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTabBar.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabBar.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabBar.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTabBar.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabBar.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabBar.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabBar.shape": (),
-    "PySide2.QtWidgets.QTabBar.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabBar.sizeHint": (),
-    "PySide2.QtWidgets.QTabBar.tabAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTabBar.tabButton": ('int', 'PySide2.QtWidgets.QTabBar.ButtonPosition'),
-    "PySide2.QtWidgets.QTabBar.tabData": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabLayoutChange": (),
-    "PySide2.QtWidgets.QTabBar.tabRect": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabSizeHint": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabText": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabTextColor": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabBar.tabsClosable": (),
-    "PySide2.QtWidgets.QTabBar.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTabBar.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabBar.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtWidgets.QTabWidget:
-# class PySide2.QtWidgets.QTabWidget.TabPosition:
-# class PySide2.QtWidgets.QTabWidget.TabShape:
-    "PySide2.QtWidgets.QTabWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.addTab": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.clear": (),
-    "PySide2.QtWidgets.QTabWidget.cornerWidget": ('PySide2.QtCore.Qt.Corner',),
-    "PySide2.QtWidgets.QTabWidget.count": (),
-    "PySide2.QtWidgets.QTabWidget.currentIndex": (),
-    "PySide2.QtWidgets.QTabWidget.currentWidget": (),
-    "PySide2.QtWidgets.QTabWidget.documentMode": (),
-    "PySide2.QtWidgets.QTabWidget.elideMode": (),
-    "PySide2.QtWidgets.QTabWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTabWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QTabWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QTabWidget.iconSize": (),
-    "PySide2.QtWidgets.QTabWidget.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.initStyleOption": ('PySide2.QtWidgets.QStyleOptionTabWidgetFrame',),
-    "PySide2.QtWidgets.QTabWidget.insertTab": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QTabWidget.isMovable": (),
-    "PySide2.QtWidgets.QTabWidget.isTabEnabled": ('int',),
-    "PySide2.QtWidgets.QTabWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTabWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTabWidget.removeTab": ('int',),
-    "PySide2.QtWidgets.QTabWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTabWidget.setCornerWidget": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Corner'),
-    "PySide2.QtWidgets.QTabWidget.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QTabWidget.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTabWidget.setDocumentMode": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setElideMode": ('PySide2.QtCore.Qt.TextElideMode',),
-    "PySide2.QtWidgets.QTabWidget.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTabWidget.setMovable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabBar": ('PySide2.QtWidgets.QTabBar',),
-    "PySide2.QtWidgets.QTabWidget.setTabBarAutoHide": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setTabEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QTabWidget.setTabIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTabWidget.setTabPosition": ('PySide2.QtWidgets.QTabWidget.TabPosition',),
-    "PySide2.QtWidgets.QTabWidget.setTabShape": ('PySide2.QtWidgets.QTabWidget.TabShape',),
-    "PySide2.QtWidgets.QTabWidget.setTabText": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTabWidget.setTabsClosable": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.setUsesScrollButtons": ('bool',),
-    "PySide2.QtWidgets.QTabWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTabWidget.sizeHint": (),
-    "PySide2.QtWidgets.QTabWidget.tabBar": (),
-    "PySide2.QtWidgets.QTabWidget.tabBarAutoHide": (),
-    "PySide2.QtWidgets.QTabWidget.tabIcon": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabInserted": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabPosition": (),
-    "PySide2.QtWidgets.QTabWidget.tabRemoved": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabShape": (),
-    "PySide2.QtWidgets.QTabWidget.tabText": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabToolTip": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabWhatsThis": ('int',),
-    "PySide2.QtWidgets.QTabWidget.tabsClosable": (),
-    "PySide2.QtWidgets.QTabWidget.usesScrollButtons": (),
-    "PySide2.QtWidgets.QTabWidget.widget": ('int',),
-# class PySide2.QtWidgets.QTableView:
-    "PySide2.QtWidgets.QTableView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTableView.clearSpans": (),
-    "PySide2.QtWidgets.QTableView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTableView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTableView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTableView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTableView.gridStyle": (),
-    "PySide2.QtWidgets.QTableView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.hideRow": ('int',),
-    "PySide2.QtWidgets.QTableView.horizontalHeader": (),
-    "PySide2.QtWidgets.QTableView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTableView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTableView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isCornerButtonEnabled": (),
-    "PySide2.QtWidgets.QTableView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.isRowHidden": ('int',),
-    "PySide2.QtWidgets.QTableView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTableView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTableView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeColumnsToContents": (),
-    "PySide2.QtWidgets.QTableView.resizeRowToContents": ('int',),
-    "PySide2.QtWidgets.QTableView.resizeRowsToContents": (),
-    "PySide2.QtWidgets.QTableView.rowAt": ('int',),
-    "PySide2.QtWidgets.QTableView.rowCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowHeight": ('int',),
-    "PySide2.QtWidgets.QTableView.rowMoved": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowSpan": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.rowViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTableView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableView.selectColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.selectRow": ('int',),
-    "PySide2.QtWidgets.QTableView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTableView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTableView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setCornerButtonEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setGridStyle": ('PySide2.QtCore.Qt.PenStyle',),
-    "PySide2.QtWidgets.QTableView.setHorizontalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.setRowHeight": ('int', 'int'),
-    "PySide2.QtWidgets.QTableView.setRowHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTableView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTableView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTableView.setShowGrid": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableView.setSpan": ('int', 'int', 'int', 'int'),
-    "PySide2.QtWidgets.QTableView.setVerticalHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTableView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTableView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.showGrid": (),
-    "PySide2.QtWidgets.QTableView.showRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTableView.sizeHintForRow": ('int',),
-    "PySide2.QtWidgets.QTableView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTableView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTableView.updateGeometries": (),
-    "PySide2.QtWidgets.QTableView.verticalHeader": (),
-    "PySide2.QtWidgets.QTableView.verticalOffset": (),
-    "PySide2.QtWidgets.QTableView.verticalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTableView.viewOptions": (),
-    "PySide2.QtWidgets.QTableView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTableView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTableView.wordWrap": (),
-# class PySide2.QtWidgets.QTableWidget:
-    "PySide2.QtWidgets.QTableWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('int', 'int', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTableWidget.cellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.clear": (),
-    "PySide2.QtWidgets.QTableWidget.clearContents": (),
-    "PySide2.QtWidgets.QTableWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.column": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.columnCount": (),
-    "PySide2.QtWidgets.QTableWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTableWidget.currentItem": (),
-    "PySide2.QtWidgets.QTableWidget.currentRow": (),
-    "PySide2.QtWidgets.QTableWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTableWidget.dropMimeData": ('int', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTableWidget.editItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTableWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags'),
-    "PySide2.QtWidgets.QTableWidget.horizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.indexFromItem": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.insertColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.insertRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.isItemSelected": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTableWidget.item": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTableWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTableWidget.itemPrototype": (),
-    "PySide2.QtWidgets.QTableWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTableWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTableWidgetItem]',),
-    "PySide2.QtWidgets.QTableWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTableWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTableWidgetItem',)],
-    "PySide2.QtWidgets.QTableWidget.removeCellWidget": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.removeColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.removeRow": ('int',),
-    "PySide2.QtWidgets.QTableWidget.row": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.rowCount": (),
-    "PySide2.QtWidgets.QTableWidget.scrollToItem": ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTableWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTableWidget.selectedRanges": (),
-    "PySide2.QtWidgets.QTableWidget.setCellWidget": ('int', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTableWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setCurrentCell": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setCurrentItem": [('PySide2.QtWidgets.QTableWidgetItem',), ('PySide2.QtWidgets.QTableWidgetItem', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setHorizontalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.setItem": ('int', 'int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setItemPrototype": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.setItemSelected": ('PySide2.QtWidgets.QTableWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTableWidget.setRangeSelected": ('PySide2.QtWidgets.QTableWidgetSelectionRange', 'bool'),
-    "PySide2.QtWidgets.QTableWidget.setRowCount": ('int',),
-    "PySide2.QtWidgets.QTableWidget.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderItem": ('int', 'PySide2.QtWidgets.QTableWidgetItem'),
-    "PySide2.QtWidgets.QTableWidget.setVerticalHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTableWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTableWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTableWidget.takeHorizontalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.takeItem": ('int', 'int'),
-    "PySide2.QtWidgets.QTableWidget.takeVerticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.verticalHeaderItem": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualColumn": ('int',),
-    "PySide2.QtWidgets.QTableWidget.visualItemRect": ('PySide2.QtWidgets.QTableWidgetItem',),
-    "PySide2.QtWidgets.QTableWidget.visualRow": ('int',),
-# class PySide2.QtWidgets.QTableWidgetItem:
-# class PySide2.QtWidgets.QTableWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTableWidgetItem.__init__": [('PySide2.QtGui.QIcon', 'str', 'int'), ('PySide2.QtWidgets.QTableWidgetItem',), ('int',), ('str', 'int')],
-    "PySide2.QtWidgets.QTableWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.background": (),
-    "PySide2.QtWidgets.QTableWidgetItem.backgroundColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.checkState": (),
-    "PySide2.QtWidgets.QTableWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTableWidgetItem.column": (),
-    "PySide2.QtWidgets.QTableWidgetItem.data": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTableWidgetItem.font": (),
-    "PySide2.QtWidgets.QTableWidgetItem.foreground": (),
-    "PySide2.QtWidgets.QTableWidgetItem.icon": (),
-    "PySide2.QtWidgets.QTableWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTableWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTableWidgetItem.row": (),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setCheckState": ('PySide2.QtCore.Qt.CheckState',),
-    "PySide2.QtWidgets.QTableWidgetItem.setData": ('int', 'typing.Any'),
-    "PySide2.QtWidgets.QTableWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTableWidgetItem.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTableWidgetItem.setForeground": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtWidgets.QTableWidgetItem.setIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTableWidgetItem.setSizeHint": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QTableWidgetItem.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setText": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextAlignment": ('int',),
-    "PySide2.QtWidgets.QTableWidgetItem.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTableWidgetItem.setToolTip": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QTableWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QTableWidgetItem.statusTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.tableWidget": (),
-    "PySide2.QtWidgets.QTableWidgetItem.text": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textAlignment": (),
-    "PySide2.QtWidgets.QTableWidgetItem.textColor": (),
-    "PySide2.QtWidgets.QTableWidgetItem.toolTip": (),
-    "PySide2.QtWidgets.QTableWidgetItem.type": (),
-    "PySide2.QtWidgets.QTableWidgetItem.whatsThis": (),
-    "PySide2.QtWidgets.QTableWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTableWidgetSelectionRange:
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__init__": [(), ('PySide2.QtWidgets.QTableWidgetSelectionRange',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.__copy__": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.bottomRow": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.columnCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.leftColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rightColumn": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.rowCount": (),
-    "PySide2.QtWidgets.QTableWidgetSelectionRange.topRow": (),
-# class PySide2.QtWidgets.QTapAndHoldGesture:
-    "PySide2.QtWidgets.QTapAndHoldGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.position": (),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.setTimeout": ('int',),
-    "PySide2.QtWidgets.QTapAndHoldGesture.timeout": (),
-# class PySide2.QtWidgets.QTapGesture:
-    "PySide2.QtWidgets.QTapGesture.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QTapGesture.position": (),
-    "PySide2.QtWidgets.QTapGesture.setPosition": ('PySide2.QtCore.QPointF',),
-# class PySide2.QtWidgets.QTextBrowser:
-    "PySide2.QtWidgets.QTextBrowser.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTextBrowser.backward": (),
-    "PySide2.QtWidgets.QTextBrowser.backwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.clearHistory": (),
-    "PySide2.QtWidgets.QTextBrowser.doSetSource": ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType'),
-    "PySide2.QtWidgets.QTextBrowser.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextBrowser.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextBrowser.forward": (),
-    "PySide2.QtWidgets.QTextBrowser.forwardHistoryCount": (),
-    "PySide2.QtWidgets.QTextBrowser.historyTitle": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.historyUrl": ('int',),
-    "PySide2.QtWidgets.QTextBrowser.home": (),
-    "PySide2.QtWidgets.QTextBrowser.isBackwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.isForwardAvailable": (),
-    "PySide2.QtWidgets.QTextBrowser.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextBrowser.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextBrowser.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextBrowser.openExternalLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.openLinks": (),
-    "PySide2.QtWidgets.QTextBrowser.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextBrowser.reload": (),
-    "PySide2.QtWidgets.QTextBrowser.searchPaths": (),
-    "PySide2.QtWidgets.QTextBrowser.setOpenExternalLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setOpenLinks": ('bool',),
-    "PySide2.QtWidgets.QTextBrowser.setSearchPaths": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTextBrowser.setSource": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtGui.QTextDocument.ResourceType')],
-    "PySide2.QtWidgets.QTextBrowser.source": (),
-    "PySide2.QtWidgets.QTextBrowser.sourceType": (),
-# class PySide2.QtWidgets.QTextEdit:
-# class PySide2.QtWidgets.QTextEdit.AutoFormatting:
-# class PySide2.QtWidgets.QTextEdit.AutoFormattingFlag:
-# class PySide2.QtWidgets.QTextEdit.ExtraSelection:
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__init__": [(), ('PySide2.QtWidgets.QTextEdit.ExtraSelection',)],
-    "PySide2.QtWidgets.QTextEdit.ExtraSelection.__copy__": (),
-# class PySide2.QtWidgets.QTextEdit.LineWrapMode:
-    "PySide2.QtWidgets.QTextEdit.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QTextEdit.acceptRichText": (),
-    "PySide2.QtWidgets.QTextEdit.alignment": (),
-    "PySide2.QtWidgets.QTextEdit.anchorAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.append": ('str',),
-    "PySide2.QtWidgets.QTextEdit.autoFormatting": (),
-    "PySide2.QtWidgets.QTextEdit.canInsertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.canPaste": (),
-    "PySide2.QtWidgets.QTextEdit.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.clear": (),
-    "PySide2.QtWidgets.QTextEdit.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QTextEdit.copy": (),
-    "PySide2.QtWidgets.QTextEdit.createMimeDataFromSelection": (),
-    "PySide2.QtWidgets.QTextEdit.createStandardContextMenu": [(), ('PySide2.QtCore.QPoint',)],
-    "PySide2.QtWidgets.QTextEdit.currentCharFormat": (),
-    "PySide2.QtWidgets.QTextEdit.currentFont": (),
-    "PySide2.QtWidgets.QTextEdit.cursorForPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTextEdit.cursorRect": [(), ('PySide2.QtGui.QTextCursor',)],
-    "PySide2.QtWidgets.QTextEdit.cursorWidth": (),
-    "PySide2.QtWidgets.QTextEdit.cut": (),
-    "PySide2.QtWidgets.QTextEdit.doSetTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.document": (),
-    "PySide2.QtWidgets.QTextEdit.documentTitle": (),
-    "PySide2.QtWidgets.QTextEdit.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTextEdit.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTextEdit.ensureCursorVisible": (),
-    "PySide2.QtWidgets.QTextEdit.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTextEdit.extraSelections": (),
-    "PySide2.QtWidgets.QTextEdit.find": [('PySide2.QtCore.QRegExp', 'PySide2.QtGui.QTextDocument.FindFlags'), ('PySide2.QtCore.QRegularExpression', 'PySide2.QtGui.QTextDocument.FindFlags'), ('str', 'PySide2.QtGui.QTextDocument.FindFlags')],
-    "PySide2.QtWidgets.QTextEdit.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QTextEdit.fontFamily": (),
-    "PySide2.QtWidgets.QTextEdit.fontItalic": (),
-    "PySide2.QtWidgets.QTextEdit.fontPointSize": (),
-    "PySide2.QtWidgets.QTextEdit.fontUnderline": (),
-    "PySide2.QtWidgets.QTextEdit.fontWeight": (),
-    "PySide2.QtWidgets.QTextEdit.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QTextEdit.inputMethodQuery": [('PySide2.QtCore.Qt.InputMethodQuery',), ('PySide2.QtCore.Qt.InputMethodQuery', 'typing.Any')],
-    "PySide2.QtWidgets.QTextEdit.insertFromMimeData": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTextEdit.insertHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.insertPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.isReadOnly": (),
-    "PySide2.QtWidgets.QTextEdit.isUndoRedoEnabled": (),
-    "PySide2.QtWidgets.QTextEdit.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTextEdit.lineWrapColumnOrWidth": (),
-    "PySide2.QtWidgets.QTextEdit.lineWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.loadResource": ('int', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWidgets.QTextEdit.mergeCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTextEdit.moveCursor": ('PySide2.QtGui.QTextCursor.MoveOperation', 'PySide2.QtGui.QTextCursor.MoveMode'),
-    "PySide2.QtWidgets.QTextEdit.overwriteMode": (),
-    "PySide2.QtWidgets.QTextEdit.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTextEdit.paste": (),
-    "PySide2.QtWidgets.QTextEdit.placeholderText": (),
-    "PySide2.QtWidgets.QTextEdit.print_": ('PySide2.QtGui.QPagedPaintDevice',),
-    "PySide2.QtWidgets.QTextEdit.redo": (),
-    "PySide2.QtWidgets.QTextEdit.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QTextEdit.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTextEdit.scrollToAnchor": ('str',),
-    "PySide2.QtWidgets.QTextEdit.selectAll": (),
-    "PySide2.QtWidgets.QTextEdit.setAcceptRichText": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtWidgets.QTextEdit.setAutoFormatting": ('PySide2.QtWidgets.QTextEdit.AutoFormatting',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentCharFormat": ('PySide2.QtGui.QTextCharFormat',),
-    "PySide2.QtWidgets.QTextEdit.setCurrentFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QTextEdit.setCursorWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setDocument": ('PySide2.QtGui.QTextDocument',),
-    "PySide2.QtWidgets.QTextEdit.setDocumentTitle": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setExtraSelections": ('typing.Sequence[PySide2.QtWidgets.QTextEdit.ExtraSelection]',),
-    "PySide2.QtWidgets.QTextEdit.setFontFamily": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setFontItalic": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontPointSize": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setFontUnderline": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setFontWeight": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setHtml": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapColumnOrWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setLineWrapMode": ('PySide2.QtWidgets.QTextEdit.LineWrapMode',),
-    "PySide2.QtWidgets.QTextEdit.setMarkdown": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setOverwriteMode": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setPlaceholderText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setPlainText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setReadOnly": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabChangesFocus": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopDistance": ('float',),
-    "PySide2.QtWidgets.QTextEdit.setTabStopWidth": ('int',),
-    "PySide2.QtWidgets.QTextEdit.setText": ('str',),
-    "PySide2.QtWidgets.QTextEdit.setTextBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWidgets.QTextEdit.setTextCursor": ('PySide2.QtGui.QTextCursor',),
-    "PySide2.QtWidgets.QTextEdit.setTextInteractionFlags": ('PySide2.QtCore.Qt.TextInteractionFlags',),
-    "PySide2.QtWidgets.QTextEdit.setUndoRedoEnabled": ('bool',),
-    "PySide2.QtWidgets.QTextEdit.setWordWrapMode": ('PySide2.QtGui.QTextOption.WrapMode',),
-    "PySide2.QtWidgets.QTextEdit.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QTextEdit.tabChangesFocus": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopDistance": (),
-    "PySide2.QtWidgets.QTextEdit.tabStopWidth": (),
-    "PySide2.QtWidgets.QTextEdit.textBackgroundColor": (),
-    "PySide2.QtWidgets.QTextEdit.textColor": (),
-    "PySide2.QtWidgets.QTextEdit.textCursor": (),
-    "PySide2.QtWidgets.QTextEdit.textInteractionFlags": (),
-    "PySide2.QtWidgets.QTextEdit.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTextEdit.toHtml": (),
-    "PySide2.QtWidgets.QTextEdit.toMarkdown": ('PySide2.QtGui.QTextDocument.MarkdownFeatures',),
-    "PySide2.QtWidgets.QTextEdit.toPlainText": (),
-    "PySide2.QtWidgets.QTextEdit.undo": (),
-    "PySide2.QtWidgets.QTextEdit.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QTextEdit.wordWrapMode": (),
-    "PySide2.QtWidgets.QTextEdit.zoomIn": ('int',),
-    "PySide2.QtWidgets.QTextEdit.zoomInF": ('float',),
-    "PySide2.QtWidgets.QTextEdit.zoomOut": ('int',),
-# class PySide2.QtWidgets.QTileRules:
-    "PySide2.QtWidgets.QTileRules.__init__": [('PySide2.QtCore.Qt.TileRule',), ('PySide2.QtCore.Qt.TileRule', 'PySide2.QtCore.Qt.TileRule'), ('PySide2.QtWidgets.QTileRules',)],
-    "PySide2.QtWidgets.QTileRules.__copy__": (),
-# class PySide2.QtWidgets.QTimeEdit:
-    "PySide2.QtWidgets.QTimeEdit.__init__": [('PySide2.QtCore.QTime', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QToolBar:
-    "PySide2.QtWidgets.QToolBar.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtWidgets.QToolBar.actionAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QToolBar.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolBar.actionGeometry": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.addAction": [('PySide2.QtGui.QIcon', 'str'), ('PySide2.QtGui.QIcon', 'str', 'PySide2.QtCore.QObject', 'str'), ('PySide2.QtWidgets.QAction',), ('str',), ('str', 'PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtWidgets.QToolBar.addSeparator": (),
-    "PySide2.QtWidgets.QToolBar.addWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBar.allowedAreas": (),
-    "PySide2.QtWidgets.QToolBar.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.clear": (),
-    "PySide2.QtWidgets.QToolBar.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBar.iconSize": (),
-    "PySide2.QtWidgets.QToolBar.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolBar',),
-    "PySide2.QtWidgets.QToolBar.insertSeparator": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolBar.insertWidget": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QToolBar.isAreaAllowed": ('PySide2.QtCore.Qt.ToolBarArea',),
-    "PySide2.QtWidgets.QToolBar.isFloatable": (),
-    "PySide2.QtWidgets.QToolBar.isFloating": (),
-    "PySide2.QtWidgets.QToolBar.isMovable": (),
-    "PySide2.QtWidgets.QToolBar.orientation": (),
-    "PySide2.QtWidgets.QToolBar.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolBar.setAllowedAreas": ('PySide2.QtCore.Qt.ToolBarAreas',),
-    "PySide2.QtWidgets.QToolBar.setFloatable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setIconSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtWidgets.QToolBar.setMovable": ('bool',),
-    "PySide2.QtWidgets.QToolBar.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtWidgets.QToolBar.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolBar.toggleViewAction": (),
-    "PySide2.QtWidgets.QToolBar.toolButtonStyle": (),
-    "PySide2.QtWidgets.QToolBar.widgetForAction": ('PySide2.QtWidgets.QAction',),
-# class PySide2.QtWidgets.QToolBox:
-    "PySide2.QtWidgets.QToolBox.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QToolBox.addItem": [('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.count": (),
-    "PySide2.QtWidgets.QToolBox.currentIndex": (),
-    "PySide2.QtWidgets.QToolBox.currentWidget": (),
-    "PySide2.QtWidgets.QToolBox.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolBox.indexOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.insertItem": [('int', 'PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QIcon', 'str'), ('int', 'PySide2.QtWidgets.QWidget', 'str')],
-    "PySide2.QtWidgets.QToolBox.isItemEnabled": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemIcon": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemInserted": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemRemoved": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemText": ('int',),
-    "PySide2.QtWidgets.QToolBox.itemToolTip": ('int',),
-    "PySide2.QtWidgets.QToolBox.removeItem": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentIndex": ('int',),
-    "PySide2.QtWidgets.QToolBox.setCurrentWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolBox.setItemEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QToolBox.setItemIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QToolBox.setItemText": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.setItemToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QToolBox.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QToolBox.widget": ('int',),
-# class PySide2.QtWidgets.QToolButton:
-# class PySide2.QtWidgets.QToolButton.ToolButtonPopupMode:
-    "PySide2.QtWidgets.QToolButton.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QToolButton.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QToolButton.arrowType": (),
-    "PySide2.QtWidgets.QToolButton.autoRaise": (),
-    "PySide2.QtWidgets.QToolButton.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.defaultAction": (),
-    "PySide2.QtWidgets.QToolButton.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.hitButton": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QToolButton.initStyleOption": ('PySide2.QtWidgets.QStyleOptionToolButton',),
-    "PySide2.QtWidgets.QToolButton.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QToolButton.menu": (),
-    "PySide2.QtWidgets.QToolButton.minimumSizeHint": (),
-    "PySide2.QtWidgets.QToolButton.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QToolButton.nextCheckState": (),
-    "PySide2.QtWidgets.QToolButton.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QToolButton.popupMode": (),
-    "PySide2.QtWidgets.QToolButton.setArrowType": ('PySide2.QtCore.Qt.ArrowType',),
-    "PySide2.QtWidgets.QToolButton.setAutoRaise": ('bool',),
-    "PySide2.QtWidgets.QToolButton.setDefaultAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QToolButton.setMenu": ('PySide2.QtWidgets.QMenu',),
-    "PySide2.QtWidgets.QToolButton.setPopupMode": ('PySide2.QtWidgets.QToolButton.ToolButtonPopupMode',),
-    "PySide2.QtWidgets.QToolButton.setToolButtonStyle": ('PySide2.QtCore.Qt.ToolButtonStyle',),
-    "PySide2.QtWidgets.QToolButton.showMenu": (),
-    "PySide2.QtWidgets.QToolButton.sizeHint": (),
-    "PySide2.QtWidgets.QToolButton.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QToolButton.toolButtonStyle": (),
-# class PySide2.QtWidgets.QToolTip:
-    "PySide2.QtWidgets.QToolTip.font": (),
-    "PySide2.QtWidgets.QToolTip.hideText": (),
-    "PySide2.QtWidgets.QToolTip.isVisible": (),
-    "PySide2.QtWidgets.QToolTip.palette": (),
-    "PySide2.QtWidgets.QToolTip.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QToolTip.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QToolTip.showText": [('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect'), ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QRect', 'int')],
-    "PySide2.QtWidgets.QToolTip.text": (),
-# class PySide2.QtWidgets.QTreeView:
-    "PySide2.QtWidgets.QTreeView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeView.allColumnsShowFocus": (),
-    "PySide2.QtWidgets.QTreeView.autoExpandDelay": (),
-    "PySide2.QtWidgets.QTreeView.collapse": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.collapseAll": (),
-    "PySide2.QtWidgets.QTreeView.columnAt": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnCountChanged": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnMoved": (),
-    "PySide2.QtWidgets.QTreeView.columnResized": ('int', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.columnViewportPosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.columnWidth": ('int',),
-    "PySide2.QtWidgets.QTreeView.currentChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.dataChanged": ('PySide2.QtCore.QModelIndex', 'PySide2.QtCore.QModelIndex', 'typing.List[int]'),
-    "PySide2.QtWidgets.QTreeView.doItemsLayout": (),
-    "PySide2.QtWidgets.QTreeView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QTreeView.drawBranches": ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRect', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawRow": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.drawTree": ('PySide2.QtGui.QPainter', 'PySide2.QtGui.QRegion'),
-    "PySide2.QtWidgets.QTreeView.expand": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.expandAll": (),
-    "PySide2.QtWidgets.QTreeView.expandRecursively": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtWidgets.QTreeView.expandToDepth": ('int',),
-    "PySide2.QtWidgets.QTreeView.expandsOnDoubleClick": (),
-    "PySide2.QtWidgets.QTreeView.header": (),
-    "PySide2.QtWidgets.QTreeView.hideColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.horizontalOffset": (),
-    "PySide2.QtWidgets.QTreeView.horizontalScrollbarAction": ('int',),
-    "PySide2.QtWidgets.QTreeView.indentation": (),
-    "PySide2.QtWidgets.QTreeView.indexAbove": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexAt": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QTreeView.indexBelow": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.indexRowSizeHint": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isAnimated": (),
-    "PySide2.QtWidgets.QTreeView.isColumnHidden": ('int',),
-    "PySide2.QtWidgets.QTreeView.isExpanded": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isHeaderHidden": (),
-    "PySide2.QtWidgets.QTreeView.isIndexHidden": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.isRowHidden": ('int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtWidgets.QTreeView.isSortingEnabled": (),
-    "PySide2.QtWidgets.QTreeView.itemsExpandable": (),
-    "PySide2.QtWidgets.QTreeView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QTreeView.keyboardSearch": ('str',),
-    "PySide2.QtWidgets.QTreeView.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QTreeView.moveCursor": ('PySide2.QtWidgets.QAbstractItemView.CursorAction', 'PySide2.QtCore.Qt.KeyboardModifiers'),
-    "PySide2.QtWidgets.QTreeView.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QTreeView.reexpand": (),
-    "PySide2.QtWidgets.QTreeView.reset": (),
-    "PySide2.QtWidgets.QTreeView.resetIndentation": (),
-    "PySide2.QtWidgets.QTreeView.resizeColumnToContents": ('int',),
-    "PySide2.QtWidgets.QTreeView.rootIsDecorated": (),
-    "PySide2.QtWidgets.QTreeView.rowHeight": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.rowsAboutToBeRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsInserted": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.rowsRemoved": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollContentsBy": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.scrollTo": ('PySide2.QtCore.QModelIndex', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeView.selectAll": (),
-    "PySide2.QtWidgets.QTreeView.selectedIndexes": (),
-    "PySide2.QtWidgets.QTreeView.selectionChanged": ('PySide2.QtCore.QItemSelection', 'PySide2.QtCore.QItemSelection'),
-    "PySide2.QtWidgets.QTreeView.setAllColumnsShowFocus": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAnimated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setAutoExpandDelay": ('int',),
-    "PySide2.QtWidgets.QTreeView.setColumnHidden": ('int', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setColumnWidth": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeView.setExpanded": ('PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setExpandsOnDoubleClick": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setFirstColumnSpanned": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setHeader": ('PySide2.QtWidgets.QHeaderView',),
-    "PySide2.QtWidgets.QTreeView.setHeaderHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setIndentation": ('int',),
-    "PySide2.QtWidgets.QTreeView.setItemsExpandable": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeView.setRootIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.setRootIsDecorated": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setRowHidden": ('int', 'PySide2.QtCore.QModelIndex', 'bool'),
-    "PySide2.QtWidgets.QTreeView.setSelection": ('PySide2.QtCore.QRect', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags'),
-    "PySide2.QtWidgets.QTreeView.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeView.setSortingEnabled": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setTreePosition": ('int',),
-    "PySide2.QtWidgets.QTreeView.setUniformRowHeights": ('bool',),
-    "PySide2.QtWidgets.QTreeView.setWordWrap": ('bool',),
-    "PySide2.QtWidgets.QTreeView.showColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sizeHintForColumn": ('int',),
-    "PySide2.QtWidgets.QTreeView.sortByColumn": [('int',), ('int', 'PySide2.QtCore.Qt.SortOrder')],
-    "PySide2.QtWidgets.QTreeView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtWidgets.QTreeView.treePosition": (),
-    "PySide2.QtWidgets.QTreeView.uniformRowHeights": (),
-    "PySide2.QtWidgets.QTreeView.updateGeometries": (),
-    "PySide2.QtWidgets.QTreeView.verticalOffset": (),
-    "PySide2.QtWidgets.QTreeView.verticalScrollbarValueChanged": ('int',),
-    "PySide2.QtWidgets.QTreeView.viewportEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeView.viewportSizeHint": (),
-    "PySide2.QtWidgets.QTreeView.visualRect": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeView.visualRegionForSelection": ('PySide2.QtCore.QItemSelection',),
-    "PySide2.QtWidgets.QTreeView.wordWrap": (),
-# class PySide2.QtWidgets.QTreeWidget:
-    "PySide2.QtWidgets.QTreeWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.addTopLevelItems": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.clear": (),
-    "PySide2.QtWidgets.QTreeWidget.closePersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.collapseItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidget.currentColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.currentItem": (),
-    "PySide2.QtWidgets.QTreeWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QTreeWidget.dropMimeData": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QMimeData', 'PySide2.QtCore.Qt.DropAction'),
-    "PySide2.QtWidgets.QTreeWidget.editItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QTreeWidget.expandItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.findItems": ('str', 'PySide2.QtCore.Qt.MatchFlags', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.headerItem": (),
-    "PySide2.QtWidgets.QTreeWidget.indexFromItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.indexOfTopLevelItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItem": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidget.insertTopLevelItems": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidget.invisibleRootItem": (),
-    "PySide2.QtWidgets.QTreeWidget.isFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.isPersistentEditorOpen": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemAbove": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.itemBelow": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.itemFromIndex": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtWidgets.QTreeWidget.itemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.items": ('PySide2.QtCore.QMimeData',),
-    "PySide2.QtWidgets.QTreeWidget.mimeData": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidget.mimeTypes": (),
-    "PySide2.QtWidgets.QTreeWidget.openPersistentEditor": [('PySide2.QtCore.QModelIndex',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int')],
-    "PySide2.QtWidgets.QTreeWidget.removeItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int'),
-    "PySide2.QtWidgets.QTreeWidget.scrollToItem": ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QAbstractItemView.ScrollHint'),
-    "PySide2.QtWidgets.QTreeWidget.selectedItems": (),
-    "PySide2.QtWidgets.QTreeWidget.setColumnCount": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.setCurrentItem": [('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtCore.QItemSelectionModel.SelectionFlags')],
-    "PySide2.QtWidgets.QTreeWidget.setFirstItemColumnSpanned": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderItem": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabel": ('str',),
-    "PySide2.QtWidgets.QTreeWidget.setHeaderLabels": ('typing.Sequence[str]',),
-    "PySide2.QtWidgets.QTreeWidget.setItemExpanded": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemHidden": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemSelected": ('PySide2.QtWidgets.QTreeWidgetItem', 'bool'),
-    "PySide2.QtWidgets.QTreeWidget.setItemWidget": ('PySide2.QtWidgets.QTreeWidgetItem', 'int', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QTreeWidget.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtWidgets.QTreeWidget.setSelectionModel": ('PySide2.QtCore.QItemSelectionModel',),
-    "PySide2.QtWidgets.QTreeWidget.sortColumn": (),
-    "PySide2.QtWidgets.QTreeWidget.sortItems": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidget.supportedDropActions": (),
-    "PySide2.QtWidgets.QTreeWidget.takeTopLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItem": ('int',),
-    "PySide2.QtWidgets.QTreeWidget.topLevelItemCount": (),
-    "PySide2.QtWidgets.QTreeWidget.visualItemRect": ('PySide2.QtWidgets.QTreeWidgetItem',),
-# class PySide2.QtWidgets.QTreeWidgetItem:
-# class PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy:
-# class PySide2.QtWidgets.QTreeWidgetItem.ItemType:
-    "PySide2.QtWidgets.QTreeWidgetItem.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'int'), ('PySide2.QtWidgets.QTreeWidget', 'typing.Sequence[str]', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem',), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'int'), ('PySide2.QtWidgets.QTreeWidgetItem', 'typing.Sequence[str]', 'int'), ('int',), ('typing.Sequence[str]', 'int')],
-    "PySide2.QtWidgets.QTreeWidgetItem.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.addChildren": ('typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]',),
-    "PySide2.QtWidgets.QTreeWidgetItem.background": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.backgroundColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.checkState": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.child": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.childCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.childIndicatorPolicy": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.clone": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.columnCount": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.data": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.emitDataChanged": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.flags": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.font": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.foreground": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.icon": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.indexOfChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChild": ('int', 'PySide2.QtWidgets.QTreeWidgetItem'),
-    "PySide2.QtWidgets.QTreeWidgetItem.insertChildren": ('int', 'typing.Sequence[PySide2.QtWidgets.QTreeWidgetItem]'),
-    "PySide2.QtWidgets.QTreeWidgetItem.isDisabled": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isExpanded": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isFirstColumnSpanned": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isHidden": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.isSelected": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.parent": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.read": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWidgets.QTreeWidgetItem.removeChild": ('PySide2.QtWidgets.QTreeWidgetItem',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setBackgroundColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setCheckState": ('int', 'PySide2.QtCore.Qt.CheckState'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setChildIndicatorPolicy": ('PySide2.QtWidgets.QTreeWidgetItem.ChildIndicatorPolicy',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setData": ('int', 'int', 'typing.Any'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setExpanded": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFirstColumnSpanned": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFlags": ('PySide2.QtCore.Qt.ItemFlags',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setFont": ('int', 'PySide2.QtGui.QFont'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setForeground": ('int', 'PySide2.QtGui.QBrush'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setHidden": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setIcon": ('int', 'PySide2.QtGui.QIcon'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSelected": ('bool',),
-    "PySide2.QtWidgets.QTreeWidgetItem.setSizeHint": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setStatusTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setText": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextAlignment": ('int', 'int'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setTextColor": ('int', 'PySide2.QtGui.QColor'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setToolTip": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.setWhatsThis": ('int', 'str'),
-    "PySide2.QtWidgets.QTreeWidgetItem.sizeHint": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.sortChildren": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtWidgets.QTreeWidgetItem.statusTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChild": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.takeChildren": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.text": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textAlignment": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.textColor": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.toolTip": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.treeWidget": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.type": (),
-    "PySide2.QtWidgets.QTreeWidgetItem.whatsThis": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItem.write": ('PySide2.QtCore.QDataStream',),
-# class PySide2.QtWidgets.QTreeWidgetItemIterator:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlag:
-# class PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags:
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__init__": [('PySide2.QtWidgets.QTreeWidget', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItem', 'PySide2.QtWidgets.QTreeWidgetItemIterator.IteratorFlags'), ('PySide2.QtWidgets.QTreeWidgetItemIterator',)],
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__copy__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iadd__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__isub__": ('int',),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.__iter__": (),
-    "PySide2.QtWidgets.QTreeWidgetItemIterator.value": (),
-# class PySide2.QtWidgets.QUndoCommand:
-    "PySide2.QtWidgets.QUndoCommand.__init__": [('PySide2.QtWidgets.QUndoCommand',), ('str', 'PySide2.QtWidgets.QUndoCommand')],
-    "PySide2.QtWidgets.QUndoCommand.actionText": (),
-    "PySide2.QtWidgets.QUndoCommand.child": ('int',),
-    "PySide2.QtWidgets.QUndoCommand.childCount": (),
-    "PySide2.QtWidgets.QUndoCommand.id": (),
-    "PySide2.QtWidgets.QUndoCommand.isObsolete": (),
-    "PySide2.QtWidgets.QUndoCommand.mergeWith": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoCommand.redo": (),
-    "PySide2.QtWidgets.QUndoCommand.setObsolete": ('bool',),
-    "PySide2.QtWidgets.QUndoCommand.setText": ('str',),
-    "PySide2.QtWidgets.QUndoCommand.text": (),
-    "PySide2.QtWidgets.QUndoCommand.undo": (),
-# class PySide2.QtWidgets.QUndoGroup:
-    "PySide2.QtWidgets.QUndoGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoGroup.activeStack": (),
-    "PySide2.QtWidgets.QUndoGroup.addStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.canRedo": (),
-    "PySide2.QtWidgets.QUndoGroup.canUndo": (),
-    "PySide2.QtWidgets.QUndoGroup.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoGroup.isClean": (),
-    "PySide2.QtWidgets.QUndoGroup.redo": (),
-    "PySide2.QtWidgets.QUndoGroup.redoText": (),
-    "PySide2.QtWidgets.QUndoGroup.removeStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.setActiveStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoGroup.stacks": (),
-    "PySide2.QtWidgets.QUndoGroup.undo": (),
-    "PySide2.QtWidgets.QUndoGroup.undoText": (),
-# class PySide2.QtWidgets.QUndoStack:
-    "PySide2.QtWidgets.QUndoStack.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QUndoStack.beginMacro": ('str',),
-    "PySide2.QtWidgets.QUndoStack.canRedo": (),
-    "PySide2.QtWidgets.QUndoStack.canUndo": (),
-    "PySide2.QtWidgets.QUndoStack.cleanIndex": (),
-    "PySide2.QtWidgets.QUndoStack.clear": (),
-    "PySide2.QtWidgets.QUndoStack.command": ('int',),
-    "PySide2.QtWidgets.QUndoStack.count": (),
-    "PySide2.QtWidgets.QUndoStack.createRedoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.createUndoAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtWidgets.QUndoStack.endMacro": (),
-    "PySide2.QtWidgets.QUndoStack.index": (),
-    "PySide2.QtWidgets.QUndoStack.isActive": (),
-    "PySide2.QtWidgets.QUndoStack.isClean": (),
-    "PySide2.QtWidgets.QUndoStack.push": ('PySide2.QtWidgets.QUndoCommand',),
-    "PySide2.QtWidgets.QUndoStack.redo": (),
-    "PySide2.QtWidgets.QUndoStack.redoText": (),
-    "PySide2.QtWidgets.QUndoStack.resetClean": (),
-    "PySide2.QtWidgets.QUndoStack.setActive": ('bool',),
-    "PySide2.QtWidgets.QUndoStack.setClean": (),
-    "PySide2.QtWidgets.QUndoStack.setIndex": ('int',),
-    "PySide2.QtWidgets.QUndoStack.setUndoLimit": ('int',),
-    "PySide2.QtWidgets.QUndoStack.text": ('int',),
-    "PySide2.QtWidgets.QUndoStack.undo": (),
-    "PySide2.QtWidgets.QUndoStack.undoLimit": (),
-    "PySide2.QtWidgets.QUndoStack.undoText": (),
-# class PySide2.QtWidgets.QUndoView:
-    "PySide2.QtWidgets.QUndoView.__init__": [('PySide2.QtWidgets.QUndoGroup', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QUndoStack', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtWidgets.QUndoView.cleanIcon": (),
-    "PySide2.QtWidgets.QUndoView.emptyLabel": (),
-    "PySide2.QtWidgets.QUndoView.group": (),
-    "PySide2.QtWidgets.QUndoView.setCleanIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QUndoView.setEmptyLabel": ('str',),
-    "PySide2.QtWidgets.QUndoView.setGroup": ('PySide2.QtWidgets.QUndoGroup',),
-    "PySide2.QtWidgets.QUndoView.setStack": ('PySide2.QtWidgets.QUndoStack',),
-    "PySide2.QtWidgets.QUndoView.stack": (),
-# class PySide2.QtWidgets.QVBoxLayout:
-    "PySide2.QtWidgets.QVBoxLayout.__init__": [(), ('PySide2.QtWidgets.QWidget',)],
-# class PySide2.QtWidgets.QWhatsThis:
-    "PySide2.QtWidgets.QWhatsThis.createAction": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWhatsThis.enterWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.hideText": (),
-    "PySide2.QtWidgets.QWhatsThis.inWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.leaveWhatsThisMode": (),
-    "PySide2.QtWidgets.QWhatsThis.showText": ('PySide2.QtCore.QPoint', 'str', 'PySide2.QtWidgets.QWidget'),
-# class PySide2.QtWidgets.QWidget:
-# class PySide2.QtWidgets.QWidget.RenderFlag:
-# class PySide2.QtWidgets.QWidget.RenderFlags:
-    "PySide2.QtWidgets.QWidget.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.acceptDrops": (),
-    "PySide2.QtWidgets.QWidget.accessibleDescription": (),
-    "PySide2.QtWidgets.QWidget.accessibleName": (),
-    "PySide2.QtWidgets.QWidget.actionEvent": ('PySide2.QtGui.QActionEvent',),
-    "PySide2.QtWidgets.QWidget.actions": (),
-    "PySide2.QtWidgets.QWidget.activateWindow": (),
-    "PySide2.QtWidgets.QWidget.addAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.addActions": ('typing.Sequence[PySide2.QtWidgets.QAction]',),
-    "PySide2.QtWidgets.QWidget.adjustSize": (),
-    "PySide2.QtWidgets.QWidget.autoFillBackground": (),
-    "PySide2.QtWidgets.QWidget.backgroundRole": (),
-    "PySide2.QtWidgets.QWidget.backingStore": (),
-    "PySide2.QtWidgets.QWidget.baseSize": (),
-    "PySide2.QtWidgets.QWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.childAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.childrenRect": (),
-    "PySide2.QtWidgets.QWidget.childrenRegion": (),
-    "PySide2.QtWidgets.QWidget.clearFocus": (),
-    "PySide2.QtWidgets.QWidget.clearMask": (),
-    "PySide2.QtWidgets.QWidget.close": (),
-    "PySide2.QtWidgets.QWidget.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWidgets.QWidget.contentsMargins": (),
-    "PySide2.QtWidgets.QWidget.contentsRect": (),
-    "PySide2.QtWidgets.QWidget.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWidgets.QWidget.contextMenuPolicy": (),
-    "PySide2.QtWidgets.QWidget.create": ('int', 'bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.createWinId": (),
-    "PySide2.QtWidgets.QWidget.createWindowContainer": ('PySide2.QtGui.QWindow', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWidget.cursor": (),
-    "PySide2.QtWidgets.QWidget.destroy": ('bool', 'bool'),
-    "PySide2.QtWidgets.QWidget.devType": (),
-    "PySide2.QtWidgets.QWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWidgets.QWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWidgets.QWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWidgets.QWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWidgets.QWidget.effectiveWinId": (),
-    "PySide2.QtWidgets.QWidget.ensurePolished": (),
-    "PySide2.QtWidgets.QWidget.enterEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.find": ('int',),
-    "PySide2.QtWidgets.QWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusNextChild": (),
-    "PySide2.QtWidgets.QWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtWidgets.QWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtWidgets.QWidget.focusPolicy": (),
-    "PySide2.QtWidgets.QWidget.focusPreviousChild": (),
-    "PySide2.QtWidgets.QWidget.focusProxy": (),
-    "PySide2.QtWidgets.QWidget.focusWidget": (),
-    "PySide2.QtWidgets.QWidget.font": (),
-    "PySide2.QtWidgets.QWidget.fontInfo": (),
-    "PySide2.QtWidgets.QWidget.fontMetrics": (),
-    "PySide2.QtWidgets.QWidget.foregroundRole": (),
-    "PySide2.QtWidgets.QWidget.frameGeometry": (),
-    "PySide2.QtWidgets.QWidget.frameSize": (),
-    "PySide2.QtWidgets.QWidget.geometry": (),
-    "PySide2.QtWidgets.QWidget.getContentsMargins": (),
-    "PySide2.QtWidgets.QWidget.grab": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidget.grabGesture": ('PySide2.QtCore.Qt.GestureType', 'PySide2.QtCore.Qt.GestureFlags'),
-    "PySide2.QtWidgets.QWidget.grabKeyboard": (),
-    "PySide2.QtWidgets.QWidget.grabMouse": [(), ('PySide2.QtGui.QCursor',)],
-    "PySide2.QtWidgets.QWidget.grabShortcut": ('PySide2.QtGui.QKeySequence', 'PySide2.QtCore.Qt.ShortcutContext'),
-    "PySide2.QtWidgets.QWidget.graphicsEffect": (),
-    "PySide2.QtWidgets.QWidget.graphicsProxyWidget": (),
-    "PySide2.QtWidgets.QWidget.hasFocus": (),
-    "PySide2.QtWidgets.QWidget.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidget.hasMouseTracking": (),
-    "PySide2.QtWidgets.QWidget.hasTabletTracking": (),
-    "PySide2.QtWidgets.QWidget.height": (),
-    "PySide2.QtWidgets.QWidget.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.hide": (),
-    "PySide2.QtWidgets.QWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWidgets.QWidget.initPainter": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtWidgets.QWidget.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtWidgets.QWidget.inputMethodHints": (),
-    "PySide2.QtWidgets.QWidget.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtWidgets.QWidget.insertAction": ('PySide2.QtWidgets.QAction', 'PySide2.QtWidgets.QAction'),
-    "PySide2.QtWidgets.QWidget.insertActions": ('PySide2.QtWidgets.QAction', 'typing.Sequence[PySide2.QtWidgets.QAction]'),
-    "PySide2.QtWidgets.QWidget.internalWinId": (),
-    "PySide2.QtWidgets.QWidget.isActiveWindow": (),
-    "PySide2.QtWidgets.QWidget.isAncestorOf": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabled": (),
-    "PySide2.QtWidgets.QWidget.isEnabledTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isEnabledToTLW": (),
-    "PySide2.QtWidgets.QWidget.isFullScreen": (),
-    "PySide2.QtWidgets.QWidget.isHidden": (),
-    "PySide2.QtWidgets.QWidget.isLeftToRight": (),
-    "PySide2.QtWidgets.QWidget.isMaximized": (),
-    "PySide2.QtWidgets.QWidget.isMinimized": (),
-    "PySide2.QtWidgets.QWidget.isModal": (),
-    "PySide2.QtWidgets.QWidget.isRightToLeft": (),
-    "PySide2.QtWidgets.QWidget.isTopLevel": (),
-    "PySide2.QtWidgets.QWidget.isVisible": (),
-    "PySide2.QtWidgets.QWidget.isVisibleTo": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.isWindow": (),
-    "PySide2.QtWidgets.QWidget.isWindowModified": (),
-    "PySide2.QtWidgets.QWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtWidgets.QWidget.keyboardGrabber": (),
-    "PySide2.QtWidgets.QWidget.layout": (),
-    "PySide2.QtWidgets.QWidget.layoutDirection": (),
-    "PySide2.QtWidgets.QWidget.leaveEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidget.locale": (),
-    "PySide2.QtWidgets.QWidget.lower": (),
-    "PySide2.QtWidgets.QWidget.mapFrom": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapFromGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapFromParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapTo": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtWidgets.QWidget.mapToGlobal": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mapToParent": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.mask": (),
-    "PySide2.QtWidgets.QWidget.maximumHeight": (),
-    "PySide2.QtWidgets.QWidget.maximumSize": (),
-    "PySide2.QtWidgets.QWidget.maximumWidth": (),
-    "PySide2.QtWidgets.QWidget.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtWidgets.QWidget.minimumHeight": (),
-    "PySide2.QtWidgets.QWidget.minimumSize": (),
-    "PySide2.QtWidgets.QWidget.minimumSizeHint": (),
-    "PySide2.QtWidgets.QWidget.minimumWidth": (),
-    "PySide2.QtWidgets.QWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseGrabber": (),
-    "PySide2.QtWidgets.QWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtWidgets.QWidget.move": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtWidgets.QWidget.nativeEvent": ('PySide2.QtCore.QByteArray', 'int'),
-    "PySide2.QtWidgets.QWidget.nativeParentWidget": (),
-    "PySide2.QtWidgets.QWidget.nextInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.normalGeometry": (),
-    "PySide2.QtWidgets.QWidget.overrideWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.overrideWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.paintEngine": (),
-    "PySide2.QtWidgets.QWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWidget.palette": (),
-    "PySide2.QtWidgets.QWidget.parentWidget": (),
-    "PySide2.QtWidgets.QWidget.pos": (),
-    "PySide2.QtWidgets.QWidget.previousInFocusChain": (),
-    "PySide2.QtWidgets.QWidget.raise_": (),
-    "PySide2.QtWidgets.QWidget.rect": (),
-    "PySide2.QtWidgets.QWidget.redirected": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtWidgets.QWidget.releaseKeyboard": (),
-    "PySide2.QtWidgets.QWidget.releaseMouse": (),
-    "PySide2.QtWidgets.QWidget.releaseShortcut": ('int',),
-    "PySide2.QtWidgets.QWidget.removeAction": ('PySide2.QtWidgets.QAction',),
-    "PySide2.QtWidgets.QWidget.render": [('PySide2.QtGui.QPaintDevice', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags'), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QRegion', 'PySide2.QtWidgets.QWidget.RenderFlags')],
-    "PySide2.QtWidgets.QWidget.repaint": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.resize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWidget.restoreGeometry": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWidgets.QWidget.saveGeometry": (),
-    "PySide2.QtWidgets.QWidget.screen": (),
-    "PySide2.QtWidgets.QWidget.scroll": [('int', 'int'), ('int', 'int', 'PySide2.QtCore.QRect')],
-    "PySide2.QtWidgets.QWidget.setAcceptDrops": ('bool',),
-    "PySide2.QtWidgets.QWidget.setAccessibleDescription": ('str',),
-    "PySide2.QtWidgets.QWidget.setAccessibleName": ('str',),
-    "PySide2.QtWidgets.QWidget.setAttribute": ('PySide2.QtCore.Qt.WidgetAttribute', 'bool'),
-    "PySide2.QtWidgets.QWidget.setAutoFillBackground": ('bool',),
-    "PySide2.QtWidgets.QWidget.setBackgroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setBaseSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContentsMargins": [('PySide2.QtCore.QMargins',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setContextMenuPolicy": ('PySide2.QtCore.Qt.ContextMenuPolicy',),
-    "PySide2.QtWidgets.QWidget.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtWidgets.QWidget.setDisabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setFixedHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setFixedSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setFixedWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtWidgets.QWidget.setFocusPolicy": ('PySide2.QtCore.Qt.FocusPolicy',),
-    "PySide2.QtWidgets.QWidget.setFocusProxy": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtWidgets.QWidget.setForegroundRole": ('PySide2.QtGui.QPalette.ColorRole',),
-    "PySide2.QtWidgets.QWidget.setGeometry": [('PySide2.QtCore.QRect',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.setGraphicsEffect": ('PySide2.QtWidgets.QGraphicsEffect',),
-    "PySide2.QtWidgets.QWidget.setHidden": ('bool',),
-    "PySide2.QtWidgets.QWidget.setInputMethodHints": ('PySide2.QtCore.Qt.InputMethodHints',),
-    "PySide2.QtWidgets.QWidget.setLayout": ('PySide2.QtWidgets.QLayout',),
-    "PySide2.QtWidgets.QWidget.setLayoutDirection": ('PySide2.QtCore.Qt.LayoutDirection',),
-    "PySide2.QtWidgets.QWidget.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtWidgets.QWidget.setMask": [('PySide2.QtGui.QBitmap',), ('PySide2.QtGui.QRegion',)],
-    "PySide2.QtWidgets.QWidget.setMaximumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMaximumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMaximumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumHeight": ('int',),
-    "PySide2.QtWidgets.QWidget.setMinimumSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setMinimumWidth": ('int',),
-    "PySide2.QtWidgets.QWidget.setMouseTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setPalette": ('PySide2.QtGui.QPalette',),
-    "PySide2.QtWidgets.QWidget.setParent": [('PySide2.QtWidgets.QWidget',), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtWidgets.QWidget.setShortcutAutoRepeat": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setShortcutEnabled": ('int', 'bool'),
-    "PySide2.QtWidgets.QWidget.setSizeIncrement": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtWidgets.QWidget.setSizePolicy": [('PySide2.QtWidgets.QSizePolicy',), ('PySide2.QtWidgets.QSizePolicy.Policy', 'PySide2.QtWidgets.QSizePolicy.Policy')],
-    "PySide2.QtWidgets.QWidget.setStatusTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setStyle": ('PySide2.QtWidgets.QStyle',),
-    "PySide2.QtWidgets.QWidget.setStyleSheet": ('str',),
-    "PySide2.QtWidgets.QWidget.setTabOrder": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtWidgets.QWidget.setTabletTracking": ('bool',),
-    "PySide2.QtWidgets.QWidget.setToolTip": ('str',),
-    "PySide2.QtWidgets.QWidget.setToolTipDuration": ('int',),
-    "PySide2.QtWidgets.QWidget.setUpdatesEnabled": ('bool',),
-    "PySide2.QtWidgets.QWidget.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWhatsThis": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFilePath": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowFlag": ('PySide2.QtCore.Qt.WindowType', 'bool'),
-    "PySide2.QtWidgets.QWidget.setWindowFlags": ('PySide2.QtCore.Qt.WindowFlags',),
-    "PySide2.QtWidgets.QWidget.setWindowIcon": ('PySide2.QtGui.QIcon',),
-    "PySide2.QtWidgets.QWidget.setWindowIconText": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowModality": ('PySide2.QtCore.Qt.WindowModality',),
-    "PySide2.QtWidgets.QWidget.setWindowModified": ('bool',),
-    "PySide2.QtWidgets.QWidget.setWindowOpacity": ('float',),
-    "PySide2.QtWidgets.QWidget.setWindowRole": ('str',),
-    "PySide2.QtWidgets.QWidget.setWindowState": ('PySide2.QtCore.Qt.WindowStates',),
-    "PySide2.QtWidgets.QWidget.setWindowTitle": ('str',),
-    "PySide2.QtWidgets.QWidget.sharedPainter": (),
-    "PySide2.QtWidgets.QWidget.show": (),
-    "PySide2.QtWidgets.QWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWidgets.QWidget.showFullScreen": (),
-    "PySide2.QtWidgets.QWidget.showMaximized": (),
-    "PySide2.QtWidgets.QWidget.showMinimized": (),
-    "PySide2.QtWidgets.QWidget.showNormal": (),
-    "PySide2.QtWidgets.QWidget.size": (),
-    "PySide2.QtWidgets.QWidget.sizeHint": (),
-    "PySide2.QtWidgets.QWidget.sizeIncrement": (),
-    "PySide2.QtWidgets.QWidget.sizePolicy": (),
-    "PySide2.QtWidgets.QWidget.stackUnder": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidget.statusTip": (),
-    "PySide2.QtWidgets.QWidget.style": (),
-    "PySide2.QtWidgets.QWidget.styleSheet": (),
-    "PySide2.QtWidgets.QWidget.tabletEvent": ('PySide2.QtGui.QTabletEvent',),
-    "PySide2.QtWidgets.QWidget.testAttribute": ('PySide2.QtCore.Qt.WidgetAttribute',),
-    "PySide2.QtWidgets.QWidget.toolTip": (),
-    "PySide2.QtWidgets.QWidget.toolTipDuration": (),
-    "PySide2.QtWidgets.QWidget.topLevelWidget": (),
-    "PySide2.QtWidgets.QWidget.underMouse": (),
-    "PySide2.QtWidgets.QWidget.ungrabGesture": ('PySide2.QtCore.Qt.GestureType',),
-    "PySide2.QtWidgets.QWidget.unsetCursor": (),
-    "PySide2.QtWidgets.QWidget.unsetLayoutDirection": (),
-    "PySide2.QtWidgets.QWidget.unsetLocale": (),
-    "PySide2.QtWidgets.QWidget.update": [(), ('PySide2.QtCore.QRect',), ('PySide2.QtGui.QRegion',), ('int', 'int', 'int', 'int')],
-    "PySide2.QtWidgets.QWidget.updateGeometry": (),
-    "PySide2.QtWidgets.QWidget.updateMicroFocus": (),
-    "PySide2.QtWidgets.QWidget.updatesEnabled": (),
-    "PySide2.QtWidgets.QWidget.visibleRegion": (),
-    "PySide2.QtWidgets.QWidget.whatsThis": (),
-    "PySide2.QtWidgets.QWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtWidgets.QWidget.width": (),
-    "PySide2.QtWidgets.QWidget.winId": (),
-    "PySide2.QtWidgets.QWidget.window": (),
-    "PySide2.QtWidgets.QWidget.windowFilePath": (),
-    "PySide2.QtWidgets.QWidget.windowFlags": (),
-    "PySide2.QtWidgets.QWidget.windowHandle": (),
-    "PySide2.QtWidgets.QWidget.windowIcon": (),
-    "PySide2.QtWidgets.QWidget.windowIconText": (),
-    "PySide2.QtWidgets.QWidget.windowModality": (),
-    "PySide2.QtWidgets.QWidget.windowOpacity": (),
-    "PySide2.QtWidgets.QWidget.windowRole": (),
-    "PySide2.QtWidgets.QWidget.windowState": (),
-    "PySide2.QtWidgets.QWidget.windowTitle": (),
-    "PySide2.QtWidgets.QWidget.windowType": (),
-    "PySide2.QtWidgets.QWidget.x": (),
-    "PySide2.QtWidgets.QWidget.y": (),
-# class PySide2.QtWidgets.QWidgetAction:
-    "PySide2.QtWidgets.QWidgetAction.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWidgets.QWidgetAction.createWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.createdWidgets": (),
-    "PySide2.QtWidgets.QWidgetAction.defaultWidget": (),
-    "PySide2.QtWidgets.QWidgetAction.deleteWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWidgetAction.eventFilter": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtWidgets.QWidgetAction.releaseWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.requestWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetAction.setDefaultWidget": ('PySide2.QtWidgets.QWidget',),
-# class PySide2.QtWidgets.QWidgetItem:
-    "PySide2.QtWidgets.QWidgetItem.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWidgetItem.controlTypes": (),
-    "PySide2.QtWidgets.QWidgetItem.expandingDirections": (),
-    "PySide2.QtWidgets.QWidgetItem.geometry": (),
-    "PySide2.QtWidgets.QWidgetItem.hasHeightForWidth": (),
-    "PySide2.QtWidgets.QWidgetItem.heightForWidth": ('int',),
-    "PySide2.QtWidgets.QWidgetItem.isEmpty": (),
-    "PySide2.QtWidgets.QWidgetItem.maximumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.minimumSize": (),
-    "PySide2.QtWidgets.QWidgetItem.setGeometry": ('PySide2.QtCore.QRect',),
-    "PySide2.QtWidgets.QWidgetItem.sizeHint": (),
-    "PySide2.QtWidgets.QWidgetItem.widget": (),
-# class PySide2.QtWidgets.QWizard:
-# class PySide2.QtWidgets.QWizard.WizardButton:
-# class PySide2.QtWidgets.QWizard.WizardOption:
-# class PySide2.QtWidgets.QWizard.WizardOptions:
-# class PySide2.QtWidgets.QWizard.WizardPixmap:
-# class PySide2.QtWidgets.QWizard.WizardStyle:
-    "PySide2.QtWidgets.QWizard.__init__": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtWidgets.QWizard.addPage": ('PySide2.QtWidgets.QWizardPage',),
-    "PySide2.QtWidgets.QWizard.back": (),
-    "PySide2.QtWidgets.QWizard.button": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizard.cleanupPage": ('int',),
-    "PySide2.QtWidgets.QWizard.currentId": (),
-    "PySide2.QtWidgets.QWizard.currentPage": (),
-    "PySide2.QtWidgets.QWizard.done": ('int',),
-    "PySide2.QtWidgets.QWizard.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWidgets.QWizard.field": ('str',),
-    "PySide2.QtWidgets.QWizard.hasVisitedPage": ('int',),
-    "PySide2.QtWidgets.QWizard.initializePage": ('int',),
-    "PySide2.QtWidgets.QWizard.nextId": (),
-    "PySide2.QtWidgets.QWizard.options": (),
-    "PySide2.QtWidgets.QWizard.page": ('int',),
-    "PySide2.QtWidgets.QWizard.pageIds": (),
-    "PySide2.QtWidgets.QWizard.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtWidgets.QWizard.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizard.removePage": ('int',),
-    "PySide2.QtWidgets.QWizard.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtWidgets.QWizard.restart": (),
-    "PySide2.QtWidgets.QWizard.setButton": ('PySide2.QtWidgets.QWizard.WizardButton', 'PySide2.QtWidgets.QAbstractButton'),
-    "PySide2.QtWidgets.QWizard.setButtonLayout": ('typing.Sequence[PySide2.QtWidgets.QWizard.WizardButton]',),
-    "PySide2.QtWidgets.QWizard.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizard.setDefaultProperty": ('str', 'str', 'str'),
-    "PySide2.QtWidgets.QWizard.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizard.setOption": ('PySide2.QtWidgets.QWizard.WizardOption', 'bool'),
-    "PySide2.QtWidgets.QWizard.setOptions": ('PySide2.QtWidgets.QWizard.WizardOptions',),
-    "PySide2.QtWidgets.QWizard.setPage": ('int', 'PySide2.QtWidgets.QWizardPage'),
-    "PySide2.QtWidgets.QWizard.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizard.setSideWidget": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizard.setStartId": ('int',),
-    "PySide2.QtWidgets.QWizard.setSubTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setTitleFormat": ('PySide2.QtCore.Qt.TextFormat',),
-    "PySide2.QtWidgets.QWizard.setVisible": ('bool',),
-    "PySide2.QtWidgets.QWizard.setWizardStyle": ('PySide2.QtWidgets.QWizard.WizardStyle',),
-    "PySide2.QtWidgets.QWizard.sideWidget": (),
-    "PySide2.QtWidgets.QWizard.sizeHint": (),
-    "PySide2.QtWidgets.QWizard.startId": (),
-    "PySide2.QtWidgets.QWizard.subTitleFormat": (),
-    "PySide2.QtWidgets.QWizard.testOption": ('PySide2.QtWidgets.QWizard.WizardOption',),
-    "PySide2.QtWidgets.QWizard.titleFormat": (),
-    "PySide2.QtWidgets.QWizard.validateCurrentPage": (),
-    "PySide2.QtWidgets.QWizard.visitedPages": (),
-    "PySide2.QtWidgets.QWizard.wizardStyle": (),
-# class PySide2.QtWidgets.QWizardPage:
-    "PySide2.QtWidgets.QWizardPage.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWidgets.QWizardPage.buttonText": ('PySide2.QtWidgets.QWizard.WizardButton',),
-    "PySide2.QtWidgets.QWizardPage.cleanupPage": (),
-    "PySide2.QtWidgets.QWizardPage.field": ('str',),
-    "PySide2.QtWidgets.QWizardPage.initializePage": (),
-    "PySide2.QtWidgets.QWizardPage.isCommitPage": (),
-    "PySide2.QtWidgets.QWizardPage.isComplete": (),
-    "PySide2.QtWidgets.QWizardPage.isFinalPage": (),
-    "PySide2.QtWidgets.QWizardPage.nextId": (),
-    "PySide2.QtWidgets.QWizardPage.pixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap',),
-    "PySide2.QtWidgets.QWizardPage.registerField": ('str', 'PySide2.QtWidgets.QWidget', 'str', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setButtonText": ('PySide2.QtWidgets.QWizard.WizardButton', 'str'),
-    "PySide2.QtWidgets.QWizardPage.setCommitPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setField": ('str', 'typing.Any'),
-    "PySide2.QtWidgets.QWizardPage.setFinalPage": ('bool',),
-    "PySide2.QtWidgets.QWizardPage.setPixmap": ('PySide2.QtWidgets.QWizard.WizardPixmap', 'PySide2.QtGui.QPixmap'),
-    "PySide2.QtWidgets.QWizardPage.setSubTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.setTitle": ('str',),
-    "PySide2.QtWidgets.QWizardPage.subTitle": (),
-    "PySide2.QtWidgets.QWizardPage.title": (),
-    "PySide2.QtWidgets.QWizardPage.validatePage": (),
-    "PySide2.QtWidgets.QWizardPage.wizard": (),
-    }) if "PySide2.QtWidgets" in sys.modules else None
-# Module PySide2.QtPrintSupport
-sig_dict.update({
-# class PySide2.QtPrintSupport.QAbstractPrintDialog:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions:
-# class PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange:
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.__init__": ('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.addEnabledOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.enabledOptions": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.fromPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.isOptionEnabled": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.maxPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.minPage": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printRange": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.printer": (),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setEnabledOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setMinMax": ('int', 'int'),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setOptionTabs": ('typing.Sequence[PySide2.QtWidgets.QWidget]',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.setPrintRange": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintRange',),
-    "PySide2.QtPrintSupport.QAbstractPrintDialog.toPage": (),
-# class PySide2.QtPrintSupport.QPageSetupDialog:
-    "PySide2.QtPrintSupport.QPageSetupDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPageSetupDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPageSetupDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPageSetupDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPageSetupDialog.printer": (),
-# class PySide2.QtPrintSupport.QPrintDialog:
-    "PySide2.QtPrintSupport.QPrintDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtPrintSupport.QPrintDialog.accept": (),
-    "PySide2.QtPrintSupport.QPrintDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintDialog.exec_": (),
-    "PySide2.QtPrintSupport.QPrintDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintDialog.options": (),
-    "PySide2.QtPrintSupport.QPrintDialog.setOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption', 'bool'),
-    "PySide2.QtPrintSupport.QPrintDialog.setOptions": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOptions',),
-    "PySide2.QtPrintSupport.QPrintDialog.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintDialog.testOption": ('PySide2.QtPrintSupport.QAbstractPrintDialog.PrintDialogOption',),
-# class PySide2.QtPrintSupport.QPrintEngine:
-# class PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey:
-    "PySide2.QtPrintSupport.QPrintEngine.__init__": (),
-    "PySide2.QtPrintSupport.QPrintEngine.abort": (),
-    "PySide2.QtPrintSupport.QPrintEngine.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrintEngine.newPage": (),
-    "PySide2.QtPrintSupport.QPrintEngine.printerState": (),
-    "PySide2.QtPrintSupport.QPrintEngine.property": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey',),
-    "PySide2.QtPrintSupport.QPrintEngine.setProperty": ('PySide2.QtPrintSupport.QPrintEngine.PrintEnginePropertyKey', 'typing.Any'),
-# class PySide2.QtPrintSupport.QPrintPreviewDialog:
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.done": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.open": [(), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.printer": (),
-    "PySide2.QtPrintSupport.QPrintPreviewDialog.setVisible": ('bool',),
-# class PySide2.QtPrintSupport.QPrintPreviewWidget:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode:
-# class PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode:
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.__init__": [('PySide2.QtPrintSupport.QPrinter', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.currentPage": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitInView": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.fitToWidth": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.orientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.pageCount": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.print_": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setAllPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setCurrentPage": ('int',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setFacingPagesViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setLandscapeOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setPortraitOrientation": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setSinglePageViewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setViewMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ViewMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setVisible": ('bool',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomFactor": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.setZoomMode": ('PySide2.QtPrintSupport.QPrintPreviewWidget.ZoomMode',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.updatePreview": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.viewMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomFactor": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomIn": ('float',),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomMode": (),
-    "PySide2.QtPrintSupport.QPrintPreviewWidget.zoomOut": ('float',),
-# class PySide2.QtPrintSupport.QPrinter:
-# class PySide2.QtPrintSupport.QPrinter.ColorMode:
-# class PySide2.QtPrintSupport.QPrinter.DuplexMode:
-# class PySide2.QtPrintSupport.QPrinter.Orientation:
-# class PySide2.QtPrintSupport.QPrinter.OutputFormat:
-# class PySide2.QtPrintSupport.QPrinter.PageOrder:
-# class PySide2.QtPrintSupport.QPrinter.PaperSource:
-# class PySide2.QtPrintSupport.QPrinter.PrintRange:
-# class PySide2.QtPrintSupport.QPrinter.PrinterMode:
-# class PySide2.QtPrintSupport.QPrinter.PrinterState:
-# class PySide2.QtPrintSupport.QPrinter.Unit:
-    "PySide2.QtPrintSupport.QPrinter.__init__": [('PySide2.QtPrintSupport.QPrinter.PrinterMode',), ('PySide2.QtPrintSupport.QPrinterInfo', 'PySide2.QtPrintSupport.QPrinter.PrinterMode')],
-    "PySide2.QtPrintSupport.QPrinter.abort": (),
-    "PySide2.QtPrintSupport.QPrinter.actualNumCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.collateCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.colorMode": (),
-    "PySide2.QtPrintSupport.QPrinter.copyCount": (),
-    "PySide2.QtPrintSupport.QPrinter.creator": (),
-    "PySide2.QtPrintSupport.QPrinter.devType": (),
-    "PySide2.QtPrintSupport.QPrinter.docName": (),
-    "PySide2.QtPrintSupport.QPrinter.doubleSidedPrinting": (),
-    "PySide2.QtPrintSupport.QPrinter.duplex": (),
-    "PySide2.QtPrintSupport.QPrinter.fontEmbeddingEnabled": (),
-    "PySide2.QtPrintSupport.QPrinter.fromPage": (),
-    "PySide2.QtPrintSupport.QPrinter.fullPage": (),
-    "PySide2.QtPrintSupport.QPrinter.getPageMargins": ('PySide2.QtPrintSupport.QPrinter.Unit',),
-    "PySide2.QtPrintSupport.QPrinter.isValid": (),
-    "PySide2.QtPrintSupport.QPrinter.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtPrintSupport.QPrinter.newPage": (),
-    "PySide2.QtPrintSupport.QPrinter.numCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.orientation": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFileName": (),
-    "PySide2.QtPrintSupport.QPrinter.outputFormat": (),
-    "PySide2.QtPrintSupport.QPrinter.pageOrder": (),
-    "PySide2.QtPrintSupport.QPrinter.pageRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.pageSize": (),
-    "PySide2.QtPrintSupport.QPrinter.paintEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.paperName": (),
-    "PySide2.QtPrintSupport.QPrinter.paperRect": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSize": [(), ('PySide2.QtPrintSupport.QPrinter.Unit',)],
-    "PySide2.QtPrintSupport.QPrinter.paperSource": (),
-    "PySide2.QtPrintSupport.QPrinter.pdfVersion": (),
-    "PySide2.QtPrintSupport.QPrinter.printEngine": (),
-    "PySide2.QtPrintSupport.QPrinter.printProgram": (),
-    "PySide2.QtPrintSupport.QPrinter.printRange": (),
-    "PySide2.QtPrintSupport.QPrinter.printerName": (),
-    "PySide2.QtPrintSupport.QPrinter.printerState": (),
-    "PySide2.QtPrintSupport.QPrinter.resolution": (),
-    "PySide2.QtPrintSupport.QPrinter.setCollateCopies": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setColorMode": ('PySide2.QtPrintSupport.QPrinter.ColorMode',),
-    "PySide2.QtPrintSupport.QPrinter.setCopyCount": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setCreator": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDocName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setDoubleSidedPrinting": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setDuplex": ('PySide2.QtPrintSupport.QPrinter.DuplexMode',),
-    "PySide2.QtPrintSupport.QPrinter.setEngines": ('PySide2.QtPrintSupport.QPrintEngine', 'PySide2.QtGui.QPaintEngine'),
-    "PySide2.QtPrintSupport.QPrinter.setFontEmbeddingEnabled": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setFromTo": ('int', 'int'),
-    "PySide2.QtPrintSupport.QPrinter.setFullPage": ('bool',),
-    "PySide2.QtPrintSupport.QPrinter.setMargins": ('PySide2.QtGui.QPagedPaintDevice.Margins',),
-    "PySide2.QtPrintSupport.QPrinter.setNumCopies": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setOrientation": ('PySide2.QtPrintSupport.QPrinter.Orientation',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFileName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setOutputFormat": ('PySide2.QtPrintSupport.QPrinter.OutputFormat',),
-    "PySide2.QtPrintSupport.QPrinter.setPageMargins": [('PySide2.QtCore.QMarginsF',), ('float', 'float', 'float', 'float', 'PySide2.QtPrintSupport.QPrinter.Unit')],
-    "PySide2.QtPrintSupport.QPrinter.setPageOrder": ('PySide2.QtPrintSupport.QPrinter.PageOrder',),
-    "PySide2.QtPrintSupport.QPrinter.setPageSize": [('PySide2.QtGui.QPageSize',), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPageSizeMM": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPaperSize": [('PySide2.QtCore.QSizeF', 'PySide2.QtPrintSupport.QPrinter.Unit'), ('PySide2.QtGui.QPagedPaintDevice.PageSize',)],
-    "PySide2.QtPrintSupport.QPrinter.setPaperSource": ('PySide2.QtPrintSupport.QPrinter.PaperSource',),
-    "PySide2.QtPrintSupport.QPrinter.setPdfVersion": ('PySide2.QtGui.QPagedPaintDevice.PdfVersion',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintProgram": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setPrintRange": ('PySide2.QtPrintSupport.QPrinter.PrintRange',),
-    "PySide2.QtPrintSupport.QPrinter.setPrinterName": ('str',),
-    "PySide2.QtPrintSupport.QPrinter.setResolution": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.setWinPageSize": ('int',),
-    "PySide2.QtPrintSupport.QPrinter.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinter.supportsMultipleCopies": (),
-    "PySide2.QtPrintSupport.QPrinter.toPage": (),
-    "PySide2.QtPrintSupport.QPrinter.winPageSize": (),
-# class PySide2.QtPrintSupport.QPrinterInfo:
-    "PySide2.QtPrintSupport.QPrinterInfo.__init__": [(), ('PySide2.QtPrintSupport.QPrinter',), ('PySide2.QtPrintSupport.QPrinterInfo',)],
-    "PySide2.QtPrintSupport.QPrinterInfo.__copy__": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinterNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.availablePrinters": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultColorMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultDuplexMode": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinter": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.defaultPrinterName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.description": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isDefault": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isNull": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.isRemote": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.location": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.makeAndModel": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.maximumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.minimumPhysicalPageSize": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerInfo": ('str',),
-    "PySide2.QtPrintSupport.QPrinterInfo.printerName": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.state": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedColorModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedDuplexModes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPageSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedPaperSizes": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedResolutions": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportedSizesWithNames": (),
-    "PySide2.QtPrintSupport.QPrinterInfo.supportsCustomPageSizes": (),
-    }) if "PySide2.QtPrintSupport" in sys.modules else None
-# Module PySide2.QtSql
-sig_dict.update({
-# class PySide2.QtSql.QSql:
-# class PySide2.QtSql.QSql.Location:
-# class PySide2.QtSql.QSql.NumericalPrecisionPolicy:
-# class PySide2.QtSql.QSql.ParamType:
-# class PySide2.QtSql.QSql.ParamTypeFlag:
-# class PySide2.QtSql.QSql.TableType:
-# class PySide2.QtSql.QSqlDatabase:
-    "PySide2.QtSql.QSqlDatabase.__init__": [(), ('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlDriver',), ('str',)],
-    "PySide2.QtSql.QSqlDatabase.__copy__": (),
-    "PySide2.QtSql.QSqlDatabase.addDatabase": [('PySide2.QtSql.QSqlDriver', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.cloneDatabase": [('PySide2.QtSql.QSqlDatabase', 'str'), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.close": (),
-    "PySide2.QtSql.QSqlDatabase.commit": (),
-    "PySide2.QtSql.QSqlDatabase.connectOptions": (),
-    "PySide2.QtSql.QSqlDatabase.connectionName": (),
-    "PySide2.QtSql.QSqlDatabase.connectionNames": (),
-    "PySide2.QtSql.QSqlDatabase.contains": ('str',),
-    "PySide2.QtSql.QSqlDatabase.database": ('str', 'bool'),
-    "PySide2.QtSql.QSqlDatabase.databaseName": (),
-    "PySide2.QtSql.QSqlDatabase.driver": (),
-    "PySide2.QtSql.QSqlDatabase.driverName": (),
-    "PySide2.QtSql.QSqlDatabase.drivers": (),
-    "PySide2.QtSql.QSqlDatabase.exec_": ('str',),
-    "PySide2.QtSql.QSqlDatabase.hostName": (),
-    "PySide2.QtSql.QSqlDatabase.isDriverAvailable": ('str',),
-    "PySide2.QtSql.QSqlDatabase.isOpen": (),
-    "PySide2.QtSql.QSqlDatabase.isOpenError": (),
-    "PySide2.QtSql.QSqlDatabase.isValid": (),
-    "PySide2.QtSql.QSqlDatabase.lastError": (),
-    "PySide2.QtSql.QSqlDatabase.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDatabase.open": [(), ('str', 'str')],
-    "PySide2.QtSql.QSqlDatabase.password": (),
-    "PySide2.QtSql.QSqlDatabase.port": (),
-    "PySide2.QtSql.QSqlDatabase.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDatabase.record": ('str',),
-    "PySide2.QtSql.QSqlDatabase.registerSqlDriver": ('str', 'PySide2.QtSql.QSqlDriverCreatorBase'),
-    "PySide2.QtSql.QSqlDatabase.removeDatabase": ('str',),
-    "PySide2.QtSql.QSqlDatabase.rollback": (),
-    "PySide2.QtSql.QSqlDatabase.setConnectOptions": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setDatabaseName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setHostName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDatabase.setPassword": ('str',),
-    "PySide2.QtSql.QSqlDatabase.setPort": ('int',),
-    "PySide2.QtSql.QSqlDatabase.setUserName": ('str',),
-    "PySide2.QtSql.QSqlDatabase.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDatabase.transaction": (),
-    "PySide2.QtSql.QSqlDatabase.userName": (),
-# class PySide2.QtSql.QSqlDriver:
-# class PySide2.QtSql.QSqlDriver.DbmsType:
-# class PySide2.QtSql.QSqlDriver.DriverFeature:
-# class PySide2.QtSql.QSqlDriver.IdentifierType:
-# class PySide2.QtSql.QSqlDriver.NotificationSource:
-# class PySide2.QtSql.QSqlDriver.StatementType:
-    "PySide2.QtSql.QSqlDriver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlDriver.beginTransaction": (),
-    "PySide2.QtSql.QSqlDriver.cancelQuery": (),
-    "PySide2.QtSql.QSqlDriver.close": (),
-    "PySide2.QtSql.QSqlDriver.commitTransaction": (),
-    "PySide2.QtSql.QSqlDriver.createResult": (),
-    "PySide2.QtSql.QSqlDriver.dbmsType": (),
-    "PySide2.QtSql.QSqlDriver.escapeIdentifier": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.formatValue": ('PySide2.QtSql.QSqlField', 'bool'),
-    "PySide2.QtSql.QSqlDriver.hasFeature": ('PySide2.QtSql.QSqlDriver.DriverFeature',),
-    "PySide2.QtSql.QSqlDriver.isIdentifierEscaped": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.isOpen": (),
-    "PySide2.QtSql.QSqlDriver.isOpenError": (),
-    "PySide2.QtSql.QSqlDriver.lastError": (),
-    "PySide2.QtSql.QSqlDriver.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlDriver.open": ('str', 'str', 'str', 'str', 'int', 'str'),
-    "PySide2.QtSql.QSqlDriver.primaryIndex": ('str',),
-    "PySide2.QtSql.QSqlDriver.record": ('str',),
-    "PySide2.QtSql.QSqlDriver.rollbackTransaction": (),
-    "PySide2.QtSql.QSqlDriver.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlDriver.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlDriver.setOpen": ('bool',),
-    "PySide2.QtSql.QSqlDriver.setOpenError": ('bool',),
-    "PySide2.QtSql.QSqlDriver.sqlStatement": ('PySide2.QtSql.QSqlDriver.StatementType', 'str', 'PySide2.QtSql.QSqlRecord', 'bool'),
-    "PySide2.QtSql.QSqlDriver.stripDelimiters": ('str', 'PySide2.QtSql.QSqlDriver.IdentifierType'),
-    "PySide2.QtSql.QSqlDriver.subscribeToNotification": ('str',),
-    "PySide2.QtSql.QSqlDriver.subscribedToNotifications": (),
-    "PySide2.QtSql.QSqlDriver.tables": ('PySide2.QtSql.QSql.TableType',),
-    "PySide2.QtSql.QSqlDriver.unsubscribeFromNotification": ('str',),
-# class PySide2.QtSql.QSqlDriverCreatorBase:
-    "PySide2.QtSql.QSqlDriverCreatorBase.__init__": (),
-    "PySide2.QtSql.QSqlDriverCreatorBase.createObject": (),
-# class PySide2.QtSql.QSqlError:
-# class PySide2.QtSql.QSqlError.ErrorType:
-    "PySide2.QtSql.QSqlError.__init__": [('PySide2.QtSql.QSqlError',), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'int'), ('str', 'str', 'PySide2.QtSql.QSqlError.ErrorType', 'str')],
-    "PySide2.QtSql.QSqlError.__copy__": (),
-    "PySide2.QtSql.QSqlError.databaseText": (),
-    "PySide2.QtSql.QSqlError.driverText": (),
-    "PySide2.QtSql.QSqlError.isValid": (),
-    "PySide2.QtSql.QSqlError.nativeErrorCode": (),
-    "PySide2.QtSql.QSqlError.number": (),
-    "PySide2.QtSql.QSqlError.setDatabaseText": ('str',),
-    "PySide2.QtSql.QSqlError.setDriverText": ('str',),
-    "PySide2.QtSql.QSqlError.setNumber": ('int',),
-    "PySide2.QtSql.QSqlError.setType": ('PySide2.QtSql.QSqlError.ErrorType',),
-    "PySide2.QtSql.QSqlError.swap": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlError.text": (),
-    "PySide2.QtSql.QSqlError.type": (),
-# class PySide2.QtSql.QSqlField:
-# class PySide2.QtSql.QSqlField.RequiredStatus:
-    "PySide2.QtSql.QSqlField.__init__": [('PySide2.QtSql.QSqlField',), ('str', 'type'), ('str', 'type', 'str')],
-    "PySide2.QtSql.QSqlField.__copy__": (),
-    "PySide2.QtSql.QSqlField.clear": (),
-    "PySide2.QtSql.QSqlField.defaultValue": (),
-    "PySide2.QtSql.QSqlField.isAutoValue": (),
-    "PySide2.QtSql.QSqlField.isGenerated": (),
-    "PySide2.QtSql.QSqlField.isNull": (),
-    "PySide2.QtSql.QSqlField.isReadOnly": (),
-    "PySide2.QtSql.QSqlField.isValid": (),
-    "PySide2.QtSql.QSqlField.length": (),
-    "PySide2.QtSql.QSqlField.name": (),
-    "PySide2.QtSql.QSqlField.precision": (),
-    "PySide2.QtSql.QSqlField.requiredStatus": (),
-    "PySide2.QtSql.QSqlField.setAutoValue": ('bool',),
-    "PySide2.QtSql.QSqlField.setDefaultValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.setGenerated": ('bool',),
-    "PySide2.QtSql.QSqlField.setLength": ('int',),
-    "PySide2.QtSql.QSqlField.setName": ('str',),
-    "PySide2.QtSql.QSqlField.setPrecision": ('int',),
-    "PySide2.QtSql.QSqlField.setReadOnly": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequired": ('bool',),
-    "PySide2.QtSql.QSqlField.setRequiredStatus": ('PySide2.QtSql.QSqlField.RequiredStatus',),
-    "PySide2.QtSql.QSqlField.setSqlType": ('int',),
-    "PySide2.QtSql.QSqlField.setTableName": ('str',),
-    "PySide2.QtSql.QSqlField.setType": ('type',),
-    "PySide2.QtSql.QSqlField.setValue": ('typing.Any',),
-    "PySide2.QtSql.QSqlField.tableName": (),
-    "PySide2.QtSql.QSqlField.type": (),
-    "PySide2.QtSql.QSqlField.typeID": (),
-    "PySide2.QtSql.QSqlField.value": (),
-# class PySide2.QtSql.QSqlIndex:
-    "PySide2.QtSql.QSqlIndex.__init__": [('PySide2.QtSql.QSqlIndex',), ('str', 'str')],
-    "PySide2.QtSql.QSqlIndex.__copy__": (),
-    "PySide2.QtSql.QSqlIndex.append": [('PySide2.QtSql.QSqlField',), ('PySide2.QtSql.QSqlField', 'bool')],
-    "PySide2.QtSql.QSqlIndex.cursorName": (),
-    "PySide2.QtSql.QSqlIndex.isDescending": ('int',),
-    "PySide2.QtSql.QSqlIndex.name": (),
-    "PySide2.QtSql.QSqlIndex.setCursorName": ('str',),
-    "PySide2.QtSql.QSqlIndex.setDescending": ('int', 'bool'),
-    "PySide2.QtSql.QSqlIndex.setName": ('str',),
-# class PySide2.QtSql.QSqlQuery:
-# class PySide2.QtSql.QSqlQuery.BatchExecutionMode:
-    "PySide2.QtSql.QSqlQuery.__init__": [('PySide2.QtSql.QSqlDatabase',), ('PySide2.QtSql.QSqlQuery',), ('PySide2.QtSql.QSqlResult',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-    "PySide2.QtSql.QSqlQuery.__copy__": (),
-    "PySide2.QtSql.QSqlQuery.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlQuery.at": (),
-    "PySide2.QtSql.QSqlQuery.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlQuery.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.boundValues": (),
-    "PySide2.QtSql.QSqlQuery.clear": (),
-    "PySide2.QtSql.QSqlQuery.driver": (),
-    "PySide2.QtSql.QSqlQuery.execBatch": ('PySide2.QtSql.QSqlQuery.BatchExecutionMode',),
-    "PySide2.QtSql.QSqlQuery.exec_": [(), ('str',)],
-    "PySide2.QtSql.QSqlQuery.executedQuery": (),
-    "PySide2.QtSql.QSqlQuery.finish": (),
-    "PySide2.QtSql.QSqlQuery.first": (),
-    "PySide2.QtSql.QSqlQuery.isActive": (),
-    "PySide2.QtSql.QSqlQuery.isForwardOnly": (),
-    "PySide2.QtSql.QSqlQuery.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlQuery.isSelect": (),
-    "PySide2.QtSql.QSqlQuery.isValid": (),
-    "PySide2.QtSql.QSqlQuery.last": (),
-    "PySide2.QtSql.QSqlQuery.lastError": (),
-    "PySide2.QtSql.QSqlQuery.lastInsertId": (),
-    "PySide2.QtSql.QSqlQuery.lastQuery": (),
-    "PySide2.QtSql.QSqlQuery.nextResult": (),
-    "PySide2.QtSql.QSqlQuery.numRowsAffected": (),
-    "PySide2.QtSql.QSqlQuery.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlQuery.prepare": ('str',),
-    "PySide2.QtSql.QSqlQuery.previous": (),
-    "PySide2.QtSql.QSqlQuery.record": (),
-    "PySide2.QtSql.QSqlQuery.result": (),
-    "PySide2.QtSql.QSqlQuery.seek": ('int', 'bool'),
-    "PySide2.QtSql.QSqlQuery.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlQuery.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlQuery.size": (),
-    "PySide2.QtSql.QSqlQuery.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlQueryModel:
-    "PySide2.QtSql.QSqlQueryModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginInsertRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveColumns": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginRemoveRows": ('PySide2.QtCore.QModelIndex', 'int', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.beginResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.canFetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.clear": (),
-    "PySide2.QtSql.QSqlQueryModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.endInsertColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endInsertRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveColumns": (),
-    "PySide2.QtSql.QSqlQueryModel.endRemoveRows": (),
-    "PySide2.QtSql.QSqlQueryModel.endResetModel": (),
-    "PySide2.QtSql.QSqlQueryModel.fetchMore": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.insertColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.lastError": (),
-    "PySide2.QtSql.QSqlQueryModel.query": (),
-    "PySide2.QtSql.QSqlQueryModel.queryChange": (),
-    "PySide2.QtSql.QSqlQueryModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlQueryModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlQueryModel.roleNames": (),
-    "PySide2.QtSql.QSqlQueryModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlQueryModel.setHeaderData": ('int', 'PySide2.QtCore.Qt.Orientation', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlQueryModel.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlQueryModel.setQuery": [('PySide2.QtSql.QSqlQuery',), ('str', 'PySide2.QtSql.QSqlDatabase')],
-# class PySide2.QtSql.QSqlRecord:
-    "PySide2.QtSql.QSqlRecord.__init__": [(), ('PySide2.QtSql.QSqlRecord',)],
-    "PySide2.QtSql.QSqlRecord.__copy__": (),
-    "PySide2.QtSql.QSqlRecord.append": ('PySide2.QtSql.QSqlField',),
-    "PySide2.QtSql.QSqlRecord.clear": (),
-    "PySide2.QtSql.QSqlRecord.clearValues": (),
-    "PySide2.QtSql.QSqlRecord.contains": ('str',),
-    "PySide2.QtSql.QSqlRecord.count": (),
-    "PySide2.QtSql.QSqlRecord.field": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.fieldName": ('int',),
-    "PySide2.QtSql.QSqlRecord.indexOf": ('str',),
-    "PySide2.QtSql.QSqlRecord.insert": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.isEmpty": (),
-    "PySide2.QtSql.QSqlRecord.isGenerated": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.isNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.keyValues": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRecord.remove": ('int',),
-    "PySide2.QtSql.QSqlRecord.replace": ('int', 'PySide2.QtSql.QSqlField'),
-    "PySide2.QtSql.QSqlRecord.setGenerated": [('int', 'bool'), ('str', 'bool')],
-    "PySide2.QtSql.QSqlRecord.setNull": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlRecord.setValue": [('int', 'typing.Any'), ('str', 'typing.Any')],
-    "PySide2.QtSql.QSqlRecord.value": [('int',), ('str',)],
-# class PySide2.QtSql.QSqlRelation:
-    "PySide2.QtSql.QSqlRelation.__init__": [(), ('PySide2.QtSql.QSqlRelation',), ('str', 'str', 'str')],
-    "PySide2.QtSql.QSqlRelation.__copy__": (),
-    "PySide2.QtSql.QSqlRelation.displayColumn": (),
-    "PySide2.QtSql.QSqlRelation.indexColumn": (),
-    "PySide2.QtSql.QSqlRelation.isValid": (),
-    "PySide2.QtSql.QSqlRelation.swap": ('PySide2.QtSql.QSqlRelation',),
-    "PySide2.QtSql.QSqlRelation.tableName": (),
-# class PySide2.QtSql.QSqlRelationalDelegate:
-    "PySide2.QtSql.QSqlRelationalDelegate.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSql.QSqlRelationalDelegate.createEditor": ('PySide2.QtWidgets.QWidget', 'PySide2.QtWidgets.QStyleOptionViewItem', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setEditorData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalDelegate.setModelData": ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QModelIndex'),
-# class PySide2.QtSql.QSqlRelationalTableModel:
-# class PySide2.QtSql.QSqlRelationalTableModel.JoinMode:
-    "PySide2.QtSql.QSqlRelationalTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlRelationalTableModel.clear": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlRelationalTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.relation": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.relationModel": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlRelationalTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlRelationalTableModel.select": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlRelationalTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setJoinMode": ('PySide2.QtSql.QSqlRelationalTableModel.JoinMode',),
-    "PySide2.QtSql.QSqlRelationalTableModel.setRelation": ('int', 'PySide2.QtSql.QSqlRelation'),
-    "PySide2.QtSql.QSqlRelationalTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlRelationalTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-# class PySide2.QtSql.QSqlResult:
-# class PySide2.QtSql.QSqlResult.BindingSyntax:
-    "PySide2.QtSql.QSqlResult.__init__": ('PySide2.QtSql.QSqlDriver',),
-    "PySide2.QtSql.QSqlResult.addBindValue": ('typing.Any', 'PySide2.QtSql.QSql.ParamType'),
-    "PySide2.QtSql.QSqlResult.at": (),
-    "PySide2.QtSql.QSqlResult.bindValue": [('int', 'typing.Any', 'PySide2.QtSql.QSql.ParamType'), ('str', 'typing.Any', 'PySide2.QtSql.QSql.ParamType')],
-    "PySide2.QtSql.QSqlResult.bindValueType": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.bindingSyntax": (),
-    "PySide2.QtSql.QSqlResult.boundValue": [('int',), ('str',)],
-    "PySide2.QtSql.QSqlResult.boundValueCount": (),
-    "PySide2.QtSql.QSqlResult.boundValueName": ('int',),
-    "PySide2.QtSql.QSqlResult.boundValues": (),
-    "PySide2.QtSql.QSqlResult.clear": (),
-    "PySide2.QtSql.QSqlResult.data": ('int',),
-    "PySide2.QtSql.QSqlResult.detachFromResultSet": (),
-    "PySide2.QtSql.QSqlResult.driver": (),
-    "PySide2.QtSql.QSqlResult.execBatch": ('bool',),
-    "PySide2.QtSql.QSqlResult.exec_": (),
-    "PySide2.QtSql.QSqlResult.executedQuery": (),
-    "PySide2.QtSql.QSqlResult.fetch": ('int',),
-    "PySide2.QtSql.QSqlResult.fetchFirst": (),
-    "PySide2.QtSql.QSqlResult.fetchLast": (),
-    "PySide2.QtSql.QSqlResult.fetchNext": (),
-    "PySide2.QtSql.QSqlResult.fetchPrevious": (),
-    "PySide2.QtSql.QSqlResult.handle": (),
-    "PySide2.QtSql.QSqlResult.hasOutValues": (),
-    "PySide2.QtSql.QSqlResult.isActive": (),
-    "PySide2.QtSql.QSqlResult.isForwardOnly": (),
-    "PySide2.QtSql.QSqlResult.isNull": ('int',),
-    "PySide2.QtSql.QSqlResult.isSelect": (),
-    "PySide2.QtSql.QSqlResult.isValid": (),
-    "PySide2.QtSql.QSqlResult.lastError": (),
-    "PySide2.QtSql.QSqlResult.lastInsertId": (),
-    "PySide2.QtSql.QSqlResult.lastQuery": (),
-    "PySide2.QtSql.QSqlResult.nextResult": (),
-    "PySide2.QtSql.QSqlResult.numRowsAffected": (),
-    "PySide2.QtSql.QSqlResult.numericalPrecisionPolicy": (),
-    "PySide2.QtSql.QSqlResult.prepare": ('str',),
-    "PySide2.QtSql.QSqlResult.record": (),
-    "PySide2.QtSql.QSqlResult.reset": ('str',),
-    "PySide2.QtSql.QSqlResult.resetBindCount": (),
-    "PySide2.QtSql.QSqlResult.savePrepare": ('str',),
-    "PySide2.QtSql.QSqlResult.setActive": ('bool',),
-    "PySide2.QtSql.QSqlResult.setAt": ('int',),
-    "PySide2.QtSql.QSqlResult.setForwardOnly": ('bool',),
-    "PySide2.QtSql.QSqlResult.setLastError": ('PySide2.QtSql.QSqlError',),
-    "PySide2.QtSql.QSqlResult.setNumericalPrecisionPolicy": ('PySide2.QtSql.QSql.NumericalPrecisionPolicy',),
-    "PySide2.QtSql.QSqlResult.setQuery": ('str',),
-    "PySide2.QtSql.QSqlResult.setSelect": ('bool',),
-    "PySide2.QtSql.QSqlResult.size": (),
-# class PySide2.QtSql.QSqlTableModel:
-# class PySide2.QtSql.QSqlTableModel.EditStrategy:
-    "PySide2.QtSql.QSqlTableModel.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtSql.QSqlDatabase'),
-    "PySide2.QtSql.QSqlTableModel.clear": (),
-    "PySide2.QtSql.QSqlTableModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtSql.QSqlTableModel.database": (),
-    "PySide2.QtSql.QSqlTableModel.deleteRowFromTable": ('int',),
-    "PySide2.QtSql.QSqlTableModel.editStrategy": (),
-    "PySide2.QtSql.QSqlTableModel.fieldIndex": ('str',),
-    "PySide2.QtSql.QSqlTableModel.filter": (),
-    "PySide2.QtSql.QSqlTableModel.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtSql.QSqlTableModel.indexInQuery": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.insertRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.insertRowIntoTable": ('PySide2.QtSql.QSqlRecord',),
-    "PySide2.QtSql.QSqlTableModel.insertRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.isDirty": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtSql.QSqlTableModel.orderByClause": (),
-    "PySide2.QtSql.QSqlTableModel.primaryKey": (),
-    "PySide2.QtSql.QSqlTableModel.primaryValues": ('int',),
-    "PySide2.QtSql.QSqlTableModel.record": [(), ('int',)],
-    "PySide2.QtSql.QSqlTableModel.removeColumns": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.removeRows": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtSql.QSqlTableModel.revert": (),
-    "PySide2.QtSql.QSqlTableModel.revertAll": (),
-    "PySide2.QtSql.QSqlTableModel.revertRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtSql.QSqlTableModel.select": (),
-    "PySide2.QtSql.QSqlTableModel.selectRow": ('int',),
-    "PySide2.QtSql.QSqlTableModel.selectStatement": (),
-    "PySide2.QtSql.QSqlTableModel.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-    "PySide2.QtSql.QSqlTableModel.setEditStrategy": ('PySide2.QtSql.QSqlTableModel.EditStrategy',),
-    "PySide2.QtSql.QSqlTableModel.setFilter": ('str',),
-    "PySide2.QtSql.QSqlTableModel.setPrimaryKey": ('PySide2.QtSql.QSqlIndex',),
-    "PySide2.QtSql.QSqlTableModel.setQuery": ('PySide2.QtSql.QSqlQuery',),
-    "PySide2.QtSql.QSqlTableModel.setRecord": ('int', 'PySide2.QtSql.QSqlRecord'),
-    "PySide2.QtSql.QSqlTableModel.setSort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.setTable": ('str',),
-    "PySide2.QtSql.QSqlTableModel.sort": ('int', 'PySide2.QtCore.Qt.SortOrder'),
-    "PySide2.QtSql.QSqlTableModel.submit": (),
-    "PySide2.QtSql.QSqlTableModel.submitAll": (),
-    "PySide2.QtSql.QSqlTableModel.tableName": (),
-    "PySide2.QtSql.QSqlTableModel.updateRowInTable": ('int', 'PySide2.QtSql.QSqlRecord'),
-    }) if "PySide2.QtSql" in sys.modules else None
-# Module PySide2.QtNetwork
-sig_dict.update({
-# class PySide2.QtNetwork.QAbstractNetworkCache:
-    "PySide2.QtNetwork.QAbstractNetworkCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.cacheSize": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.clear": (),
-    "PySide2.QtNetwork.QAbstractNetworkCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QAbstractNetworkCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QAbstractSocket:
-# class PySide2.QtNetwork.QAbstractSocket.BindFlag:
-# class PySide2.QtNetwork.QAbstractSocket.BindMode:
-# class PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol:
-# class PySide2.QtNetwork.QAbstractSocket.PauseMode:
-# class PySide2.QtNetwork.QAbstractSocket.PauseModes:
-# class PySide2.QtNetwork.QAbstractSocket.SocketError:
-# class PySide2.QtNetwork.QAbstractSocket.SocketOption:
-# class PySide2.QtNetwork.QAbstractSocket.SocketState:
-# class PySide2.QtNetwork.QAbstractSocket.SocketType:
-    "PySide2.QtNetwork.QAbstractSocket.__init__": ('PySide2.QtNetwork.QAbstractSocket.SocketType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QAbstractSocket.abort": (),
-    "PySide2.QtNetwork.QAbstractSocket.atEnd": (),
-    "PySide2.QtNetwork.QAbstractSocket.bind": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtNetwork.QAbstractSocket.BindMode'), ('int', 'PySide2.QtNetwork.QAbstractSocket.BindMode')],
-    "PySide2.QtNetwork.QAbstractSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QAbstractSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QAbstractSocket.canReadLine": (),
-    "PySide2.QtNetwork.QAbstractSocket.close": (),
-    "PySide2.QtNetwork.QAbstractSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QAbstractSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QAbstractSocket.error": (),
-    "PySide2.QtNetwork.QAbstractSocket.flush": (),
-    "PySide2.QtNetwork.QAbstractSocket.isSequential": (),
-    "PySide2.QtNetwork.QAbstractSocket.isValid": (),
-    "PySide2.QtNetwork.QAbstractSocket.localAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.localPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.pauseMode": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerAddress": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerName": (),
-    "PySide2.QtNetwork.QAbstractSocket.peerPort": (),
-    "PySide2.QtNetwork.QAbstractSocket.protocolTag": (),
-    "PySide2.QtNetwork.QAbstractSocket.proxy": (),
-    "PySide2.QtNetwork.QAbstractSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QAbstractSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.readLineData": ('str', 'int'),
-    "PySide2.QtNetwork.QAbstractSocket.resume": (),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerAddress": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerName": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QAbstractSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QAbstractSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketError": ('PySide2.QtNetwork.QAbstractSocket.SocketError',),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QAbstractSocket.setSocketState": ('PySide2.QtNetwork.QAbstractSocket.SocketState',),
-    "PySide2.QtNetwork.QAbstractSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QAbstractSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QAbstractSocket.socketType": (),
-    "PySide2.QtNetwork.QAbstractSocket.state": (),
-    "PySide2.QtNetwork.QAbstractSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QAbstractSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QAuthenticator:
-    "PySide2.QtNetwork.QAuthenticator.__init__": [(), ('PySide2.QtNetwork.QAuthenticator',)],
-    "PySide2.QtNetwork.QAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QAuthenticator.isNull": (),
-    "PySide2.QtNetwork.QAuthenticator.option": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.options": (),
-    "PySide2.QtNetwork.QAuthenticator.password": (),
-    "PySide2.QtNetwork.QAuthenticator.realm": (),
-    "PySide2.QtNetwork.QAuthenticator.setOption": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QAuthenticator.setPassword": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setRealm": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.setUser": ('str',),
-    "PySide2.QtNetwork.QAuthenticator.user": (),
-# class PySide2.QtNetwork.QDnsDomainNameRecord:
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__init__": [(), ('PySide2.QtNetwork.QDnsDomainNameRecord',)],
-    "PySide2.QtNetwork.QDnsDomainNameRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.name": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.swap": ('PySide2.QtNetwork.QDnsDomainNameRecord',),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsDomainNameRecord.value": (),
-# class PySide2.QtNetwork.QDnsHostAddressRecord:
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__init__": [(), ('PySide2.QtNetwork.QDnsHostAddressRecord',)],
-    "PySide2.QtNetwork.QDnsHostAddressRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.name": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.swap": ('PySide2.QtNetwork.QDnsHostAddressRecord',),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsHostAddressRecord.value": (),
-# class PySide2.QtNetwork.QDnsLookup:
-# class PySide2.QtNetwork.QDnsLookup.Error:
-# class PySide2.QtNetwork.QDnsLookup.Type:
-    "PySide2.QtNetwork.QDnsLookup.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtNetwork.QDnsLookup.Type', 'str', 'PySide2.QtNetwork.QHostAddress', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QDnsLookup.abort": (),
-    "PySide2.QtNetwork.QDnsLookup.canonicalNameRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.error": (),
-    "PySide2.QtNetwork.QDnsLookup.errorString": (),
-    "PySide2.QtNetwork.QDnsLookup.hostAddressRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.isFinished": (),
-    "PySide2.QtNetwork.QDnsLookup.lookup": (),
-    "PySide2.QtNetwork.QDnsLookup.mailExchangeRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.name": (),
-    "PySide2.QtNetwork.QDnsLookup.nameServerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.nameserver": (),
-    "PySide2.QtNetwork.QDnsLookup.pointerRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.serviceRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.setName": ('str',),
-    "PySide2.QtNetwork.QDnsLookup.setNameserver": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QDnsLookup.setType": ('PySide2.QtNetwork.QDnsLookup.Type',),
-    "PySide2.QtNetwork.QDnsLookup.textRecords": (),
-    "PySide2.QtNetwork.QDnsLookup.type": (),
-# class PySide2.QtNetwork.QDnsMailExchangeRecord:
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__init__": [(), ('PySide2.QtNetwork.QDnsMailExchangeRecord',)],
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.exchange": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.name": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.preference": (),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.swap": ('PySide2.QtNetwork.QDnsMailExchangeRecord',),
-    "PySide2.QtNetwork.QDnsMailExchangeRecord.timeToLive": (),
-# class PySide2.QtNetwork.QDnsServiceRecord:
-    "PySide2.QtNetwork.QDnsServiceRecord.__init__": [(), ('PySide2.QtNetwork.QDnsServiceRecord',)],
-    "PySide2.QtNetwork.QDnsServiceRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.name": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.port": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.priority": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.swap": ('PySide2.QtNetwork.QDnsServiceRecord',),
-    "PySide2.QtNetwork.QDnsServiceRecord.target": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsServiceRecord.weight": (),
-# class PySide2.QtNetwork.QDnsTextRecord:
-    "PySide2.QtNetwork.QDnsTextRecord.__init__": [(), ('PySide2.QtNetwork.QDnsTextRecord',)],
-    "PySide2.QtNetwork.QDnsTextRecord.__copy__": (),
-    "PySide2.QtNetwork.QDnsTextRecord.name": (),
-    "PySide2.QtNetwork.QDnsTextRecord.swap": ('PySide2.QtNetwork.QDnsTextRecord',),
-    "PySide2.QtNetwork.QDnsTextRecord.timeToLive": (),
-    "PySide2.QtNetwork.QDnsTextRecord.values": (),
-# class PySide2.QtNetwork.QDtls:
-# class PySide2.QtNetwork.QDtls.HandshakeState:
-    "PySide2.QtNetwork.QDtls.__init__": ('PySide2.QtNetwork.QSslSocket.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QDtls.abortHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.decryptDatagram": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.doHandshake": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QDtls.dtlsConfiguration": (),
-    "PySide2.QtNetwork.QDtls.dtlsError": (),
-    "PySide2.QtNetwork.QDtls.dtlsErrorString": (),
-    "PySide2.QtNetwork.QDtls.handleTimeout": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.handshakeState": (),
-    "PySide2.QtNetwork.QDtls.ignoreVerificationErrors": ('typing.List[PySide2.QtNetwork.QSslError]',),
-    "PySide2.QtNetwork.QDtls.isConnectionEncrypted": (),
-    "PySide2.QtNetwork.QDtls.mtuHint": (),
-    "PySide2.QtNetwork.QDtls.peerAddress": (),
-    "PySide2.QtNetwork.QDtls.peerPort": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationErrors": (),
-    "PySide2.QtNetwork.QDtls.peerVerificationName": (),
-    "PySide2.QtNetwork.QDtls.resumeHandshake": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sessionCipher": (),
-    "PySide2.QtNetwork.QDtls.sessionProtocol": (),
-    "PySide2.QtNetwork.QDtls.setDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QDtls.setMtuHint": ('int',),
-    "PySide2.QtNetwork.QDtls.setPeer": ('PySide2.QtNetwork.QHostAddress', 'int', 'str'),
-    "PySide2.QtNetwork.QDtls.setPeerVerificationName": ('str',),
-    "PySide2.QtNetwork.QDtls.shutdown": ('PySide2.QtNetwork.QUdpSocket',),
-    "PySide2.QtNetwork.QDtls.sslMode": (),
-    "PySide2.QtNetwork.QDtls.writeDatagramEncrypted": ('PySide2.QtNetwork.QUdpSocket', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtNetwork.QDtlsError:
-# class PySide2.QtNetwork.QHostAddress:
-# class PySide2.QtNetwork.QHostAddress.ConversionMode:
-# class PySide2.QtNetwork.QHostAddress.ConversionModeFlag:
-# class PySide2.QtNetwork.QHostAddress.SpecialAddress:
-    "PySide2.QtNetwork.QHostAddress.__init__": [(), ('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.__copy__": (),
-    "PySide2.QtNetwork.QHostAddress.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QHostAddress.clear": (),
-    "PySide2.QtNetwork.QHostAddress.isBroadcast": (),
-    "PySide2.QtNetwork.QHostAddress.isEqual": ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QHostAddress.ConversionMode'),
-    "PySide2.QtNetwork.QHostAddress.isGlobal": (),
-    "PySide2.QtNetwork.QHostAddress.isInSubnet": [('PySide2.QtNetwork.QHostAddress', 'int'), ('typing.Tuple[PySide2.QtNetwork.QHostAddress, int]',)],
-    "PySide2.QtNetwork.QHostAddress.isLinkLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isLoopback": (),
-    "PySide2.QtNetwork.QHostAddress.isMulticast": (),
-    "PySide2.QtNetwork.QHostAddress.isNull": (),
-    "PySide2.QtNetwork.QHostAddress.isSiteLocal": (),
-    "PySide2.QtNetwork.QHostAddress.isUniqueLocalUnicast": (),
-    "PySide2.QtNetwork.QHostAddress.parseSubnet": ('str',),
-    "PySide2.QtNetwork.QHostAddress.protocol": (),
-    "PySide2.QtNetwork.QHostAddress.scopeId": (),
-    "PySide2.QtNetwork.QHostAddress.setAddress": [('PySide2.QtNetwork.QHostAddress.SpecialAddress',), ('PySide2.QtNetwork.QIPv6Address',), ('int',), ('str',)],
-    "PySide2.QtNetwork.QHostAddress.setScopeId": ('str',),
-    "PySide2.QtNetwork.QHostAddress.swap": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QHostAddress.toIPv4Address": (),
-    "PySide2.QtNetwork.QHostAddress.toIPv6Address": (),
-    "PySide2.QtNetwork.QHostAddress.toString": (),
-# class PySide2.QtNetwork.QHostInfo:
-# class PySide2.QtNetwork.QHostInfo.HostInfoError:
-    "PySide2.QtNetwork.QHostInfo.__init__": [('PySide2.QtNetwork.QHostInfo',), ('int',)],
-    "PySide2.QtNetwork.QHostInfo.__copy__": (),
-    "PySide2.QtNetwork.QHostInfo.abortHostLookup": ('int',),
-    "PySide2.QtNetwork.QHostInfo.addresses": (),
-    "PySide2.QtNetwork.QHostInfo.error": (),
-    "PySide2.QtNetwork.QHostInfo.errorString": (),
-    "PySide2.QtNetwork.QHostInfo.fromName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.hostName": (),
-    "PySide2.QtNetwork.QHostInfo.localDomainName": (),
-    "PySide2.QtNetwork.QHostInfo.localHostName": (),
-    "PySide2.QtNetwork.QHostInfo.lookupId": (),
-    "PySide2.QtNetwork.QHostInfo.setAddresses": ('typing.Sequence[PySide2.QtNetwork.QHostAddress]',),
-    "PySide2.QtNetwork.QHostInfo.setError": ('PySide2.QtNetwork.QHostInfo.HostInfoError',),
-    "PySide2.QtNetwork.QHostInfo.setErrorString": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setHostName": ('str',),
-    "PySide2.QtNetwork.QHostInfo.setLookupId": ('int',),
-    "PySide2.QtNetwork.QHostInfo.swap": ('PySide2.QtNetwork.QHostInfo',),
-# class PySide2.QtNetwork.QHstsPolicy:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlag:
-# class PySide2.QtNetwork.QHstsPolicy.PolicyFlags:
-    "PySide2.QtNetwork.QHstsPolicy.__init__": [(), ('PySide2.QtCore.QDateTime', 'PySide2.QtNetwork.QHstsPolicy.PolicyFlags', 'str', 'PySide2.QtCore.QUrl.ParsingMode'), ('PySide2.QtNetwork.QHstsPolicy',)],
-    "PySide2.QtNetwork.QHstsPolicy.__copy__": (),
-    "PySide2.QtNetwork.QHstsPolicy.expiry": (),
-    "PySide2.QtNetwork.QHstsPolicy.host": ('PySide2.QtCore.QUrl.ComponentFormattingOption',),
-    "PySide2.QtNetwork.QHstsPolicy.includesSubDomains": (),
-    "PySide2.QtNetwork.QHstsPolicy.isExpired": (),
-    "PySide2.QtNetwork.QHstsPolicy.setExpiry": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QHstsPolicy.setHost": ('str', 'PySide2.QtCore.QUrl.ParsingMode'),
-    "PySide2.QtNetwork.QHstsPolicy.setIncludesSubDomains": ('bool',),
-    "PySide2.QtNetwork.QHstsPolicy.swap": ('PySide2.QtNetwork.QHstsPolicy',),
-# class PySide2.QtNetwork.QHttpMultiPart:
-# class PySide2.QtNetwork.QHttpMultiPart.ContentType:
-    "PySide2.QtNetwork.QHttpMultiPart.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtNetwork.QHttpMultiPart.ContentType', 'PySide2.QtCore.QObject')],
-    "PySide2.QtNetwork.QHttpMultiPart.append": ('PySide2.QtNetwork.QHttpPart',),
-    "PySide2.QtNetwork.QHttpMultiPart.boundary": (),
-    "PySide2.QtNetwork.QHttpMultiPart.setBoundary": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpMultiPart.setContentType": ('PySide2.QtNetwork.QHttpMultiPart.ContentType',),
-# class PySide2.QtNetwork.QHttpPart:
-    "PySide2.QtNetwork.QHttpPart.__init__": [(), ('PySide2.QtNetwork.QHttpPart',)],
-    "PySide2.QtNetwork.QHttpPart.__copy__": (),
-    "PySide2.QtNetwork.QHttpPart.setBody": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QHttpPart.setBodyDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QHttpPart.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QHttpPart.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QHttpPart.swap": ('PySide2.QtNetwork.QHttpPart',),
-# class PySide2.QtNetwork.QIPv6Address:
-    "PySide2.QtNetwork.QIPv6Address.__init__": [(), ('PySide2.QtNetwork.QIPv6Address',)],
-    "PySide2.QtNetwork.QIPv6Address.__copy__": (),
-# class PySide2.QtNetwork.QLocalServer:
-# class PySide2.QtNetwork.QLocalServer.SocketOption:
-# class PySide2.QtNetwork.QLocalServer.SocketOptions:
-    "PySide2.QtNetwork.QLocalServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalServer.close": (),
-    "PySide2.QtNetwork.QLocalServer.errorString": (),
-    "PySide2.QtNetwork.QLocalServer.fullServerName": (),
-    "PySide2.QtNetwork.QLocalServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QLocalServer.isListening": (),
-    "PySide2.QtNetwork.QLocalServer.listen": [('int',), ('str',)],
-    "PySide2.QtNetwork.QLocalServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QLocalServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QLocalServer.removeServer": ('str',),
-    "PySide2.QtNetwork.QLocalServer.serverError": (),
-    "PySide2.QtNetwork.QLocalServer.serverName": (),
-    "PySide2.QtNetwork.QLocalServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QLocalServer.setSocketOptions": ('PySide2.QtNetwork.QLocalServer.SocketOptions',),
-    "PySide2.QtNetwork.QLocalServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalServer.socketOptions": (),
-    "PySide2.QtNetwork.QLocalServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QLocalSocket:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketError:
-# class PySide2.QtNetwork.QLocalSocket.LocalSocketState:
-    "PySide2.QtNetwork.QLocalSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QLocalSocket.abort": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QLocalSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QLocalSocket.canReadLine": (),
-    "PySide2.QtNetwork.QLocalSocket.close": (),
-    "PySide2.QtNetwork.QLocalSocket.connectToServer": [('PySide2.QtCore.QIODevice.OpenMode',), ('str', 'PySide2.QtCore.QIODevice.OpenMode')],
-    "PySide2.QtNetwork.QLocalSocket.disconnectFromServer": (),
-    "PySide2.QtNetwork.QLocalSocket.error": (),
-    "PySide2.QtNetwork.QLocalSocket.flush": (),
-    "PySide2.QtNetwork.QLocalSocket.fullServerName": (),
-    "PySide2.QtNetwork.QLocalSocket.isSequential": (),
-    "PySide2.QtNetwork.QLocalSocket.isValid": (),
-    "PySide2.QtNetwork.QLocalSocket.open": ('PySide2.QtCore.QIODevice.OpenMode',),
-    "PySide2.QtNetwork.QLocalSocket.readBufferSize": (),
-    "PySide2.QtNetwork.QLocalSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QLocalSocket.serverName": (),
-    "PySide2.QtNetwork.QLocalSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.setServerName": ('str',),
-    "PySide2.QtNetwork.QLocalSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QLocalSocket.LocalSocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QLocalSocket.socketDescriptor": (),
-    "PySide2.QtNetwork.QLocalSocket.state": (),
-    "PySide2.QtNetwork.QLocalSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QLocalSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkAccessManager:
-# class PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility:
-# class PySide2.QtNetwork.QNetworkAccessManager.Operation:
-    "PySide2.QtNetwork.QNetworkAccessManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkAccessManager.activeConfiguration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.addStrictTransportSecurityHosts": ('typing.List[PySide2.QtNetwork.QHstsPolicy]',),
-    "PySide2.QtNetwork.QNetworkAccessManager.autoDeleteReplies": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.cache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearAccessCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.clearConnectionCache": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.configuration": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHost": ('str', 'int'),
-    "PySide2.QtNetwork.QNetworkAccessManager.connectToHostEncrypted": [('str', 'int', 'PySide2.QtNetwork.QSslConfiguration'), ('str', 'int', 'PySide2.QtNetwork.QSslConfiguration', 'str')],
-    "PySide2.QtNetwork.QNetworkAccessManager.cookieJar": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.createRequest": ('PySide2.QtNetwork.QNetworkAccessManager.Operation', 'PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtNetwork.QNetworkAccessManager.deleteResource": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.enableStrictTransportSecurityStore": ('bool', 'str'),
-    "PySide2.QtNetwork.QNetworkAccessManager.get": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.head": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.isStrictTransportSecurityStoreEnabled": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.networkAccessible": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.post": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.proxy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.proxyFactory": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.put": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.redirectPolicy": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.sendCustomRequest": [('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'), ('PySide2.QtNetwork.QNetworkRequest', 'PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHttpMultiPart')],
-    "PySide2.QtNetwork.QNetworkAccessManager.setAutoDeleteReplies": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCache": ('PySide2.QtNetwork.QAbstractNetworkCache',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setCookieJar": ('PySide2.QtNetwork.QNetworkCookieJar',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setNetworkAccessible": ('PySide2.QtNetwork.QNetworkAccessManager.NetworkAccessibility',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setRedirectPolicy": ('PySide2.QtNetwork.QNetworkRequest.RedirectPolicy',),
-    "PySide2.QtNetwork.QNetworkAccessManager.setStrictTransportSecurityEnabled": ('bool',),
-    "PySide2.QtNetwork.QNetworkAccessManager.strictTransportSecurityHosts": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemes": (),
-    "PySide2.QtNetwork.QNetworkAccessManager.supportedSchemesImplementation": (),
-# class PySide2.QtNetwork.QNetworkAddressEntry:
-# class PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus:
-    "PySide2.QtNetwork.QNetworkAddressEntry.__init__": [(), ('PySide2.QtNetwork.QNetworkAddressEntry',)],
-    "PySide2.QtNetwork.QNetworkAddressEntry.__copy__": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.broadcast": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.clearAddressLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.dnsEligibility": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.ip": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isLifetimeKnown": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isPermanent": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.isTemporary": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.netmask": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.preferredLifetime": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.prefixLength": (),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setAddressLifetime": ('PySide2.QtCore.QDeadlineTimer', 'PySide2.QtCore.QDeadlineTimer'),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setBroadcast": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setDnsEligibility": ('PySide2.QtNetwork.QNetworkAddressEntry.DnsEligibilityStatus',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setIp": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setNetmask": ('PySide2.QtNetwork.QHostAddress',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.setPrefixLength": ('int',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.swap": ('PySide2.QtNetwork.QNetworkAddressEntry',),
-    "PySide2.QtNetwork.QNetworkAddressEntry.validityLifetime": (),
-# class PySide2.QtNetwork.QNetworkCacheMetaData:
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__init__": [(), ('PySide2.QtNetwork.QNetworkCacheMetaData',)],
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.attributes": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.isValid": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.lastModified": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.rawHeaders": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.saveToDisk": (),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setAttributes": ('typing.Dict[PySide2.QtNetwork.QNetworkRequest.Attribute, typing.Any]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setLastModified": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setRawHeaders": ('typing.Sequence[typing.Tuple]',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setSaveToDisk": ('bool',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.swap": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkCacheMetaData.url": (),
-# class PySide2.QtNetwork.QNetworkConfiguration:
-# class PySide2.QtNetwork.QNetworkConfiguration.BearerType:
-# class PySide2.QtNetwork.QNetworkConfiguration.Purpose:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlag:
-# class PySide2.QtNetwork.QNetworkConfiguration.StateFlags:
-# class PySide2.QtNetwork.QNetworkConfiguration.Type:
-    "PySide2.QtNetwork.QNetworkConfiguration.__init__": [(), ('PySide2.QtNetwork.QNetworkConfiguration',)],
-    "PySide2.QtNetwork.QNetworkConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerType": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeFamily": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.bearerTypeName": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.children": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.connectTimeout": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.identifier": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isRoamingAvailable": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.isValid": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.name": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.purpose": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.setConnectTimeout": ('int',),
-    "PySide2.QtNetwork.QNetworkConfiguration.state": (),
-    "PySide2.QtNetwork.QNetworkConfiguration.swap": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkConfiguration.type": (),
-# class PySide2.QtNetwork.QNetworkConfigurationManager:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capabilities:
-# class PySide2.QtNetwork.QNetworkConfigurationManager.Capability:
-    "PySide2.QtNetwork.QNetworkConfigurationManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.allConfigurations": ('PySide2.QtNetwork.QNetworkConfiguration.StateFlags',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.capabilities": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.configurationFromIdentifier": ('str',),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.defaultConfiguration": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.isOnline": (),
-    "PySide2.QtNetwork.QNetworkConfigurationManager.updateConfigurations": (),
-# class PySide2.QtNetwork.QNetworkCookie:
-# class PySide2.QtNetwork.QNetworkCookie.RawForm:
-    "PySide2.QtNetwork.QNetworkCookie.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QNetworkCookie',)],
-    "PySide2.QtNetwork.QNetworkCookie.__copy__": (),
-    "PySide2.QtNetwork.QNetworkCookie.domain": (),
-    "PySide2.QtNetwork.QNetworkCookie.expirationDate": (),
-    "PySide2.QtNetwork.QNetworkCookie.hasSameIdentifier": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.isHttpOnly": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSecure": (),
-    "PySide2.QtNetwork.QNetworkCookie.isSessionCookie": (),
-    "PySide2.QtNetwork.QNetworkCookie.name": (),
-    "PySide2.QtNetwork.QNetworkCookie.normalize": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookie.parseCookies": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.path": (),
-    "PySide2.QtNetwork.QNetworkCookie.setDomain": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setExpirationDate": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtNetwork.QNetworkCookie.setHttpOnly": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.setPath": ('str',),
-    "PySide2.QtNetwork.QNetworkCookie.setSecure": ('bool',),
-    "PySide2.QtNetwork.QNetworkCookie.setValue": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkCookie.swap": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookie.toRawForm": ('PySide2.QtNetwork.QNetworkCookie.RawForm',),
-    "PySide2.QtNetwork.QNetworkCookie.value": (),
-# class PySide2.QtNetwork.QNetworkCookieJar:
-    "PySide2.QtNetwork.QNetworkCookieJar.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkCookieJar.allCookies": (),
-    "PySide2.QtNetwork.QNetworkCookieJar.cookiesForUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkCookieJar.deleteCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.insertCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setAllCookies": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]',),
-    "PySide2.QtNetwork.QNetworkCookieJar.setCookiesFromUrl": ('typing.Sequence[PySide2.QtNetwork.QNetworkCookie]', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtNetwork.QNetworkCookieJar.updateCookie": ('PySide2.QtNetwork.QNetworkCookie',),
-    "PySide2.QtNetwork.QNetworkCookieJar.validateCookie": ('PySide2.QtNetwork.QNetworkCookie', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtNetwork.QNetworkDatagram:
-    "PySide2.QtNetwork.QNetworkDatagram.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    "PySide2.QtNetwork.QNetworkDatagram.__copy__": (),
-    "PySide2.QtNetwork.QNetworkDatagram.clear": (),
-    "PySide2.QtNetwork.QNetworkDatagram.data": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.destinationPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.hopLimit": (),
-    "PySide2.QtNetwork.QNetworkDatagram.interfaceIndex": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isNull": (),
-    "PySide2.QtNetwork.QNetworkDatagram.isValid": (),
-    "PySide2.QtNetwork.QNetworkDatagram.makeReply": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.senderAddress": (),
-    "PySide2.QtNetwork.QNetworkDatagram.senderPort": (),
-    "PySide2.QtNetwork.QNetworkDatagram.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkDatagram.setDestination": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.setHopLimit": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setInterfaceIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkDatagram.setSender": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QNetworkDatagram.swap": ('PySide2.QtNetwork.QNetworkDatagram',),
-# class PySide2.QtNetwork.QNetworkDiskCache:
-    "PySide2.QtNetwork.QNetworkDiskCache.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheDirectory": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.cacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.clear": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.data": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.expire": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.fileMetaData": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.insert": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtNetwork.QNetworkDiskCache.maximumCacheSize": (),
-    "PySide2.QtNetwork.QNetworkDiskCache.metaData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.prepare": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-    "PySide2.QtNetwork.QNetworkDiskCache.remove": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setCacheDirectory": ('str',),
-    "PySide2.QtNetwork.QNetworkDiskCache.setMaximumCacheSize": ('int',),
-    "PySide2.QtNetwork.QNetworkDiskCache.updateMetaData": ('PySide2.QtNetwork.QNetworkCacheMetaData',),
-# class PySide2.QtNetwork.QNetworkInterface:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlag:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceFlags:
-# class PySide2.QtNetwork.QNetworkInterface.InterfaceType:
-    "PySide2.QtNetwork.QNetworkInterface.__init__": [(), ('PySide2.QtNetwork.QNetworkInterface',)],
-    "PySide2.QtNetwork.QNetworkInterface.__copy__": (),
-    "PySide2.QtNetwork.QNetworkInterface.addressEntries": (),
-    "PySide2.QtNetwork.QNetworkInterface.allAddresses": (),
-    "PySide2.QtNetwork.QNetworkInterface.allInterfaces": (),
-    "PySide2.QtNetwork.QNetworkInterface.flags": (),
-    "PySide2.QtNetwork.QNetworkInterface.hardwareAddress": (),
-    "PySide2.QtNetwork.QNetworkInterface.humanReadableName": (),
-    "PySide2.QtNetwork.QNetworkInterface.index": (),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceIndexFromName": ('str',),
-    "PySide2.QtNetwork.QNetworkInterface.interfaceNameFromIndex": ('int',),
-    "PySide2.QtNetwork.QNetworkInterface.isValid": (),
-    "PySide2.QtNetwork.QNetworkInterface.maximumTransmissionUnit": (),
-    "PySide2.QtNetwork.QNetworkInterface.name": (),
-    "PySide2.QtNetwork.QNetworkInterface.swap": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QNetworkInterface.type": (),
-# class PySide2.QtNetwork.QNetworkProxy:
-# class PySide2.QtNetwork.QNetworkProxy.Capabilities:
-# class PySide2.QtNetwork.QNetworkProxy.Capability:
-# class PySide2.QtNetwork.QNetworkProxy.ProxyType:
-    "PySide2.QtNetwork.QNetworkProxy.__init__": [(), ('PySide2.QtNetwork.QNetworkProxy',), ('PySide2.QtNetwork.QNetworkProxy.ProxyType', 'str', 'int', 'str', 'str')],
-    "PySide2.QtNetwork.QNetworkProxy.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxy.applicationProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.capabilities": (),
-    "PySide2.QtNetwork.QNetworkProxy.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkProxy.hostName": (),
-    "PySide2.QtNetwork.QNetworkProxy.isCachingProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.isTransparentProxy": (),
-    "PySide2.QtNetwork.QNetworkProxy.password": (),
-    "PySide2.QtNetwork.QNetworkProxy.port": (),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkProxy.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkProxy.setApplicationProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.setCapabilities": ('PySide2.QtNetwork.QNetworkProxy.Capabilities',),
-    "PySide2.QtNetwork.QNetworkProxy.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkProxy.setHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPassword": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.setPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxy.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkProxy.setType": ('PySide2.QtNetwork.QNetworkProxy.ProxyType',),
-    "PySide2.QtNetwork.QNetworkProxy.setUser": ('str',),
-    "PySide2.QtNetwork.QNetworkProxy.swap": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QNetworkProxy.type": (),
-    "PySide2.QtNetwork.QNetworkProxy.user": (),
-# class PySide2.QtNetwork.QNetworkProxyFactory:
-    "PySide2.QtNetwork.QNetworkProxyFactory.__init__": (),
-    "PySide2.QtNetwork.QNetworkProxyFactory.proxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.queryProxy": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setApplicationProxyFactory": ('PySide2.QtNetwork.QNetworkProxyFactory',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration": ('bool',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.systemProxyForQuery": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyFactory.usesSystemConfiguration": (),
-# class PySide2.QtNetwork.QNetworkProxyQuery:
-# class PySide2.QtNetwork.QNetworkProxyQuery.QueryType:
-    "PySide2.QtNetwork.QNetworkProxyQuery.__init__": [(), ('PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QUrl', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkConfiguration', 'str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('PySide2.QtNetwork.QNetworkProxyQuery',), ('int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType'), ('str', 'int', 'str', 'PySide2.QtNetwork.QNetworkProxyQuery.QueryType')],
-    "PySide2.QtNetwork.QNetworkProxyQuery.__copy__": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.localPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.networkConfiguration": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerHostName": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.peerPort": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.protocolTag": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.queryType": (),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setLocalPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setNetworkConfiguration": ('PySide2.QtNetwork.QNetworkConfiguration',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerHostName": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setPeerPort": ('int',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setProtocolTag": ('str',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setQueryType": ('PySide2.QtNetwork.QNetworkProxyQuery.QueryType',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.swap": ('PySide2.QtNetwork.QNetworkProxyQuery',),
-    "PySide2.QtNetwork.QNetworkProxyQuery.url": (),
-# class PySide2.QtNetwork.QNetworkReply:
-# class PySide2.QtNetwork.QNetworkReply.NetworkError:
-    "PySide2.QtNetwork.QNetworkReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkReply.abort": (),
-    "PySide2.QtNetwork.QNetworkReply.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute',),
-    "PySide2.QtNetwork.QNetworkReply.close": (),
-    "PySide2.QtNetwork.QNetworkReply.error": (),
-    "PySide2.QtNetwork.QNetworkReply.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QNetworkReply.ignoreSslErrorsImplementation": ('typing.Sequence[PySide2.QtNetwork.QSslError]',),
-    "PySide2.QtNetwork.QNetworkReply.isFinished": (),
-    "PySide2.QtNetwork.QNetworkReply.isRunning": (),
-    "PySide2.QtNetwork.QNetworkReply.isSequential": (),
-    "PySide2.QtNetwork.QNetworkReply.manager": (),
-    "PySide2.QtNetwork.QNetworkReply.operation": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkReply.rawHeaderPairs": (),
-    "PySide2.QtNetwork.QNetworkReply.readBufferSize": (),
-    "PySide2.QtNetwork.QNetworkReply.request": (),
-    "PySide2.QtNetwork.QNetworkReply.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setError": ('PySide2.QtNetwork.QNetworkReply.NetworkError', 'str'),
-    "PySide2.QtNetwork.QNetworkReply.setFinished": ('bool',),
-    "PySide2.QtNetwork.QNetworkReply.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkReply.setOperation": ('PySide2.QtNetwork.QNetworkAccessManager.Operation',),
-    "PySide2.QtNetwork.QNetworkReply.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkReply.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QNetworkReply.setRequest": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setSslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkReply.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkReply.sslConfigurationImplementation": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkReply.url": (),
-    "PySide2.QtNetwork.QNetworkReply.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QNetworkRequest:
-# class PySide2.QtNetwork.QNetworkRequest.Attribute:
-# class PySide2.QtNetwork.QNetworkRequest.CacheLoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.KnownHeaders:
-# class PySide2.QtNetwork.QNetworkRequest.LoadControl:
-# class PySide2.QtNetwork.QNetworkRequest.Priority:
-# class PySide2.QtNetwork.QNetworkRequest.RedirectPolicy:
-    "PySide2.QtNetwork.QNetworkRequest.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtNetwork.QNetworkRequest.__copy__": (),
-    "PySide2.QtNetwork.QNetworkRequest.attribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.hasRawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.header": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders',),
-    "PySide2.QtNetwork.QNetworkRequest.maximumRedirectsAllowed": (),
-    "PySide2.QtNetwork.QNetworkRequest.originatingObject": (),
-    "PySide2.QtNetwork.QNetworkRequest.peerVerifyName": (),
-    "PySide2.QtNetwork.QNetworkRequest.priority": (),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QNetworkRequest.rawHeaderList": (),
-    "PySide2.QtNetwork.QNetworkRequest.setAttribute": ('PySide2.QtNetwork.QNetworkRequest.Attribute', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setHeader": ('PySide2.QtNetwork.QNetworkRequest.KnownHeaders', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkRequest.setMaximumRedirectsAllowed": ('int',),
-    "PySide2.QtNetwork.QNetworkRequest.setOriginatingObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QNetworkRequest.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QNetworkRequest.setPriority": ('PySide2.QtNetwork.QNetworkRequest.Priority',),
-    "PySide2.QtNetwork.QNetworkRequest.setRawHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QNetworkRequest.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QNetworkRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtNetwork.QNetworkRequest.sslConfiguration": (),
-    "PySide2.QtNetwork.QNetworkRequest.swap": ('PySide2.QtNetwork.QNetworkRequest',),
-    "PySide2.QtNetwork.QNetworkRequest.url": (),
-# class PySide2.QtNetwork.QNetworkSession:
-# class PySide2.QtNetwork.QNetworkSession.SessionError:
-# class PySide2.QtNetwork.QNetworkSession.State:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicies:
-# class PySide2.QtNetwork.QNetworkSession.UsagePolicy:
-    "PySide2.QtNetwork.QNetworkSession.__init__": ('PySide2.QtNetwork.QNetworkConfiguration', 'PySide2.QtCore.QObject'),
-    "PySide2.QtNetwork.QNetworkSession.accept": (),
-    "PySide2.QtNetwork.QNetworkSession.activeTime": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesReceived": (),
-    "PySide2.QtNetwork.QNetworkSession.bytesWritten": (),
-    "PySide2.QtNetwork.QNetworkSession.close": (),
-    "PySide2.QtNetwork.QNetworkSession.configuration": (),
-    "PySide2.QtNetwork.QNetworkSession.connectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.disconnectNotify": ('PySide2.QtCore.QMetaMethod',),
-    "PySide2.QtNetwork.QNetworkSession.error": (),
-    "PySide2.QtNetwork.QNetworkSession.errorString": (),
-    "PySide2.QtNetwork.QNetworkSession.ignore": (),
-    "PySide2.QtNetwork.QNetworkSession.interface": (),
-    "PySide2.QtNetwork.QNetworkSession.isOpen": (),
-    "PySide2.QtNetwork.QNetworkSession.migrate": (),
-    "PySide2.QtNetwork.QNetworkSession.open": (),
-    "PySide2.QtNetwork.QNetworkSession.reject": (),
-    "PySide2.QtNetwork.QNetworkSession.sessionProperty": ('str',),
-    "PySide2.QtNetwork.QNetworkSession.setSessionProperty": ('str', 'typing.Any'),
-    "PySide2.QtNetwork.QNetworkSession.state": (),
-    "PySide2.QtNetwork.QNetworkSession.stop": (),
-    "PySide2.QtNetwork.QNetworkSession.usagePolicies": (),
-    "PySide2.QtNetwork.QNetworkSession.waitForOpened": ('int',),
-# class PySide2.QtNetwork.QOcspCertificateStatus:
-# class PySide2.QtNetwork.QOcspResponse:
-    "PySide2.QtNetwork.QOcspResponse.__init__": [(), ('PySide2.QtNetwork.QOcspResponse',)],
-    "PySide2.QtNetwork.QOcspResponse.__copy__": (),
-    "PySide2.QtNetwork.QOcspResponse.certificateStatus": (),
-    "PySide2.QtNetwork.QOcspResponse.revocationReason": (),
-    "PySide2.QtNetwork.QOcspResponse.subject": (),
-    "PySide2.QtNetwork.QOcspResponse.swap": ('PySide2.QtNetwork.QOcspResponse',),
-# class PySide2.QtNetwork.QOcspRevocationReason:
-# class PySide2.QtNetwork.QPasswordDigestor:
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf1": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-    "PySide2.QtNetwork.QPasswordDigestor.deriveKeyPbkdf2": ('PySide2.QtCore.QCryptographicHash.Algorithm', 'PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'int', 'int'),
-# class PySide2.QtNetwork.QSsl:
-# class PySide2.QtNetwork.QSsl.AlternativeNameEntryType:
-# class PySide2.QtNetwork.QSsl.EncodingFormat:
-# class PySide2.QtNetwork.QSsl.KeyAlgorithm:
-# class PySide2.QtNetwork.QSsl.KeyType:
-# class PySide2.QtNetwork.QSsl.SslOption:
-# class PySide2.QtNetwork.QSsl.SslOptions:
-# class PySide2.QtNetwork.QSsl.SslProtocol:
-# class PySide2.QtNetwork.QSslCertificate:
-# class PySide2.QtNetwork.QSslCertificate.SubjectInfo:
-    "PySide2.QtNetwork.QSslCertificate.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtNetwork.QSslCertificate',)],
-    "PySide2.QtNetwork.QSslCertificate.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificate.clear": (),
-    "PySide2.QtNetwork.QSslCertificate.digest": ('PySide2.QtCore.QCryptographicHash.Algorithm',),
-    "PySide2.QtNetwork.QSslCertificate.effectiveDate": (),
-    "PySide2.QtNetwork.QSslCertificate.expiryDate": (),
-    "PySide2.QtNetwork.QSslCertificate.extensions": (),
-    "PySide2.QtNetwork.QSslCertificate.fromData": ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromDevice": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat'),
-    "PySide2.QtNetwork.QSslCertificate.fromPath": ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'),
-    "PySide2.QtNetwork.QSslCertificate.handle": (),
-    "PySide2.QtNetwork.QSslCertificate.importPkcs12": ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSslKey', 'PySide2.QtNetwork.QSslCertificate', 'typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtNetwork.QSslCertificate.isBlacklisted": (),
-    "PySide2.QtNetwork.QSslCertificate.isNull": (),
-    "PySide2.QtNetwork.QSslCertificate.isSelfSigned": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.issuerInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.issuerInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.publicKey": (),
-    "PySide2.QtNetwork.QSslCertificate.serialNumber": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectAlternativeNames": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectDisplayName": (),
-    "PySide2.QtNetwork.QSslCertificate.subjectInfo": [('PySide2.QtCore.QByteArray',), ('PySide2.QtNetwork.QSslCertificate.SubjectInfo',)],
-    "PySide2.QtNetwork.QSslCertificate.subjectInfoAttributes": (),
-    "PySide2.QtNetwork.QSslCertificate.swap": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslCertificate.toDer": (),
-    "PySide2.QtNetwork.QSslCertificate.toPem": (),
-    "PySide2.QtNetwork.QSslCertificate.toText": (),
-    "PySide2.QtNetwork.QSslCertificate.verify": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]', 'str'),
-    "PySide2.QtNetwork.QSslCertificate.version": (),
-# class PySide2.QtNetwork.QSslCertificateExtension:
-    "PySide2.QtNetwork.QSslCertificateExtension.__init__": [(), ('PySide2.QtNetwork.QSslCertificateExtension',)],
-    "PySide2.QtNetwork.QSslCertificateExtension.__copy__": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isCritical": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.isSupported": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.name": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.oid": (),
-    "PySide2.QtNetwork.QSslCertificateExtension.swap": ('PySide2.QtNetwork.QSslCertificateExtension',),
-    "PySide2.QtNetwork.QSslCertificateExtension.value": (),
-# class PySide2.QtNetwork.QSslCipher:
-    "PySide2.QtNetwork.QSslCipher.__init__": [(), ('PySide2.QtNetwork.QSslCipher',), ('str',), ('str', 'PySide2.QtNetwork.QSsl.SslProtocol')],
-    "PySide2.QtNetwork.QSslCipher.__copy__": (),
-    "PySide2.QtNetwork.QSslCipher.authenticationMethod": (),
-    "PySide2.QtNetwork.QSslCipher.encryptionMethod": (),
-    "PySide2.QtNetwork.QSslCipher.isNull": (),
-    "PySide2.QtNetwork.QSslCipher.keyExchangeMethod": (),
-    "PySide2.QtNetwork.QSslCipher.name": (),
-    "PySide2.QtNetwork.QSslCipher.protocol": (),
-    "PySide2.QtNetwork.QSslCipher.protocolString": (),
-    "PySide2.QtNetwork.QSslCipher.supportedBits": (),
-    "PySide2.QtNetwork.QSslCipher.swap": ('PySide2.QtNetwork.QSslCipher',),
-    "PySide2.QtNetwork.QSslCipher.usedBits": (),
-# class PySide2.QtNetwork.QSslConfiguration:
-# class PySide2.QtNetwork.QSslConfiguration.NextProtocolNegotiationStatus:
-    "PySide2.QtNetwork.QSslConfiguration.__init__": [(), ('PySide2.QtNetwork.QSslConfiguration',)],
-    "PySide2.QtNetwork.QSslConfiguration.__copy__": (),
-    "PySide2.QtNetwork.QSslConfiguration.allowedNextProtocols": (),
-    "PySide2.QtNetwork.QSslConfiguration.backendConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.caCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.ciphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.defaultDtlsConfiguration": (),
-    "PySide2.QtNetwork.QSslConfiguration.diffieHellmanParameters": (),
-    "PySide2.QtNetwork.QSslConfiguration.dtlsCookieVerificationEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.ephemeralServerKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.isNull": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextNegotiatedProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.nextProtocolNegotiationStatus": (),
-    "PySide2.QtNetwork.QSslConfiguration.ocspStaplingEnabled": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificate": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslConfiguration.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslConfiguration.preSharedKeyIdentityHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.privateKey": (),
-    "PySide2.QtNetwork.QSslConfiguration.protocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionCipher": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicket": (),
-    "PySide2.QtNetwork.QSslConfiguration.sessionTicketLifeTimeHint": (),
-    "PySide2.QtNetwork.QSslConfiguration.setAllowedNextProtocols": ('typing.Sequence[PySide2.QtCore.QByteArray]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfiguration": ('typing.Dict[PySide2.QtCore.QByteArray, typing.Any]',),
-    "PySide2.QtNetwork.QSslConfiguration.setBackendConfigurationOption": ('PySide2.QtCore.QByteArray', 'typing.Any'),
-    "PySide2.QtNetwork.QSslConfiguration.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDefaultDtlsConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.setDiffieHellmanParameters": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-    "PySide2.QtNetwork.QSslConfiguration.setDtlsCookieVerificationEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslConfiguration.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslConfiguration.setOcspStaplingEnabled": ('bool',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslConfiguration.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslConfiguration.setPreSharedKeyIdentityHint": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setPrivateKey": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslConfiguration.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslConfiguration.setSessionTicket": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslConfiguration.setSslOption": ('PySide2.QtNetwork.QSsl.SslOption', 'bool'),
-    "PySide2.QtNetwork.QSslConfiguration.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslConfiguration.swap": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslConfiguration.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslConfiguration.testSslOption": ('PySide2.QtNetwork.QSsl.SslOption',),
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters:
-# class PySide2.QtNetwork.QSslDiffieHellmanParameters.Error:
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__init__": [(), ('PySide2.QtNetwork.QSslDiffieHellmanParameters',)],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.__copy__": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.defaultParameters": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.error": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.errorString": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.fromEncoded": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.EncodingFormat'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isEmpty": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.isValid": (),
-    "PySide2.QtNetwork.QSslDiffieHellmanParameters.swap": ('PySide2.QtNetwork.QSslDiffieHellmanParameters',),
-# class PySide2.QtNetwork.QSslError:
-# class PySide2.QtNetwork.QSslError.SslError:
-    "PySide2.QtNetwork.QSslError.__init__": [(), ('PySide2.QtNetwork.QSslError',), ('PySide2.QtNetwork.QSslError.SslError',), ('PySide2.QtNetwork.QSslError.SslError', 'PySide2.QtNetwork.QSslCertificate')],
-    "PySide2.QtNetwork.QSslError.__copy__": (),
-    "PySide2.QtNetwork.QSslError.certificate": (),
-    "PySide2.QtNetwork.QSslError.error": (),
-    "PySide2.QtNetwork.QSslError.errorString": (),
-    "PySide2.QtNetwork.QSslError.swap": ('PySide2.QtNetwork.QSslError',),
-# class PySide2.QtNetwork.QSslKey:
-    "PySide2.QtNetwork.QSslKey.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtCore.QIODevice', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtNetwork.QSsl.KeyType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtNetwork.QSslKey',), ('int', 'PySide2.QtNetwork.QSsl.KeyType')],
-    "PySide2.QtNetwork.QSslKey.__copy__": (),
-    "PySide2.QtNetwork.QSslKey.algorithm": (),
-    "PySide2.QtNetwork.QSslKey.clear": (),
-    "PySide2.QtNetwork.QSslKey.handle": (),
-    "PySide2.QtNetwork.QSslKey.isNull": (),
-    "PySide2.QtNetwork.QSslKey.length": (),
-    "PySide2.QtNetwork.QSslKey.swap": ('PySide2.QtNetwork.QSslKey',),
-    "PySide2.QtNetwork.QSslKey.toDer": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.toPem": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslKey.type": (),
-# class PySide2.QtNetwork.QSslPreSharedKeyAuthenticator:
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__init__": [(), ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',)],
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.__copy__": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identity": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.identityHint": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumIdentityLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.maximumPreSharedKeyLength": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.preSharedKey": (),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setIdentity": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.setPreSharedKey": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtNetwork.QSslPreSharedKeyAuthenticator.swap": ('PySide2.QtNetwork.QSslPreSharedKeyAuthenticator',),
-# class PySide2.QtNetwork.QSslSocket:
-# class PySide2.QtNetwork.QSslSocket.PeerVerifyMode:
-# class PySide2.QtNetwork.QSslSocket.SslMode:
-    "PySide2.QtNetwork.QSslSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QSslSocket.abort": (),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificate": ('PySide2.QtNetwork.QSslCertificate',),
-    "PySide2.QtNetwork.QSslSocket.addDefaultCaCertificates": [('str', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QRegExp.PatternSyntax'), ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',)],
-    "PySide2.QtNetwork.QSslSocket.atEnd": (),
-    "PySide2.QtNetwork.QSslSocket.bytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.bytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.caCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.canReadLine": (),
-    "PySide2.QtNetwork.QSslSocket.ciphers": (),
-    "PySide2.QtNetwork.QSslSocket.close": (),
-    "PySide2.QtNetwork.QSslSocket.connectToHost": [('PySide2.QtNetwork.QHostAddress', 'int', 'PySide2.QtCore.QIODevice.OpenMode'), ('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.connectToHostEncrypted": [('str', 'int', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol'), ('str', 'int', 'str', 'PySide2.QtCore.QIODevice.OpenMode', 'PySide2.QtNetwork.QAbstractSocket.NetworkLayerProtocol')],
-    "PySide2.QtNetwork.QSslSocket.defaultCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.defaultCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.disconnectFromHost": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesAvailable": (),
-    "PySide2.QtNetwork.QSslSocket.encryptedBytesToWrite": (),
-    "PySide2.QtNetwork.QSslSocket.flush": (),
-    "PySide2.QtNetwork.QSslSocket.ignoreSslErrors": [(), ('typing.Sequence[PySide2.QtNetwork.QSslError]',)],
-    "PySide2.QtNetwork.QSslSocket.isEncrypted": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.localCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.mode": (),
-    "PySide2.QtNetwork.QSslSocket.ocspResponses": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificate": (),
-    "PySide2.QtNetwork.QSslSocket.peerCertificateChain": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyDepth": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyMode": (),
-    "PySide2.QtNetwork.QSslSocket.peerVerifyName": (),
-    "PySide2.QtNetwork.QSslSocket.privateKey": (),
-    "PySide2.QtNetwork.QSslSocket.protocol": (),
-    "PySide2.QtNetwork.QSslSocket.readData": ('str', 'int'),
-    "PySide2.QtNetwork.QSslSocket.resume": (),
-    "PySide2.QtNetwork.QSslSocket.sessionCipher": (),
-    "PySide2.QtNetwork.QSslSocket.sessionProtocol": (),
-    "PySide2.QtNetwork.QSslSocket.setCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setCiphers": [('str',), ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',)],
-    "PySide2.QtNetwork.QSslSocket.setDefaultCaCertificates": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setDefaultCiphers": ('typing.Sequence[PySide2.QtNetwork.QSslCipher]',),
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificate": [('PySide2.QtNetwork.QSslCertificate',), ('str', 'PySide2.QtNetwork.QSsl.EncodingFormat')],
-    "PySide2.QtNetwork.QSslSocket.setLocalCertificateChain": ('typing.Sequence[PySide2.QtNetwork.QSslCertificate]',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyDepth": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyMode": ('PySide2.QtNetwork.QSslSocket.PeerVerifyMode',),
-    "PySide2.QtNetwork.QSslSocket.setPeerVerifyName": ('str',),
-    "PySide2.QtNetwork.QSslSocket.setPrivateKey": [('PySide2.QtNetwork.QSslKey',), ('str', 'PySide2.QtNetwork.QSsl.KeyAlgorithm', 'PySide2.QtNetwork.QSsl.EncodingFormat', 'PySide2.QtCore.QByteArray')],
-    "PySide2.QtNetwork.QSslSocket.setProtocol": ('PySide2.QtNetwork.QSsl.SslProtocol',),
-    "PySide2.QtNetwork.QSslSocket.setReadBufferSize": ('int',),
-    "PySide2.QtNetwork.QSslSocket.setSocketDescriptor": ('int', 'PySide2.QtNetwork.QAbstractSocket.SocketState', 'PySide2.QtCore.QIODevice.OpenMode'),
-    "PySide2.QtNetwork.QSslSocket.setSocketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption', 'typing.Any'),
-    "PySide2.QtNetwork.QSslSocket.setSslConfiguration": ('PySide2.QtNetwork.QSslConfiguration',),
-    "PySide2.QtNetwork.QSslSocket.socketOption": ('PySide2.QtNetwork.QAbstractSocket.SocketOption',),
-    "PySide2.QtNetwork.QSslSocket.sslConfiguration": (),
-    "PySide2.QtNetwork.QSslSocket.sslErrors": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryBuildVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionNumber": (),
-    "PySide2.QtNetwork.QSslSocket.sslLibraryVersionString": (),
-    "PySide2.QtNetwork.QSslSocket.startClientEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.startServerEncryption": (),
-    "PySide2.QtNetwork.QSslSocket.supportedCiphers": (),
-    "PySide2.QtNetwork.QSslSocket.supportsSsl": (),
-    "PySide2.QtNetwork.QSslSocket.systemCaCertificates": (),
-    "PySide2.QtNetwork.QSslSocket.waitForBytesWritten": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForConnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForDisconnected": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForEncrypted": ('int',),
-    "PySide2.QtNetwork.QSslSocket.waitForReadyRead": ('int',),
-    "PySide2.QtNetwork.QSslSocket.writeData": ('str', 'int'),
-# class PySide2.QtNetwork.QTcpServer:
-    "PySide2.QtNetwork.QTcpServer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QTcpServer.addPendingConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtNetwork.QTcpServer.close": (),
-    "PySide2.QtNetwork.QTcpServer.errorString": (),
-    "PySide2.QtNetwork.QTcpServer.hasPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.incomingConnection": ('int',),
-    "PySide2.QtNetwork.QTcpServer.isListening": (),
-    "PySide2.QtNetwork.QTcpServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtNetwork.QTcpServer.maxPendingConnections": (),
-    "PySide2.QtNetwork.QTcpServer.nextPendingConnection": (),
-    "PySide2.QtNetwork.QTcpServer.pauseAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.proxy": (),
-    "PySide2.QtNetwork.QTcpServer.resumeAccepting": (),
-    "PySide2.QtNetwork.QTcpServer.serverAddress": (),
-    "PySide2.QtNetwork.QTcpServer.serverError": (),
-    "PySide2.QtNetwork.QTcpServer.serverPort": (),
-    "PySide2.QtNetwork.QTcpServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtNetwork.QTcpServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtNetwork.QTcpServer.setSocketDescriptor": ('int',),
-    "PySide2.QtNetwork.QTcpServer.socketDescriptor": (),
-    "PySide2.QtNetwork.QTcpServer.waitForNewConnection": ('int',),
-# class PySide2.QtNetwork.QTcpSocket:
-    "PySide2.QtNetwork.QTcpSocket.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtNetwork.QUdpSocket:
-    "PySide2.QtNetwork.QUdpSocket.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtNetwork.QUdpSocket.hasPendingDatagrams": (),
-    "PySide2.QtNetwork.QUdpSocket.joinMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.leaveMulticastGroup": [('PySide2.QtNetwork.QHostAddress',), ('PySide2.QtNetwork.QHostAddress', 'PySide2.QtNetwork.QNetworkInterface')],
-    "PySide2.QtNetwork.QUdpSocket.multicastInterface": (),
-    "PySide2.QtNetwork.QUdpSocket.pendingDatagramSize": (),
-    "PySide2.QtNetwork.QUdpSocket.readDatagram": ('str', 'int', 'PySide2.QtNetwork.QHostAddress'),
-    "PySide2.QtNetwork.QUdpSocket.receiveDatagram": ('int',),
-    "PySide2.QtNetwork.QUdpSocket.setMulticastInterface": ('PySide2.QtNetwork.QNetworkInterface',),
-    "PySide2.QtNetwork.QUdpSocket.writeDatagram": [('PySide2.QtCore.QByteArray', 'PySide2.QtNetwork.QHostAddress', 'int'), ('PySide2.QtNetwork.QNetworkDatagram',)],
-    }) if "PySide2.QtNetwork" in sys.modules else None
-# Module PySide2.QtTest
-sig_dict.update({
-# class PySide2.QtTest.QTest:
-# class PySide2.QtTest.QTest.KeyAction:
-# class PySide2.QtTest.QTest.MouseAction:
-# class PySide2.QtTest.QTest.QBenchmarkMetric:
-# class PySide2.QtTest.QTest.QTouchEventSequence:
-    "PySide2.QtTest.QTest.QTouchEventSequence.commit": ('bool',),
-    "PySide2.QtTest.QTest.QTouchEventSequence.move": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.press": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.release": [('int', 'PySide2.QtCore.QPoint', 'PySide2.QtGui.QWindow'), ('int', 'PySide2.QtCore.QPoint', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtTest.QTest.QTouchEventSequence.stationary": ('int',),
-# class PySide2.QtTest.QTest.TestFailMode:
-    "PySide2.QtTest.QTest.addColumnInternal": ('int', 'str'),
-    "PySide2.QtTest.QTest.asciiToKey": ('int',),
-    "PySide2.QtTest.QTest.compare_ptr_helper": ('int', 'int', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.compare_string_helper": ('str', 'str', 'str', 'str', 'str', 'int'),
-    "PySide2.QtTest.QTest.createTouchDevice": ('PySide2.QtGui.QTouchDevice.DeviceType',),
-    "PySide2.QtTest.QTest.currentAppName": (),
-    "PySide2.QtTest.QTest.currentDataTag": (),
-    "PySide2.QtTest.QTest.currentTestFailed": (),
-    "PySide2.QtTest.QTest.currentTestFunction": (),
-    "PySide2.QtTest.QTest.ignoreMessage": [('PySide2.QtCore.QtMsgType', 'PySide2.QtCore.QRegularExpression'), ('PySide2.QtCore.QtMsgType', 'str')],
-    "PySide2.QtTest.QTest.keyClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyClicks": ('PySide2.QtWidgets.QWidget', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'),
-    "PySide2.QtTest.QTest.keyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyPress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keyRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtGui.QWindow', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtWidgets.QWidget', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.keySequence": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QKeySequence'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QKeySequence')],
-    "PySide2.QtTest.QTest.keyToAscii": ('PySide2.QtCore.Qt.Key',),
-    "PySide2.QtTest.QTest.mouseClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseDClick": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseEvent": [('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtTest.QTest.MouseAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseMove": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mousePress": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.mouseRelease": [('PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.MouseButton', 'PySide2.QtCore.Qt.KeyboardModifiers', 'PySide2.QtCore.QPoint', 'int')],
-    "PySide2.QtTest.QTest.qCleanup": (),
-    "PySide2.QtTest.QTest.qElementData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qExpectFail": ('str', 'str', 'PySide2.QtTest.QTest.TestFailMode', 'str', 'int'),
-    "PySide2.QtTest.QTest.qFindTestData": ('str', 'str', 'int', 'str'),
-    "PySide2.QtTest.QTest.qGlobalData": ('str', 'int'),
-    "PySide2.QtTest.QTest.qRun": (),
-    "PySide2.QtTest.QTest.qSkip": ('str', 'str', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowActive": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.qWaitForWindowExposed": ('PySide2.QtWidgets.QWidget', 'int'),
-    "PySide2.QtTest.QTest.sendKeyEvent": [('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtGui.QWindow', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int'), ('PySide2.QtTest.QTest.KeyAction', 'PySide2.QtWidgets.QWidget', 'PySide2.QtCore.Qt.Key', 'str', 'PySide2.QtCore.Qt.KeyboardModifiers', 'int')],
-    "PySide2.QtTest.QTest.setBenchmarkResult": ('float', 'PySide2.QtTest.QTest.QBenchmarkMetric'),
-    "PySide2.QtTest.QTest.setMainSourcePath": ('str', 'str'),
-    "PySide2.QtTest.QTest.simulateEvent": [('PySide2.QtGui.QWindow', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'), ('PySide2.QtWidgets.QWidget', 'bool', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int')],
-    "PySide2.QtTest.QTest.testObject": (),
-    "PySide2.QtTest.QTest.toPrettyCString": ('str', 'int'),
-    "PySide2.QtTest.QTest.touchEvent": [('PySide2.QtGui.QWindow', 'PySide2.QtGui.QTouchDevice', 'bool'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtGui.QTouchDevice', 'bool')],
-    }) if "PySide2.QtTest" in sys.modules else None
-# Module PySide2.QtConcurrent
-sig_dict.update({
-# class PySide2.QtConcurrent.QtConcurrent:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOption:
-# class PySide2.QtConcurrent.QtConcurrent.ReduceOptions:
-# class PySide2.QtConcurrent.QtConcurrent.ThreadFunctionResult:
-    }) if "PySide2.QtConcurrent" in sys.modules else None
-# Module PySide2.QtX11Extras
-sig_dict.update({
-# class PySide2.QtX11Extras.QX11Info:
-# class PySide2.QtX11Extras.QX11Info.PeekOption:
-# class PySide2.QtX11Extras.QX11Info.PeekOptions:
-    "PySide2.QtX11Extras.QX11Info.appDpiX": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appDpiY": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appRootWindow": ('int',),
-    "PySide2.QtX11Extras.QX11Info.appScreen": (),
-    "PySide2.QtX11Extras.QX11Info.appTime": (),
-    "PySide2.QtX11Extras.QX11Info.appUserTime": (),
-    "PySide2.QtX11Extras.QX11Info.generatePeekerId": (),
-    "PySide2.QtX11Extras.QX11Info.getTimestamp": (),
-    "PySide2.QtX11Extras.QX11Info.isCompositingManagerRunning": ('int',),
-    "PySide2.QtX11Extras.QX11Info.isPlatformX11": (),
-    "PySide2.QtX11Extras.QX11Info.nextStartupId": (),
-    "PySide2.QtX11Extras.QX11Info.removePeekerId": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setAppTime": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setAppUserTime": ('int',),
-    "PySide2.QtX11Extras.QX11Info.setNextStartupId": ('PySide2.QtCore.QByteArray',),
-    }) if "PySide2.QtX11Extras" in sys.modules else None
-# Module PySide2.QtXml
-sig_dict.update({
-# class PySide2.QtXml.QDomAttr:
-    "PySide2.QtXml.QDomAttr.__init__": [(), ('PySide2.QtXml.QDomAttr',)],
-    "PySide2.QtXml.QDomAttr.__copy__": (),
-    "PySide2.QtXml.QDomAttr.name": (),
-    "PySide2.QtXml.QDomAttr.nodeType": (),
-    "PySide2.QtXml.QDomAttr.ownerElement": (),
-    "PySide2.QtXml.QDomAttr.setValue": ('str',),
-    "PySide2.QtXml.QDomAttr.specified": (),
-    "PySide2.QtXml.QDomAttr.value": (),
-# class PySide2.QtXml.QDomCDATASection:
-    "PySide2.QtXml.QDomCDATASection.__init__": [(), ('PySide2.QtXml.QDomCDATASection',)],
-    "PySide2.QtXml.QDomCDATASection.__copy__": (),
-    "PySide2.QtXml.QDomCDATASection.nodeType": (),
-# class PySide2.QtXml.QDomCharacterData:
-    "PySide2.QtXml.QDomCharacterData.__init__": [(), ('PySide2.QtXml.QDomCharacterData',)],
-    "PySide2.QtXml.QDomCharacterData.__copy__": (),
-    "PySide2.QtXml.QDomCharacterData.appendData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.data": (),
-    "PySide2.QtXml.QDomCharacterData.deleteData": ('int', 'int'),
-    "PySide2.QtXml.QDomCharacterData.insertData": ('int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.length": (),
-    "PySide2.QtXml.QDomCharacterData.nodeType": (),
-    "PySide2.QtXml.QDomCharacterData.replaceData": ('int', 'int', 'str'),
-    "PySide2.QtXml.QDomCharacterData.setData": ('str',),
-    "PySide2.QtXml.QDomCharacterData.substringData": ('int', 'int'),
-# class PySide2.QtXml.QDomComment:
-    "PySide2.QtXml.QDomComment.__init__": [(), ('PySide2.QtXml.QDomComment',)],
-    "PySide2.QtXml.QDomComment.__copy__": (),
-    "PySide2.QtXml.QDomComment.nodeType": (),
-# class PySide2.QtXml.QDomDocument:
-    "PySide2.QtXml.QDomDocument.__init__": [(), ('PySide2.QtXml.QDomDocument',), ('PySide2.QtXml.QDomDocumentType',), ('str',)],
-    "PySide2.QtXml.QDomDocument.__copy__": (),
-    "PySide2.QtXml.QDomDocument.createAttribute": ('str',),
-    "PySide2.QtXml.QDomDocument.createAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createCDATASection": ('str',),
-    "PySide2.QtXml.QDomDocument.createComment": ('str',),
-    "PySide2.QtXml.QDomDocument.createDocumentFragment": (),
-    "PySide2.QtXml.QDomDocument.createElement": ('str',),
-    "PySide2.QtXml.QDomDocument.createElementNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createEntityReference": ('str',),
-    "PySide2.QtXml.QDomDocument.createProcessingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.createTextNode": ('str',),
-    "PySide2.QtXml.QDomDocument.doctype": (),
-    "PySide2.QtXml.QDomDocument.documentElement": (),
-    "PySide2.QtXml.QDomDocument.elementById": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomDocument.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomDocument.implementation": (),
-    "PySide2.QtXml.QDomDocument.importNode": ('PySide2.QtXml.QDomNode', 'bool'),
-    "PySide2.QtXml.QDomDocument.nodeType": (),
-    "PySide2.QtXml.QDomDocument.setContent": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QByteArray', 'bool'), ('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QIODevice', 'bool'), ('PySide2.QtXml.QXmlInputSource', 'PySide2.QtXml.QXmlReader'), ('PySide2.QtXml.QXmlInputSource', 'bool'), ('str',), ('str', 'bool')],
-    "PySide2.QtXml.QDomDocument.toByteArray": ('int',),
-    "PySide2.QtXml.QDomDocument.toString": ('int',),
-# class PySide2.QtXml.QDomDocumentFragment:
-    "PySide2.QtXml.QDomDocumentFragment.__init__": [(), ('PySide2.QtXml.QDomDocumentFragment',)],
-    "PySide2.QtXml.QDomDocumentFragment.__copy__": (),
-    "PySide2.QtXml.QDomDocumentFragment.nodeType": (),
-# class PySide2.QtXml.QDomDocumentType:
-    "PySide2.QtXml.QDomDocumentType.__init__": [(), ('PySide2.QtXml.QDomDocumentType',)],
-    "PySide2.QtXml.QDomDocumentType.__copy__": (),
-    "PySide2.QtXml.QDomDocumentType.entities": (),
-    "PySide2.QtXml.QDomDocumentType.internalSubset": (),
-    "PySide2.QtXml.QDomDocumentType.name": (),
-    "PySide2.QtXml.QDomDocumentType.nodeType": (),
-    "PySide2.QtXml.QDomDocumentType.notations": (),
-    "PySide2.QtXml.QDomDocumentType.publicId": (),
-    "PySide2.QtXml.QDomDocumentType.systemId": (),
-# class PySide2.QtXml.QDomElement:
-    "PySide2.QtXml.QDomElement.__init__": [(), ('PySide2.QtXml.QDomElement',)],
-    "PySide2.QtXml.QDomElement.__copy__": (),
-    "PySide2.QtXml.QDomElement.attribute": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNS": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomElement.attributeNode": ('str',),
-    "PySide2.QtXml.QDomElement.attributeNodeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.attributes": (),
-    "PySide2.QtXml.QDomElement.elementsByTagName": ('str',),
-    "PySide2.QtXml.QDomElement.elementsByTagNameNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.hasAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.hasAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.nodeType": (),
-    "PySide2.QtXml.QDomElement.removeAttribute": ('str',),
-    "PySide2.QtXml.QDomElement.removeAttributeNS": ('str', 'str'),
-    "PySide2.QtXml.QDomElement.removeAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttribute": [('str', 'float'), ('str', 'int'), ('str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNS": [('str', 'str', 'float'), ('str', 'str', 'int'), ('str', 'str', 'str')],
-    "PySide2.QtXml.QDomElement.setAttributeNode": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setAttributeNodeNS": ('PySide2.QtXml.QDomAttr',),
-    "PySide2.QtXml.QDomElement.setTagName": ('str',),
-    "PySide2.QtXml.QDomElement.tagName": (),
-    "PySide2.QtXml.QDomElement.text": (),
-# class PySide2.QtXml.QDomEntity:
-    "PySide2.QtXml.QDomEntity.__init__": [(), ('PySide2.QtXml.QDomEntity',)],
-    "PySide2.QtXml.QDomEntity.__copy__": (),
-    "PySide2.QtXml.QDomEntity.nodeType": (),
-    "PySide2.QtXml.QDomEntity.notationName": (),
-    "PySide2.QtXml.QDomEntity.publicId": (),
-    "PySide2.QtXml.QDomEntity.systemId": (),
-# class PySide2.QtXml.QDomEntityReference:
-    "PySide2.QtXml.QDomEntityReference.__init__": [(), ('PySide2.QtXml.QDomEntityReference',)],
-    "PySide2.QtXml.QDomEntityReference.__copy__": (),
-    "PySide2.QtXml.QDomEntityReference.nodeType": (),
-# class PySide2.QtXml.QDomImplementation:
-# class PySide2.QtXml.QDomImplementation.InvalidDataPolicy:
-    "PySide2.QtXml.QDomImplementation.__init__": [(), ('PySide2.QtXml.QDomImplementation',)],
-    "PySide2.QtXml.QDomImplementation.__copy__": (),
-    "PySide2.QtXml.QDomImplementation.createDocument": ('str', 'str', 'PySide2.QtXml.QDomDocumentType'),
-    "PySide2.QtXml.QDomImplementation.createDocumentType": ('str', 'str', 'str'),
-    "PySide2.QtXml.QDomImplementation.hasFeature": ('str', 'str'),
-    "PySide2.QtXml.QDomImplementation.invalidDataPolicy": (),
-    "PySide2.QtXml.QDomImplementation.isNull": (),
-    "PySide2.QtXml.QDomImplementation.setInvalidDataPolicy": ('PySide2.QtXml.QDomImplementation.InvalidDataPolicy',),
-# class PySide2.QtXml.QDomNamedNodeMap:
-    "PySide2.QtXml.QDomNamedNodeMap.__init__": [(), ('PySide2.QtXml.QDomNamedNodeMap',)],
-    "PySide2.QtXml.QDomNamedNodeMap.__copy__": (),
-    "PySide2.QtXml.QDomNamedNodeMap.contains": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.count": (),
-    "PySide2.QtXml.QDomNamedNodeMap.isEmpty": (),
-    "PySide2.QtXml.QDomNamedNodeMap.item": ('int',),
-    "PySide2.QtXml.QDomNamedNodeMap.length": (),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.namedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItem": ('str',),
-    "PySide2.QtXml.QDomNamedNodeMap.removeNamedItemNS": ('str', 'str'),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItem": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.setNamedItemNS": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNamedNodeMap.size": (),
-# class PySide2.QtXml.QDomNode:
-# class PySide2.QtXml.QDomNode.EncodingPolicy:
-# class PySide2.QtXml.QDomNode.NodeType:
-    "PySide2.QtXml.QDomNode.__init__": [(), ('PySide2.QtXml.QDomNode',)],
-    "PySide2.QtXml.QDomNode.__copy__": (),
-    "PySide2.QtXml.QDomNode.__lshift__": ('PySide2.QtCore.QTextStream',),
-    "PySide2.QtXml.QDomNode.appendChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.attributes": (),
-    "PySide2.QtXml.QDomNode.childNodes": (),
-    "PySide2.QtXml.QDomNode.clear": (),
-    "PySide2.QtXml.QDomNode.cloneNode": ('bool',),
-    "PySide2.QtXml.QDomNode.columnNumber": (),
-    "PySide2.QtXml.QDomNode.firstChild": (),
-    "PySide2.QtXml.QDomNode.firstChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.hasAttributes": (),
-    "PySide2.QtXml.QDomNode.hasChildNodes": (),
-    "PySide2.QtXml.QDomNode.insertAfter": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.insertBefore": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.isAttr": (),
-    "PySide2.QtXml.QDomNode.isCDATASection": (),
-    "PySide2.QtXml.QDomNode.isCharacterData": (),
-    "PySide2.QtXml.QDomNode.isComment": (),
-    "PySide2.QtXml.QDomNode.isDocument": (),
-    "PySide2.QtXml.QDomNode.isDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.isDocumentType": (),
-    "PySide2.QtXml.QDomNode.isElement": (),
-    "PySide2.QtXml.QDomNode.isEntity": (),
-    "PySide2.QtXml.QDomNode.isEntityReference": (),
-    "PySide2.QtXml.QDomNode.isNotation": (),
-    "PySide2.QtXml.QDomNode.isNull": (),
-    "PySide2.QtXml.QDomNode.isProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.isSupported": ('str', 'str'),
-    "PySide2.QtXml.QDomNode.isText": (),
-    "PySide2.QtXml.QDomNode.lastChild": (),
-    "PySide2.QtXml.QDomNode.lastChildElement": ('str',),
-    "PySide2.QtXml.QDomNode.lineNumber": (),
-    "PySide2.QtXml.QDomNode.localName": (),
-    "PySide2.QtXml.QDomNode.namedItem": ('str',),
-    "PySide2.QtXml.QDomNode.namespaceURI": (),
-    "PySide2.QtXml.QDomNode.nextSibling": (),
-    "PySide2.QtXml.QDomNode.nextSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.nodeName": (),
-    "PySide2.QtXml.QDomNode.nodeType": (),
-    "PySide2.QtXml.QDomNode.nodeValue": (),
-    "PySide2.QtXml.QDomNode.normalize": (),
-    "PySide2.QtXml.QDomNode.ownerDocument": (),
-    "PySide2.QtXml.QDomNode.parentNode": (),
-    "PySide2.QtXml.QDomNode.prefix": (),
-    "PySide2.QtXml.QDomNode.previousSibling": (),
-    "PySide2.QtXml.QDomNode.previousSiblingElement": ('str',),
-    "PySide2.QtXml.QDomNode.removeChild": ('PySide2.QtXml.QDomNode',),
-    "PySide2.QtXml.QDomNode.replaceChild": ('PySide2.QtXml.QDomNode', 'PySide2.QtXml.QDomNode'),
-    "PySide2.QtXml.QDomNode.save": ('PySide2.QtCore.QTextStream', 'int', 'PySide2.QtXml.QDomNode.EncodingPolicy'),
-    "PySide2.QtXml.QDomNode.setNodeValue": ('str',),
-    "PySide2.QtXml.QDomNode.setPrefix": ('str',),
-    "PySide2.QtXml.QDomNode.toAttr": (),
-    "PySide2.QtXml.QDomNode.toCDATASection": (),
-    "PySide2.QtXml.QDomNode.toCharacterData": (),
-    "PySide2.QtXml.QDomNode.toComment": (),
-    "PySide2.QtXml.QDomNode.toDocument": (),
-    "PySide2.QtXml.QDomNode.toDocumentFragment": (),
-    "PySide2.QtXml.QDomNode.toDocumentType": (),
-    "PySide2.QtXml.QDomNode.toElement": (),
-    "PySide2.QtXml.QDomNode.toEntity": (),
-    "PySide2.QtXml.QDomNode.toEntityReference": (),
-    "PySide2.QtXml.QDomNode.toNotation": (),
-    "PySide2.QtXml.QDomNode.toProcessingInstruction": (),
-    "PySide2.QtXml.QDomNode.toText": (),
-# class PySide2.QtXml.QDomNodeList:
-    "PySide2.QtXml.QDomNodeList.__init__": [(), ('PySide2.QtXml.QDomNodeList',)],
-    "PySide2.QtXml.QDomNodeList.__copy__": (),
-    "PySide2.QtXml.QDomNodeList.at": ('int',),
-    "PySide2.QtXml.QDomNodeList.count": (),
-    "PySide2.QtXml.QDomNodeList.isEmpty": (),
-    "PySide2.QtXml.QDomNodeList.item": ('int',),
-    "PySide2.QtXml.QDomNodeList.length": (),
-    "PySide2.QtXml.QDomNodeList.size": (),
-# class PySide2.QtXml.QDomNotation:
-    "PySide2.QtXml.QDomNotation.__init__": [(), ('PySide2.QtXml.QDomNotation',)],
-    "PySide2.QtXml.QDomNotation.__copy__": (),
-    "PySide2.QtXml.QDomNotation.nodeType": (),
-    "PySide2.QtXml.QDomNotation.publicId": (),
-    "PySide2.QtXml.QDomNotation.systemId": (),
-# class PySide2.QtXml.QDomProcessingInstruction:
-    "PySide2.QtXml.QDomProcessingInstruction.__init__": [(), ('PySide2.QtXml.QDomProcessingInstruction',)],
-    "PySide2.QtXml.QDomProcessingInstruction.__copy__": (),
-    "PySide2.QtXml.QDomProcessingInstruction.data": (),
-    "PySide2.QtXml.QDomProcessingInstruction.nodeType": (),
-    "PySide2.QtXml.QDomProcessingInstruction.setData": ('str',),
-    "PySide2.QtXml.QDomProcessingInstruction.target": (),
-# class PySide2.QtXml.QDomText:
-    "PySide2.QtXml.QDomText.__init__": [(), ('PySide2.QtXml.QDomText',)],
-    "PySide2.QtXml.QDomText.__copy__": (),
-    "PySide2.QtXml.QDomText.nodeType": (),
-    "PySide2.QtXml.QDomText.splitText": ('int',),
-# class PySide2.QtXml.QXmlAttributes:
-    "PySide2.QtXml.QXmlAttributes.__init__": [(), ('PySide2.QtXml.QXmlAttributes',)],
-    "PySide2.QtXml.QXmlAttributes.__copy__": (),
-    "PySide2.QtXml.QXmlAttributes.append": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlAttributes.clear": (),
-    "PySide2.QtXml.QXmlAttributes.count": (),
-    "PySide2.QtXml.QXmlAttributes.index": [('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.length": (),
-    "PySide2.QtXml.QXmlAttributes.localName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.qName": ('int',),
-    "PySide2.QtXml.QXmlAttributes.swap": ('PySide2.QtXml.QXmlAttributes',),
-    "PySide2.QtXml.QXmlAttributes.type": [('int',), ('str',), ('str', 'str')],
-    "PySide2.QtXml.QXmlAttributes.uri": ('int',),
-    "PySide2.QtXml.QXmlAttributes.value": [('int',), ('str',), ('str', 'str')],
-# class PySide2.QtXml.QXmlContentHandler:
-    "PySide2.QtXml.QXmlContentHandler.__init__": (),
-    "PySide2.QtXml.QXmlContentHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.endDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.errorString": (),
-    "PySide2.QtXml.QXmlContentHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlContentHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlContentHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlContentHandler.startDocument": (),
-    "PySide2.QtXml.QXmlContentHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlContentHandler.startPrefixMapping": ('str', 'str'),
-# class PySide2.QtXml.QXmlDTDHandler:
-    "PySide2.QtXml.QXmlDTDHandler.__init__": (),
-    "PySide2.QtXml.QXmlDTDHandler.errorString": (),
-    "PySide2.QtXml.QXmlDTDHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDTDHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-# class PySide2.QtXml.QXmlDeclHandler:
-    "PySide2.QtXml.QXmlDeclHandler.__init__": (),
-    "PySide2.QtXml.QXmlDeclHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.errorString": (),
-    "PySide2.QtXml.QXmlDeclHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDeclHandler.internalEntityDecl": ('str', 'str'),
-# class PySide2.QtXml.QXmlDefaultHandler:
-    "PySide2.QtXml.QXmlDefaultHandler.__init__": (),
-    "PySide2.QtXml.QXmlDefaultHandler.attributeDecl": ('str', 'str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.characters": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDTD": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.endElement": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.endPrefixMapping": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.errorString": (),
-    "PySide2.QtXml.QXmlDefaultHandler.externalEntityDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlDefaultHandler.ignorableWhitespace": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.internalEntityDecl": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.notationDecl": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.processingInstruction": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-    "PySide2.QtXml.QXmlDefaultHandler.setDocumentLocator": ('PySide2.QtXml.QXmlLocator',),
-    "PySide2.QtXml.QXmlDefaultHandler.skippedEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.startDocument": (),
-    "PySide2.QtXml.QXmlDefaultHandler.startElement": ('str', 'str', 'str', 'PySide2.QtXml.QXmlAttributes'),
-    "PySide2.QtXml.QXmlDefaultHandler.startEntity": ('str',),
-    "PySide2.QtXml.QXmlDefaultHandler.startPrefixMapping": ('str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.unparsedEntityDecl": ('str', 'str', 'str', 'str'),
-    "PySide2.QtXml.QXmlDefaultHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlEntityResolver:
-    "PySide2.QtXml.QXmlEntityResolver.__init__": (),
-    "PySide2.QtXml.QXmlEntityResolver.errorString": (),
-    "PySide2.QtXml.QXmlEntityResolver.resolveEntity": ('str', 'str', 'PySide2.QtXml.QXmlInputSource'),
-# class PySide2.QtXml.QXmlErrorHandler:
-    "PySide2.QtXml.QXmlErrorHandler.__init__": (),
-    "PySide2.QtXml.QXmlErrorHandler.error": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.errorString": (),
-    "PySide2.QtXml.QXmlErrorHandler.fatalError": ('PySide2.QtXml.QXmlParseException',),
-    "PySide2.QtXml.QXmlErrorHandler.warning": ('PySide2.QtXml.QXmlParseException',),
-# class PySide2.QtXml.QXmlInputSource:
-    "PySide2.QtXml.QXmlInputSource.__init__": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtXml.QXmlInputSource.data": (),
-    "PySide2.QtXml.QXmlInputSource.fetchData": (),
-    "PySide2.QtXml.QXmlInputSource.fromRawData": ('PySide2.QtCore.QByteArray', 'bool'),
-    "PySide2.QtXml.QXmlInputSource.reset": (),
-    "PySide2.QtXml.QXmlInputSource.setData": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtXml.QXmlLexicalHandler:
-    "PySide2.QtXml.QXmlLexicalHandler.__init__": (),
-    "PySide2.QtXml.QXmlLexicalHandler.comment": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.endCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endDTD": (),
-    "PySide2.QtXml.QXmlLexicalHandler.endEntity": ('str',),
-    "PySide2.QtXml.QXmlLexicalHandler.errorString": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startCDATA": (),
-    "PySide2.QtXml.QXmlLexicalHandler.startDTD": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlLexicalHandler.startEntity": ('str',),
-# class PySide2.QtXml.QXmlLocator:
-    "PySide2.QtXml.QXmlLocator.__init__": (),
-    "PySide2.QtXml.QXmlLocator.columnNumber": (),
-    "PySide2.QtXml.QXmlLocator.lineNumber": (),
-# class PySide2.QtXml.QXmlNamespaceSupport:
-    "PySide2.QtXml.QXmlNamespaceSupport.__init__": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.popContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefix": ('str',),
-    "PySide2.QtXml.QXmlNamespaceSupport.prefixes": [(), ('str',)],
-    "PySide2.QtXml.QXmlNamespaceSupport.processName": ('str', 'bool', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.pushContext": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.reset": (),
-    "PySide2.QtXml.QXmlNamespaceSupport.setPrefix": ('str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.splitName": ('str', 'str', 'str'),
-    "PySide2.QtXml.QXmlNamespaceSupport.uri": ('str',),
-# class PySide2.QtXml.QXmlParseException:
-    "PySide2.QtXml.QXmlParseException.__init__": [('PySide2.QtXml.QXmlParseException',), ('str', 'int', 'int', 'str', 'str')],
-    "PySide2.QtXml.QXmlParseException.columnNumber": (),
-    "PySide2.QtXml.QXmlParseException.lineNumber": (),
-    "PySide2.QtXml.QXmlParseException.message": (),
-    "PySide2.QtXml.QXmlParseException.publicId": (),
-    "PySide2.QtXml.QXmlParseException.systemId": (),
-# class PySide2.QtXml.QXmlReader:
-    "PySide2.QtXml.QXmlReader.__init__": (),
-    "PySide2.QtXml.QXmlReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlReader.contentHandler": (),
-    "PySide2.QtXml.QXmlReader.declHandler": (),
-    "PySide2.QtXml.QXmlReader.entityResolver": (),
-    "PySide2.QtXml.QXmlReader.errorHandler": (),
-    "PySide2.QtXml.QXmlReader.feature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlReader.parse": ('PySide2.QtXml.QXmlInputSource',),
-    "PySide2.QtXml.QXmlReader.property": ('str',),
-    "PySide2.QtXml.QXmlReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlReader.setProperty": ('str', 'int'),
-# class PySide2.QtXml.QXmlSimpleReader:
-    "PySide2.QtXml.QXmlSimpleReader.__init__": (),
-    "PySide2.QtXml.QXmlSimpleReader.DTDHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.contentHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.declHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.entityResolver": (),
-    "PySide2.QtXml.QXmlSimpleReader.errorHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.feature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasFeature": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.hasProperty": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.lexicalHandler": (),
-    "PySide2.QtXml.QXmlSimpleReader.parse": [('PySide2.QtXml.QXmlInputSource',), ('PySide2.QtXml.QXmlInputSource', 'bool')],
-    "PySide2.QtXml.QXmlSimpleReader.parseContinue": (),
-    "PySide2.QtXml.QXmlSimpleReader.property": ('str',),
-    "PySide2.QtXml.QXmlSimpleReader.setContentHandler": ('PySide2.QtXml.QXmlContentHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDTDHandler": ('PySide2.QtXml.QXmlDTDHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setDeclHandler": ('PySide2.QtXml.QXmlDeclHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setEntityResolver": ('PySide2.QtXml.QXmlEntityResolver',),
-    "PySide2.QtXml.QXmlSimpleReader.setErrorHandler": ('PySide2.QtXml.QXmlErrorHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setFeature": ('str', 'bool'),
-    "PySide2.QtXml.QXmlSimpleReader.setLexicalHandler": ('PySide2.QtXml.QXmlLexicalHandler',),
-    "PySide2.QtXml.QXmlSimpleReader.setProperty": ('str', 'int'),
-    }) if "PySide2.QtXml" in sys.modules else None
-# Module PySide2.QtXmlPatterns
-sig_dict.update({
-# class PySide2.QtXmlPatterns.QAbstractMessageHandler:
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.handleMessage": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-    "PySide2.QtXmlPatterns.QAbstractMessageHandler.message": ('PySide2.QtCore.QtMsgType', 'str', 'PySide2.QtCore.QUrl', 'PySide2.QtXmlPatterns.QSourceLocation'),
-# class PySide2.QtXmlPatterns.QAbstractUriResolver:
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtXmlPatterns.QAbstractUriResolver.resolve": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.NodeCopySetting:
-# class PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis:
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.attributes": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.baseUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.compareOrder": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.createIndex": [('int',), ('int', 'int')],
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.documentUri": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.elementById": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.isDeepEqual": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.kind": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.name": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceBindings": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.namespaceForPrefix": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'Missing("PySide2.QtXmlPatterns.QXmlName.PrefixCode")'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nextFromSimpleAxis": ('PySide2.QtXmlPatterns.QAbstractXmlNodeModel.SimpleAxis', 'PySide2.QtXmlPatterns.QXmlNodeModelIndex'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.nodesByIdref": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.root": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sendNamespaces": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex', 'PySide2.QtXmlPatterns.QAbstractXmlReceiver'),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.sourceLocation": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.stringValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-    "PySide2.QtXmlPatterns.QAbstractXmlNodeModel.typedValue": ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',),
-# class PySide2.QtXmlPatterns.QAbstractXmlReceiver:
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.__init__": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.characters": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.comment": ('str',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endElement": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startDocument": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.startOfSequence": (),
-    "PySide2.QtXmlPatterns.QAbstractXmlReceiver.whitespaceOnly": ('str',),
-# class PySide2.QtXmlPatterns.QSourceLocation:
-    "PySide2.QtXmlPatterns.QSourceLocation.__init__": [(), ('PySide2.QtCore.QUrl', 'int', 'int'), ('PySide2.QtXmlPatterns.QSourceLocation',)],
-    "PySide2.QtXmlPatterns.QSourceLocation.__copy__": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.column": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.isNull": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.line": (),
-    "PySide2.QtXmlPatterns.QSourceLocation.setColumn": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setLine": ('int',),
-    "PySide2.QtXmlPatterns.QSourceLocation.setUri": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtXmlPatterns.QSourceLocation.uri": (),
-# class PySide2.QtXmlPatterns.QXmlFormatter:
-    "PySide2.QtXmlPatterns.QXmlFormatter.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.indentationDepth": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlFormatter.setIndentationDepth": ('int',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlFormatter.startOfSequence": (),
-# class PySide2.QtXmlPatterns.QXmlItem:
-    "PySide2.QtXmlPatterns.QXmlItem.__init__": [(), ('PySide2.QtXmlPatterns.QXmlItem',), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',), ('typing.Any',)],
-    "PySide2.QtXmlPatterns.QXmlItem.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNode": (),
-    "PySide2.QtXmlPatterns.QXmlItem.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toAtomicValue": (),
-    "PySide2.QtXmlPatterns.QXmlItem.toNodeModelIndex": (),
-# class PySide2.QtXmlPatterns.QXmlName:
-    "PySide2.QtXmlPatterns.QXmlName.__init__": [(), ('PySide2.QtXmlPatterns.QXmlName',), ('PySide2.QtXmlPatterns.QXmlNamePool', 'str', 'str', 'str')],
-    "PySide2.QtXmlPatterns.QXmlName.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlName.fromClarkName": ('str', 'PySide2.QtXmlPatterns.QXmlNamePool'),
-    "PySide2.QtXmlPatterns.QXmlName.isNCName": ('str',),
-    "PySide2.QtXmlPatterns.QXmlName.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlName.localName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.namespaceUri": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.prefix": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-    "PySide2.QtXmlPatterns.QXmlName.toClarkName": ('PySide2.QtXmlPatterns.QXmlNamePool',),
-# class PySide2.QtXmlPatterns.QXmlNamePool:
-    "PySide2.QtXmlPatterns.QXmlNamePool.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',)],
-    "PySide2.QtXmlPatterns.QXmlNamePool.__copy__": (),
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.DocumentOrder:
-# class PySide2.QtXmlPatterns.QXmlNodeModelIndex.NodeKind:
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNodeModelIndex',)],
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.additionalData": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.data": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.internalPointer": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.isNull": (),
-    "PySide2.QtXmlPatterns.QXmlNodeModelIndex.model": (),
-# class PySide2.QtXmlPatterns.QXmlQuery:
-# class PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage:
-    "PySide2.QtXmlPatterns.QXmlQuery.__init__": [(), ('PySide2.QtXmlPatterns.QXmlNamePool',), ('PySide2.QtXmlPatterns.QXmlQuery',), ('PySide2.QtXmlPatterns.QXmlQuery.QueryLanguage', 'PySide2.QtXmlPatterns.QXmlNamePool')],
-    "PySide2.QtXmlPatterns.QXmlQuery.__copy__": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.bindVariable": [('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtCore.QIODevice'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlItem'), ('PySide2.QtXmlPatterns.QXmlName', 'PySide2.QtXmlPatterns.QXmlQuery'), ('str', 'PySide2.QtCore.QIODevice'), ('str', 'PySide2.QtXmlPatterns.QXmlItem'), ('str', 'PySide2.QtXmlPatterns.QXmlQuery')],
-    "PySide2.QtXmlPatterns.QXmlQuery.evaluateTo": [('PySide2.QtCore.QIODevice',), ('PySide2.QtXmlPatterns.QAbstractXmlReceiver',), ('PySide2.QtXmlPatterns.QXmlResultItems',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.initialTemplateName": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.queryLanguage": (),
-    "PySide2.QtXmlPatterns.QXmlQuery.setFocus": [('PySide2.QtCore.QIODevice',), ('PySide2.QtCore.QUrl',), ('PySide2.QtXmlPatterns.QXmlItem',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setInitialTemplateName": [('PySide2.QtXmlPatterns.QXmlName',), ('str',)],
-    "PySide2.QtXmlPatterns.QXmlQuery.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlQuery.setQuery": [('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'), ('str', 'PySide2.QtCore.QUrl')],
-    "PySide2.QtXmlPatterns.QXmlQuery.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlQuery.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlResultItems:
-    "PySide2.QtXmlPatterns.QXmlResultItems.__init__": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.current": (),
-    "PySide2.QtXmlPatterns.QXmlResultItems.hasError": (),
-# class PySide2.QtXmlPatterns.QXmlSchema:
-    "PySide2.QtXmlPatterns.QXmlSchema.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.documentUri": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.isValid": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.load": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-    "PySide2.QtXmlPatterns.QXmlSchema.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchema.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchema.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchema.uriResolver": (),
-# class PySide2.QtXmlPatterns.QXmlSchemaValidator:
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.__init__": [(), ('PySide2.QtXmlPatterns.QXmlSchema',)],
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.messageHandler": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.namePool": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.schema": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setMessageHandler": ('PySide2.QtXmlPatterns.QAbstractMessageHandler',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setSchema": ('PySide2.QtXmlPatterns.QXmlSchema',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.setUriResolver": ('PySide2.QtXmlPatterns.QAbstractUriResolver',),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.uriResolver": (),
-    "PySide2.QtXmlPatterns.QXmlSchemaValidator.validate": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QIODevice', 'PySide2.QtCore.QUrl'), ('PySide2.QtCore.QUrl',)],
-# class PySide2.QtXmlPatterns.QXmlSerializer:
-    "PySide2.QtXmlPatterns.QXmlSerializer.__init__": ('PySide2.QtXmlPatterns.QXmlQuery', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.atomicValue": ('typing.Any',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.attribute": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.characters": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.codec": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.comment": ('str',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endElement": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.endOfSequence": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.namespaceBinding": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.outputDevice": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.processingInstruction": ('PySide2.QtXmlPatterns.QXmlName', 'str'),
-    "PySide2.QtXmlPatterns.QXmlSerializer.setCodec": ('PySide2.QtCore.QTextCodec',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startDocument": (),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startElement": ('PySide2.QtXmlPatterns.QXmlName',),
-    "PySide2.QtXmlPatterns.QXmlSerializer.startOfSequence": (),
-    }) if "PySide2.QtXmlPatterns" in sys.modules else None
-# Module PySide2.QtHelp
-sig_dict.update({
-# class PySide2.QtHelp.QCompressedHelpInfo:
-    "PySide2.QtHelp.QCompressedHelpInfo.__init__": [(), ('PySide2.QtHelp.QCompressedHelpInfo',)],
-    "PySide2.QtHelp.QCompressedHelpInfo.__copy__": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.component": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.fromCompressedHelpFile": ('str',),
-    "PySide2.QtHelp.QCompressedHelpInfo.namespaceName": (),
-    "PySide2.QtHelp.QCompressedHelpInfo.swap": ('PySide2.QtHelp.QCompressedHelpInfo',),
-    "PySide2.QtHelp.QCompressedHelpInfo.version": (),
-# class PySide2.QtHelp.QHelpContentItem:
-    "PySide2.QtHelp.QHelpContentItem.__copy__": (),
-    "PySide2.QtHelp.QHelpContentItem.child": ('int',),
-    "PySide2.QtHelp.QHelpContentItem.childCount": (),
-    "PySide2.QtHelp.QHelpContentItem.childPosition": ('PySide2.QtHelp.QHelpContentItem',),
-    "PySide2.QtHelp.QHelpContentItem.parent": (),
-    "PySide2.QtHelp.QHelpContentItem.row": (),
-    "PySide2.QtHelp.QHelpContentItem.title": (),
-    "PySide2.QtHelp.QHelpContentItem.url": (),
-# class PySide2.QtHelp.QHelpContentModel:
-    "PySide2.QtHelp.QHelpContentModel.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.contentItemAt": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtHelp.QHelpContentModel.createContents": ('str',),
-    "PySide2.QtHelp.QHelpContentModel.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtHelp.QHelpContentModel.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtHelp.QHelpContentModel.isCreatingContents": (),
-    "PySide2.QtHelp.QHelpContentModel.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtHelp.QHelpContentModel.rowCount": ('PySide2.QtCore.QModelIndex',),
-# class PySide2.QtHelp.QHelpContentWidget:
-    "PySide2.QtHelp.QHelpContentWidget.indexOf": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtHelp.QHelpEngine:
-    "PySide2.QtHelp.QHelpEngine.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngine.contentModel": (),
-    "PySide2.QtHelp.QHelpEngine.contentWidget": (),
-    "PySide2.QtHelp.QHelpEngine.indexModel": (),
-    "PySide2.QtHelp.QHelpEngine.indexWidget": (),
-    "PySide2.QtHelp.QHelpEngine.searchEngine": (),
-# class PySide2.QtHelp.QHelpEngineCore:
-    "PySide2.QtHelp.QHelpEngineCore.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpEngineCore.addCustomFilter": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtHelp.QHelpEngineCore.autoSaveFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.collectionFile": (),
-    "PySide2.QtHelp.QHelpEngineCore.copyCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.currentFilter": (),
-    "PySide2.QtHelp.QHelpEngineCore.customFilters": (),
-    "PySide2.QtHelp.QHelpEngineCore.customValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.documentationFileName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.error": (),
-    "PySide2.QtHelp.QHelpEngineCore.fileData": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.files": [('str', 'str', 'str'), ('str', 'typing.Sequence[str]', 'str')],
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributeSets": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.filterAttributes": [(), ('str',)],
-    "PySide2.QtHelp.QHelpEngineCore.filterEngine": (),
-    "PySide2.QtHelp.QHelpEngineCore.findFile": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForIdentifier": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.linksForKeyword": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.metaData": ('str', 'str'),
-    "PySide2.QtHelp.QHelpEngineCore.namespaceName": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registerDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.registeredDocumentations": (),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.removeCustomValue": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setAutoSaveFilter": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setCollectionFile": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCurrentFilter": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.setCustomValue": ('str', 'typing.Any'),
-    "PySide2.QtHelp.QHelpEngineCore.setUsesFilterEngine": ('bool',),
-    "PySide2.QtHelp.QHelpEngineCore.setupData": (),
-    "PySide2.QtHelp.QHelpEngineCore.unregisterDocumentation": ('str',),
-    "PySide2.QtHelp.QHelpEngineCore.usesFilterEngine": (),
-# class PySide2.QtHelp.QHelpFilterData:
-    "PySide2.QtHelp.QHelpFilterData.__init__": [(), ('PySide2.QtHelp.QHelpFilterData',)],
-    "PySide2.QtHelp.QHelpFilterData.__copy__": (),
-    "PySide2.QtHelp.QHelpFilterData.components": (),
-    "PySide2.QtHelp.QHelpFilterData.setComponents": ('typing.Sequence[str]',),
-    "PySide2.QtHelp.QHelpFilterData.setVersions": ('typing.Sequence[PySide2.QtCore.QVersionNumber]',),
-    "PySide2.QtHelp.QHelpFilterData.swap": ('PySide2.QtHelp.QHelpFilterData',),
-    "PySide2.QtHelp.QHelpFilterData.versions": (),
-# class PySide2.QtHelp.QHelpFilterEngine:
-    "PySide2.QtHelp.QHelpFilterEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore',),
-    "PySide2.QtHelp.QHelpFilterEngine.activeFilter": (),
-    "PySide2.QtHelp.QHelpFilterEngine.availableComponents": (),
-    "PySide2.QtHelp.QHelpFilterEngine.filterData": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.filters": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToComponent": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespaceToVersion": (),
-    "PySide2.QtHelp.QHelpFilterEngine.namespacesForFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.removeFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setActiveFilter": ('str',),
-    "PySide2.QtHelp.QHelpFilterEngine.setFilterData": ('str', 'PySide2.QtHelp.QHelpFilterData'),
-# class PySide2.QtHelp.QHelpIndexModel:
-    "PySide2.QtHelp.QHelpIndexModel.createIndex": [('int', 'int', 'int'), ('int', 'int', 'object'), ('str',)],
-    "PySide2.QtHelp.QHelpIndexModel.filter": ('str', 'str'),
-    "PySide2.QtHelp.QHelpIndexModel.isCreatingIndex": (),
-    "PySide2.QtHelp.QHelpIndexModel.linksForKeyword": ('str',),
-# class PySide2.QtHelp.QHelpIndexWidget:
-    "PySide2.QtHelp.QHelpIndexWidget.activateCurrentItem": (),
-    "PySide2.QtHelp.QHelpIndexWidget.filterIndices": ('str', 'str'),
-# class PySide2.QtHelp.QHelpSearchEngine:
-    "PySide2.QtHelp.QHelpSearchEngine.__init__": ('PySide2.QtHelp.QHelpEngineCore', 'PySide2.QtCore.QObject'),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelIndexing": (),
-    "PySide2.QtHelp.QHelpSearchEngine.cancelSearching": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hitCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.hits": ('int', 'int'),
-    "PySide2.QtHelp.QHelpSearchEngine.hitsCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.query": (),
-    "PySide2.QtHelp.QHelpSearchEngine.queryWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.reindexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.resultWidget": (),
-    "PySide2.QtHelp.QHelpSearchEngine.scheduleIndexDocumentation": (),
-    "PySide2.QtHelp.QHelpSearchEngine.search": [('str',), ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',)],
-    "PySide2.QtHelp.QHelpSearchEngine.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResultCount": (),
-    "PySide2.QtHelp.QHelpSearchEngine.searchResults": ('int', 'int'),
-# class PySide2.QtHelp.QHelpSearchQuery:
-# class PySide2.QtHelp.QHelpSearchQuery.FieldName:
-    "PySide2.QtHelp.QHelpSearchQuery.__init__": [(), ('PySide2.QtHelp.QHelpSearchQuery',), ('PySide2.QtHelp.QHelpSearchQuery.FieldName', 'typing.Sequence[str]')],
-    "PySide2.QtHelp.QHelpSearchQuery.__copy__": (),
-# class PySide2.QtHelp.QHelpSearchQueryWidget:
-    "PySide2.QtHelp.QHelpSearchQueryWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.collapseExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.expandExtendedSearch": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.isCompactMode": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.query": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.searchInput": (),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setCompactMode": ('bool',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setQuery": ('typing.Sequence[PySide2.QtHelp.QHelpSearchQuery]',),
-    "PySide2.QtHelp.QHelpSearchQueryWidget.setSearchInput": ('str',),
-# class PySide2.QtHelp.QHelpSearchResult:
-    "PySide2.QtHelp.QHelpSearchResult.__init__": [(), ('PySide2.QtCore.QUrl', 'str', 'str'), ('PySide2.QtHelp.QHelpSearchResult',)],
-    "PySide2.QtHelp.QHelpSearchResult.snippet": (),
-    "PySide2.QtHelp.QHelpSearchResult.title": (),
-    "PySide2.QtHelp.QHelpSearchResult.url": (),
-# class PySide2.QtHelp.QHelpSearchResultWidget:
-    "PySide2.QtHelp.QHelpSearchResultWidget.changeEvent": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtHelp.QHelpSearchResultWidget.linkAt": ('PySide2.QtCore.QPoint',),
-    }) if "PySide2.QtHelp" in sys.modules else None
-# Module PySide2.QtMultimedia
-sig_dict.update({
-# class PySide2.QtMultimedia.QAbstractAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAbstractAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAbstractAudioInput:
-    "PySide2.QtMultimedia.QAbstractAudioInput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioInput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAbstractAudioOutput:
-    "PySide2.QtMultimedia.QAbstractAudioOutput.__init__": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAbstractAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAbstractAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAbstractVideoBuffer:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType:
-# class PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode:
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.__init__": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handle": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.handleType": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.mapMode": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.release": (),
-    "PySide2.QtMultimedia.QAbstractVideoBuffer.unmap": (),
-# class PySide2.QtMultimedia.QAbstractVideoFilter:
-    "PySide2.QtMultimedia.QAbstractVideoFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.createFilterRunnable": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoFilter.setActive": ('bool',),
-# class PySide2.QtMultimedia.QAbstractVideoSurface:
-# class PySide2.QtMultimedia.QAbstractVideoSurface.Error:
-    "PySide2.QtMultimedia.QAbstractVideoSurface.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.error": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isActive": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.isFormatSupported": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nativeResolution": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.nearestFormat": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.present": ('PySide2.QtMultimedia.QVideoFrame',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setError": ('PySide2.QtMultimedia.QAbstractVideoSurface.Error',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.setNativeResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.start": ('PySide2.QtMultimedia.QVideoSurfaceFormat',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.stop": (),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.supportedPixelFormats": ('PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType',),
-    "PySide2.QtMultimedia.QAbstractVideoSurface.surfaceFormat": (),
-# class PySide2.QtMultimedia.QAudio:
-# class PySide2.QtMultimedia.QAudio.Error:
-# class PySide2.QtMultimedia.QAudio.Mode:
-# class PySide2.QtMultimedia.QAudio.Role:
-# class PySide2.QtMultimedia.QAudio.State:
-# class PySide2.QtMultimedia.QAudio.VolumeScale:
-    "PySide2.QtMultimedia.QAudio.convertVolume": ('float', 'PySide2.QtMultimedia.QAudio.VolumeScale', 'PySide2.QtMultimedia.QAudio.VolumeScale'),
-# class PySide2.QtMultimedia.QAudioBuffer:
-    "PySide2.QtMultimedia.QAudioBuffer.__init__": [(), ('PySide2.QtCore.QByteArray', 'PySide2.QtMultimedia.QAudioFormat', 'int'), ('PySide2.QtMultimedia.QAudioBuffer',), ('int', 'PySide2.QtMultimedia.QAudioFormat', 'int')],
-    "PySide2.QtMultimedia.QAudioBuffer.__copy__": (),
-    "PySide2.QtMultimedia.QAudioBuffer.byteCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.constData": (),
-    "PySide2.QtMultimedia.QAudioBuffer.data": (),
-    "PySide2.QtMultimedia.QAudioBuffer.duration": (),
-    "PySide2.QtMultimedia.QAudioBuffer.format": (),
-    "PySide2.QtMultimedia.QAudioBuffer.frameCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.isValid": (),
-    "PySide2.QtMultimedia.QAudioBuffer.sampleCount": (),
-    "PySide2.QtMultimedia.QAudioBuffer.startTime": (),
-# class PySide2.QtMultimedia.QAudioDecoder:
-# class PySide2.QtMultimedia.QAudioDecoder.Error:
-# class PySide2.QtMultimedia.QAudioDecoder.State:
-    "PySide2.QtMultimedia.QAudioDecoder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoder.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoder.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoder.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoder.error": (),
-    "PySide2.QtMultimedia.QAudioDecoder.errorString": (),
-    "PySide2.QtMultimedia.QAudioDecoder.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QAudioDecoder.position": (),
-    "PySide2.QtMultimedia.QAudioDecoder.read": (),
-    "PySide2.QtMultimedia.QAudioDecoder.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoder.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoder.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoder.start": (),
-    "PySide2.QtMultimedia.QAudioDecoder.state": (),
-    "PySide2.QtMultimedia.QAudioDecoder.stop": (),
-    "PySide2.QtMultimedia.QAudioDecoder.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QAudioDecoderControl:
-    "PySide2.QtMultimedia.QAudioDecoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.audioFormat": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.bufferAvailable": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.duration": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.position": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.read": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setAudioFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.setSourceFilename": ('str',),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceDevice": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.sourceFilename": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.start": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.state": (),
-    "PySide2.QtMultimedia.QAudioDecoderControl.stop": (),
-# class PySide2.QtMultimedia.QAudioDeviceInfo:
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__init__": [(), ('PySide2.QtMultimedia.QAudioDeviceInfo',)],
-    "PySide2.QtMultimedia.QAudioDeviceInfo.__copy__": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.availableDevices": ('PySide2.QtMultimedia.QAudio.Mode',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultInputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.defaultOutputDevice": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.deviceName": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isFormatSupported": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.isNull": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.nearestFormat": ('PySide2.QtMultimedia.QAudioFormat',),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.preferredFormat": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.realm": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedByteOrders": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedChannelCounts": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedCodecs": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleRates": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleSizes": (),
-    "PySide2.QtMultimedia.QAudioDeviceInfo.supportedSampleTypes": (),
-# class PySide2.QtMultimedia.QAudioEncoderSettings:
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QAudioEncoderSettings',)],
-    "PySide2.QtMultimedia.QAudioEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.channelCount": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QAudioEncoderSettings.setSampleRate": ('int',),
-# class PySide2.QtMultimedia.QAudioEncoderSettingsControl:
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.audioSettings": (),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.codecDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QAudioEncoderSettingsControl.supportedAudioCodecs": (),
-# class PySide2.QtMultimedia.QAudioFormat:
-# class PySide2.QtMultimedia.QAudioFormat.Endian:
-# class PySide2.QtMultimedia.QAudioFormat.SampleType:
-    "PySide2.QtMultimedia.QAudioFormat.__init__": [(), ('PySide2.QtMultimedia.QAudioFormat',)],
-    "PySide2.QtMultimedia.QAudioFormat.__copy__": (),
-    "PySide2.QtMultimedia.QAudioFormat.byteOrder": (),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.bytesPerFrame": (),
-    "PySide2.QtMultimedia.QAudioFormat.channelCount": (),
-    "PySide2.QtMultimedia.QAudioFormat.codec": (),
-    "PySide2.QtMultimedia.QAudioFormat.durationForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.durationForFrames": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForBytes": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.framesForDuration": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.isValid": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleRate": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleSize": (),
-    "PySide2.QtMultimedia.QAudioFormat.sampleType": (),
-    "PySide2.QtMultimedia.QAudioFormat.setByteOrder": ('PySide2.QtMultimedia.QAudioFormat.Endian',),
-    "PySide2.QtMultimedia.QAudioFormat.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setCodec": ('str',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleSize": ('int',),
-    "PySide2.QtMultimedia.QAudioFormat.setSampleType": ('PySide2.QtMultimedia.QAudioFormat.SampleType',),
-# class PySide2.QtMultimedia.QAudioInput:
-    "PySide2.QtMultimedia.QAudioInput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioInput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioInput.bytesReady": (),
-    "PySide2.QtMultimedia.QAudioInput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.error": (),
-    "PySide2.QtMultimedia.QAudioInput.format": (),
-    "PySide2.QtMultimedia.QAudioInput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioInput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioInput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioInput.reset": (),
-    "PySide2.QtMultimedia.QAudioInput.resume": (),
-    "PySide2.QtMultimedia.QAudioInput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioInput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioInput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioInput.state": (),
-    "PySide2.QtMultimedia.QAudioInput.stop": (),
-    "PySide2.QtMultimedia.QAudioInput.suspend": (),
-    "PySide2.QtMultimedia.QAudioInput.volume": (),
-# class PySide2.QtMultimedia.QAudioInputSelectorControl:
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.activeInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.availableInputs": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.defaultInput": (),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.inputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioInputSelectorControl.setActiveInput": ('str',),
-# class PySide2.QtMultimedia.QAudioOutput:
-    "PySide2.QtMultimedia.QAudioOutput.__init__": [('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QAudioFormat', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QAudioOutput.bufferSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.bytesFree": (),
-    "PySide2.QtMultimedia.QAudioOutput.category": (),
-    "PySide2.QtMultimedia.QAudioOutput.elapsedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.error": (),
-    "PySide2.QtMultimedia.QAudioOutput.format": (),
-    "PySide2.QtMultimedia.QAudioOutput.notifyInterval": (),
-    "PySide2.QtMultimedia.QAudioOutput.periodSize": (),
-    "PySide2.QtMultimedia.QAudioOutput.processedUSecs": (),
-    "PySide2.QtMultimedia.QAudioOutput.reset": (),
-    "PySide2.QtMultimedia.QAudioOutput.resume": (),
-    "PySide2.QtMultimedia.QAudioOutput.setBufferSize": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setCategory": ('str',),
-    "PySide2.QtMultimedia.QAudioOutput.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QAudioOutput.setVolume": ('float',),
-    "PySide2.QtMultimedia.QAudioOutput.start": [(), ('PySide2.QtCore.QIODevice',)],
-    "PySide2.QtMultimedia.QAudioOutput.state": (),
-    "PySide2.QtMultimedia.QAudioOutput.stop": (),
-    "PySide2.QtMultimedia.QAudioOutput.suspend": (),
-    "PySide2.QtMultimedia.QAudioOutput.volume": (),
-# class PySide2.QtMultimedia.QAudioOutputSelectorControl:
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.activeOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.availableOutputs": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.defaultOutput": (),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.outputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioOutputSelectorControl.setActiveOutput": ('str',),
-# class PySide2.QtMultimedia.QAudioProbe:
-    "PySide2.QtMultimedia.QAudioProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioProbe.isActive": (),
-    "PySide2.QtMultimedia.QAudioProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QAudioRecorder:
-    "PySide2.QtMultimedia.QAudioRecorder.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputDescription": ('str',),
-    "PySide2.QtMultimedia.QAudioRecorder.audioInputs": (),
-    "PySide2.QtMultimedia.QAudioRecorder.defaultAudioInput": (),
-    "PySide2.QtMultimedia.QAudioRecorder.setAudioInput": ('str',),
-# class PySide2.QtMultimedia.QAudioRoleControl:
-    "PySide2.QtMultimedia.QAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QAudioRoleControl.audioRole": (),
-    "PySide2.QtMultimedia.QAudioRoleControl.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QAudioRoleControl.supportedAudioRoles": (),
-# class PySide2.QtMultimedia.QCamera:
-# class PySide2.QtMultimedia.QCamera.CaptureMode:
-# class PySide2.QtMultimedia.QCamera.CaptureModes:
-# class PySide2.QtMultimedia.QCamera.Error:
-# class PySide2.QtMultimedia.QCamera.FrameRateRange:
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__init__": [(), ('PySide2.QtMultimedia.QCamera.FrameRateRange',), ('float', 'float')],
-    "PySide2.QtMultimedia.QCamera.FrameRateRange.__copy__": (),
-# class PySide2.QtMultimedia.QCamera.LockChangeReason:
-# class PySide2.QtMultimedia.QCamera.LockStatus:
-# class PySide2.QtMultimedia.QCamera.LockType:
-# class PySide2.QtMultimedia.QCamera.LockTypes:
-# class PySide2.QtMultimedia.QCamera.Position:
-# class PySide2.QtMultimedia.QCamera.State:
-# class PySide2.QtMultimedia.QCamera.Status:
-    "PySide2.QtMultimedia.QCamera.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QCamera.Position', 'PySide2.QtCore.QObject'), ('PySide2.QtMultimedia.QCameraInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QCamera.availability": (),
-    "PySide2.QtMultimedia.QCamera.availableDevices": (),
-    "PySide2.QtMultimedia.QCamera.captureMode": (),
-    "PySide2.QtMultimedia.QCamera.deviceDescription": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QCamera.error": (),
-    "PySide2.QtMultimedia.QCamera.errorString": (),
-    "PySide2.QtMultimedia.QCamera.exposure": (),
-    "PySide2.QtMultimedia.QCamera.focus": (),
-    "PySide2.QtMultimedia.QCamera.imageProcessing": (),
-    "PySide2.QtMultimedia.QCamera.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.load": (),
-    "PySide2.QtMultimedia.QCamera.lockStatus": [(), ('PySide2.QtMultimedia.QCamera.LockType',)],
-    "PySide2.QtMultimedia.QCamera.requestedLocks": (),
-    "PySide2.QtMultimedia.QCamera.searchAndLock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCamera.setViewfinder": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QCamera.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.start": (),
-    "PySide2.QtMultimedia.QCamera.state": (),
-    "PySide2.QtMultimedia.QCamera.status": (),
-    "PySide2.QtMultimedia.QCamera.stop": (),
-    "PySide2.QtMultimedia.QCamera.supportedLocks": (),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderFrameRateRanges": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderPixelFormats": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderResolutions": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.supportedViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCamera.unload": (),
-    "PySide2.QtMultimedia.QCamera.unlock": [(), ('PySide2.QtMultimedia.QCamera.LockTypes',)],
-    "PySide2.QtMultimedia.QCamera.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraCaptureBufferFormatControl:
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraCaptureBufferFormatControl.supportedBufferFormats": (),
-# class PySide2.QtMultimedia.QCameraCaptureDestinationControl:
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraCaptureDestinationControl.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-# class PySide2.QtMultimedia.QCameraControl:
-# class PySide2.QtMultimedia.QCameraControl.PropertyChangeType:
-    "PySide2.QtMultimedia.QCameraControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraControl.canChangeProperty": ('PySide2.QtMultimedia.QCameraControl.PropertyChangeType', 'PySide2.QtMultimedia.QCamera.Status'),
-    "PySide2.QtMultimedia.QCameraControl.captureMode": (),
-    "PySide2.QtMultimedia.QCameraControl.isCaptureModeSupported": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setCaptureMode": ('PySide2.QtMultimedia.QCamera.CaptureModes',),
-    "PySide2.QtMultimedia.QCameraControl.setState": ('PySide2.QtMultimedia.QCamera.State',),
-    "PySide2.QtMultimedia.QCameraControl.state": (),
-    "PySide2.QtMultimedia.QCameraControl.status": (),
-# class PySide2.QtMultimedia.QCameraExposure:
-# class PySide2.QtMultimedia.QCameraExposure.ExposureMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashMode:
-# class PySide2.QtMultimedia.QCameraExposure.FlashModes:
-# class PySide2.QtMultimedia.QCameraExposure.MeteringMode:
-    "PySide2.QtMultimedia.QCameraExposure.aperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureCompensation": (),
-    "PySide2.QtMultimedia.QCameraExposure.exposureMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.flashMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraExposure.isExposureModeSupported": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraExposure.isMeteringModeSupported": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.isoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.meteringMode": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.requestedShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoAperture": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoIsoSensitivity": (),
-    "PySide2.QtMultimedia.QCameraExposure.setAutoShutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureCompensation": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setExposureMode": ('PySide2.QtMultimedia.QCameraExposure.ExposureMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualAperture": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualIsoSensitivity": ('int',),
-    "PySide2.QtMultimedia.QCameraExposure.setManualShutterSpeed": ('float',),
-    "PySide2.QtMultimedia.QCameraExposure.setMeteringMode": ('PySide2.QtMultimedia.QCameraExposure.MeteringMode',),
-    "PySide2.QtMultimedia.QCameraExposure.setSpotMeteringPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraExposure.shutterSpeed": (),
-    "PySide2.QtMultimedia.QCameraExposure.spotMeteringPoint": (),
-# class PySide2.QtMultimedia.QCameraExposureControl:
-# class PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter:
-    "PySide2.QtMultimedia.QCameraExposureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraExposureControl.actualValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.requestedValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter',),
-    "PySide2.QtMultimedia.QCameraExposureControl.setValue": ('PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraFeedbackControl:
-# class PySide2.QtMultimedia.QCameraFeedbackControl.EventType:
-    "PySide2.QtMultimedia.QCameraFeedbackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.isEventFeedbackLocked": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.resetEventFeedback": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType',),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackEnabled": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'bool'),
-    "PySide2.QtMultimedia.QCameraFeedbackControl.setEventFeedbackSound": ('PySide2.QtMultimedia.QCameraFeedbackControl.EventType', 'str'),
-# class PySide2.QtMultimedia.QCameraFlashControl:
-    "PySide2.QtMultimedia.QCameraFlashControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFlashControl.flashMode": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashModeSupported": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-    "PySide2.QtMultimedia.QCameraFlashControl.isFlashReady": (),
-    "PySide2.QtMultimedia.QCameraFlashControl.setFlashMode": ('PySide2.QtMultimedia.QCameraExposure.FlashModes',),
-# class PySide2.QtMultimedia.QCameraFocus:
-# class PySide2.QtMultimedia.QCameraFocus.FocusMode:
-# class PySide2.QtMultimedia.QCameraFocus.FocusModes:
-# class PySide2.QtMultimedia.QCameraFocus.FocusPointMode:
-    "PySide2.QtMultimedia.QCameraFocus.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocus.digitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocus.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocus.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.opticalZoom": (),
-    "PySide2.QtMultimedia.QCameraFocus.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocus.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocus.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCameraFocusControl:
-    "PySide2.QtMultimedia.QCameraFocusControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraFocusControl.customFocusPoint": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusPointMode": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.focusZones": (),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.isFocusPointModeSupported": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setCustomFocusPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusMode": ('PySide2.QtMultimedia.QCameraFocus.FocusModes',),
-    "PySide2.QtMultimedia.QCameraFocusControl.setFocusPointMode": ('PySide2.QtMultimedia.QCameraFocus.FocusPointMode',),
-# class PySide2.QtMultimedia.QCameraFocusZone:
-# class PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus:
-    "PySide2.QtMultimedia.QCameraFocusZone.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus'), ('PySide2.QtMultimedia.QCameraFocusZone',)],
-    "PySide2.QtMultimedia.QCameraFocusZone.__copy__": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.area": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.isValid": (),
-    "PySide2.QtMultimedia.QCameraFocusZone.setStatus": ('PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus',),
-    "PySide2.QtMultimedia.QCameraFocusZone.status": (),
-# class PySide2.QtMultimedia.QCameraImageCapture:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestination:
-# class PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations:
-# class PySide2.QtMultimedia.QCameraImageCapture.DriveMode:
-# class PySide2.QtMultimedia.QCameraImageCapture.Error:
-    "PySide2.QtMultimedia.QCameraImageCapture.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QCameraImageCapture.availability": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.bufferFormat": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.captureDestination": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.encodingSettings": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.error": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.errorString": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.isCaptureDestinationSupported": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.mediaObject": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.setBufferFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setCaptureDestination": ('PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setEncodingSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QCameraImageCapture.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedBufferFormats": (),
-    "PySide2.QtMultimedia.QCameraImageCapture.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QCameraImageCaptureControl:
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.cancelCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.capture": ('str',),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.driveMode": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.isReadyForCapture": (),
-    "PySide2.QtMultimedia.QCameraImageCaptureControl.setDriveMode": ('PySide2.QtMultimedia.QCameraImageCapture.DriveMode',),
-# class PySide2.QtMultimedia.QCameraImageProcessing:
-# class PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter:
-# class PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode:
-    "PySide2.QtMultimedia.QCameraImageProcessing.brightness": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.colorFilter": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.contrast": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.denoisingLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isAvailable": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isColorFilterSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.isWhiteBalanceModeSupported": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.manualWhiteBalance": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.saturation": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setBrightness": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setColorFilter": ('PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setContrast": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setDenoisingLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setManualWhiteBalance": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSaturation": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setSharpeningLevel": ('float',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.setWhiteBalanceMode": ('PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode',),
-    "PySide2.QtMultimedia.QCameraImageProcessing.sharpeningLevel": (),
-    "PySide2.QtMultimedia.QCameraImageProcessing.whiteBalanceMode": (),
-# class PySide2.QtMultimedia.QCameraImageProcessingControl:
-# class PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter:
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.isParameterValueSupported": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.parameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter',),
-    "PySide2.QtMultimedia.QCameraImageProcessingControl.setParameter": ('PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter', 'typing.Any'),
-# class PySide2.QtMultimedia.QCameraInfo:
-    "PySide2.QtMultimedia.QCameraInfo.__init__": [('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera',), ('PySide2.QtMultimedia.QCameraInfo',)],
-    "PySide2.QtMultimedia.QCameraInfo.__copy__": (),
-    "PySide2.QtMultimedia.QCameraInfo.availableCameras": ('PySide2.QtMultimedia.QCamera.Position',),
-    "PySide2.QtMultimedia.QCameraInfo.defaultCamera": (),
-    "PySide2.QtMultimedia.QCameraInfo.description": (),
-    "PySide2.QtMultimedia.QCameraInfo.deviceName": (),
-    "PySide2.QtMultimedia.QCameraInfo.isNull": (),
-    "PySide2.QtMultimedia.QCameraInfo.orientation": (),
-    "PySide2.QtMultimedia.QCameraInfo.position": (),
-# class PySide2.QtMultimedia.QCameraInfoControl:
-    "PySide2.QtMultimedia.QCameraInfoControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraOrientation": ('str',),
-    "PySide2.QtMultimedia.QCameraInfoControl.cameraPosition": ('str',),
-# class PySide2.QtMultimedia.QCameraLocksControl:
-    "PySide2.QtMultimedia.QCameraLocksControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraLocksControl.lockStatus": ('PySide2.QtMultimedia.QCamera.LockType',),
-    "PySide2.QtMultimedia.QCameraLocksControl.searchAndLock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-    "PySide2.QtMultimedia.QCameraLocksControl.supportedLocks": (),
-    "PySide2.QtMultimedia.QCameraLocksControl.unlock": ('PySide2.QtMultimedia.QCamera.LockTypes',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettings:
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__init__": [(), ('PySide2.QtMultimedia.QCameraViewfinderSettings',)],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.isNull": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.maximumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.minimumFrameRate": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.pixelFormat": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.resolution": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMaximumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setMinimumFrameRate": ('float',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QCameraViewfinderSettings.swap": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl:
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.isViewfinderParameterSupported": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.setViewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter', 'typing.Any'),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl.viewfinderParameter": ('PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter',),
-# class PySide2.QtMultimedia.QCameraViewfinderSettingsControl2:
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.setViewfinderSettings": ('PySide2.QtMultimedia.QCameraViewfinderSettings',),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.supportedViewfinderSettings": (),
-    "PySide2.QtMultimedia.QCameraViewfinderSettingsControl2.viewfinderSettings": (),
-# class PySide2.QtMultimedia.QCameraZoomControl:
-    "PySide2.QtMultimedia.QCameraZoomControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.currentOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.maximumOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedDigitalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.requestedOpticalZoom": (),
-    "PySide2.QtMultimedia.QCameraZoomControl.zoomTo": ('float', 'float'),
-# class PySide2.QtMultimedia.QCustomAudioRoleControl:
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.customAudioRole": (),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QCustomAudioRoleControl.supportedCustomAudioRoles": (),
-# class PySide2.QtMultimedia.QImageEncoderControl:
-    "PySide2.QtMultimedia.QImageEncoderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderControl.imageSettings": (),
-    "PySide2.QtMultimedia.QImageEncoderControl.setImageSettings": ('PySide2.QtMultimedia.QImageEncoderSettings',),
-    "PySide2.QtMultimedia.QImageEncoderControl.supportedImageCodecs": (),
-# class PySide2.QtMultimedia.QImageEncoderSettings:
-    "PySide2.QtMultimedia.QImageEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QImageEncoderSettings',)],
-    "PySide2.QtMultimedia.QImageEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QImageEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QMediaAudioProbeControl:
-    "PySide2.QtMultimedia.QMediaAudioProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaAvailabilityControl:
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaAvailabilityControl.availability": (),
-# class PySide2.QtMultimedia.QMediaBindableInterface:
-    "PySide2.QtMultimedia.QMediaBindableInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaBindableInterface.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimedia.QMediaContainerControl:
-    "PySide2.QtMultimedia.QMediaContainerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaContainerControl.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaContainerControl.supportedContainers": (),
-# class PySide2.QtMultimedia.QMediaContent:
-    "PySide2.QtMultimedia.QMediaContent.__init__": [(), ('PySide2.QtCore.QUrl',), ('PySide2.QtMultimedia.QMediaContent',), ('PySide2.QtMultimedia.QMediaPlaylist', 'PySide2.QtCore.QUrl', 'bool'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest',), ('typing.Sequence[PySide2.QtMultimedia.QMediaResource]',)],
-    "PySide2.QtMultimedia.QMediaContent.__copy__": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalRequest": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalResource": (),
-    "PySide2.QtMultimedia.QMediaContent.canonicalUrl": (),
-    "PySide2.QtMultimedia.QMediaContent.isNull": (),
-    "PySide2.QtMultimedia.QMediaContent.playlist": (),
-    "PySide2.QtMultimedia.QMediaContent.request": (),
-    "PySide2.QtMultimedia.QMediaContent.resources": (),
-# class PySide2.QtMultimedia.QMediaControl:
-    "PySide2.QtMultimedia.QMediaControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaGaplessPlaybackControl:
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.crossfadeTime": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.isCrossfadeSupported": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.nextMedia": (),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setCrossfadeTime": ('float',),
-    "PySide2.QtMultimedia.QMediaGaplessPlaybackControl.setNextMedia": ('PySide2.QtMultimedia.QMediaContent',),
-# class PySide2.QtMultimedia.QMediaNetworkAccessControl:
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.currentConfiguration": (),
-    "PySide2.QtMultimedia.QMediaNetworkAccessControl.setConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-# class PySide2.QtMultimedia.QMediaObject:
-    "PySide2.QtMultimedia.QMediaObject.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaService'),
-    "PySide2.QtMultimedia.QMediaObject.addPropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.availability": (),
-    "PySide2.QtMultimedia.QMediaObject.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaObject.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaObject.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaObject.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaObject.notifyInterval": (),
-    "PySide2.QtMultimedia.QMediaObject.removePropertyWatch": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaObject.service": (),
-    "PySide2.QtMultimedia.QMediaObject.setNotifyInterval": ('int',),
-    "PySide2.QtMultimedia.QMediaObject.unbind": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMediaPlayer:
-# class PySide2.QtMultimedia.QMediaPlayer.Error:
-# class PySide2.QtMultimedia.QMediaPlayer.Flag:
-# class PySide2.QtMultimedia.QMediaPlayer.Flags:
-# class PySide2.QtMultimedia.QMediaPlayer.MediaStatus:
-# class PySide2.QtMultimedia.QMediaPlayer.State:
-    "PySide2.QtMultimedia.QMediaPlayer.__init__": ('PySide2.QtCore.QObject', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.audioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.availability": (),
-    "PySide2.QtMultimedia.QMediaPlayer.bind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlayer.currentNetworkConfiguration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.customAudioRole": (),
-    "PySide2.QtMultimedia.QMediaPlayer.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayer.error": (),
-    "PySide2.QtMultimedia.QMediaPlayer.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlayer.hasSupport": ('str', 'typing.Sequence[str]', 'PySide2.QtMultimedia.QMediaPlayer.Flags'),
-    "PySide2.QtMultimedia.QMediaPlayer.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayer.media": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayer.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayer.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayer.play": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayer.playlist": (),
-    "PySide2.QtMultimedia.QMediaPlayer.position": (),
-    "PySide2.QtMultimedia.QMediaPlayer.setAudioRole": ('PySide2.QtMultimedia.QAudio.Role',),
-    "PySide2.QtMultimedia.QMediaPlayer.setCustomAudioRole": ('str',),
-    "PySide2.QtMultimedia.QMediaPlayer.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayer.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayer.setNetworkConfigurations": ('typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPlaylist": ('PySide2.QtMultimedia.QMediaPlaylist',),
-    "PySide2.QtMultimedia.QMediaPlayer.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.setVideoOutput": [('PySide2.QtMultimedia.QAbstractVideoSurface',), ('PySide2.QtMultimediaWidgets.QGraphicsVideoItem',), ('PySide2.QtMultimediaWidgets.QVideoWidget',)],
-    "PySide2.QtMultimedia.QMediaPlayer.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayer.state": (),
-    "PySide2.QtMultimedia.QMediaPlayer.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedCustomAudioRoles": (),
-    "PySide2.QtMultimedia.QMediaPlayer.supportedMimeTypes": ('PySide2.QtMultimedia.QMediaPlayer.Flags',),
-    "PySide2.QtMultimedia.QMediaPlayer.unbind": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayer.volume": (),
-# class PySide2.QtMultimedia.QMediaPlayerControl:
-    "PySide2.QtMultimedia.QMediaPlayerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.availablePlaybackRanges": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.bufferStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.duration": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isAudioAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isSeekable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.isVideoAvailable": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.media": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStatus": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.mediaStream": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.pause": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.play": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.playbackRate": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.position": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMedia": ('PySide2.QtMultimedia.QMediaContent', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPlaybackRate": ('float',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setPosition": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QMediaPlayerControl.state": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.stop": (),
-    "PySide2.QtMultimedia.QMediaPlayerControl.volume": (),
-# class PySide2.QtMultimedia.QMediaPlaylist:
-# class PySide2.QtMultimedia.QMediaPlaylist.Error:
-# class PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode:
-    "PySide2.QtMultimedia.QMediaPlaylist.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.addMedia": [('PySide2.QtMultimedia.QMediaContent',), ('typing.Sequence[PySide2.QtMultimedia.QMediaContent]',)],
-    "PySide2.QtMultimedia.QMediaPlaylist.clear": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentIndex": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.currentMedia": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.error": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.errorString": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.insertMedia": [('int', 'PySide2.QtMultimedia.QMediaContent'), ('int', 'typing.Sequence[PySide2.QtMultimedia.QMediaContent]')],
-    "PySide2.QtMultimedia.QMediaPlaylist.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.isReadOnly": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.load": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.media": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaCount": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.moveMedia": ('int', 'int'),
-    "PySide2.QtMultimedia.QMediaPlaylist.nextIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.playbackMode": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previous": (),
-    "PySide2.QtMultimedia.QMediaPlaylist.previousIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.removeMedia": [('int',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaPlaylist.save": [('PySide2.QtCore.QIODevice', 'str'), ('PySide2.QtCore.QUrl', 'str')],
-    "PySide2.QtMultimedia.QMediaPlaylist.setCurrentIndex": ('int',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaPlaylist.setPlaybackMode": ('PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode',),
-    "PySide2.QtMultimedia.QMediaPlaylist.shuffle": (),
-# class PySide2.QtMultimedia.QMediaRecorder:
-# class PySide2.QtMultimedia.QMediaRecorder.Error:
-# class PySide2.QtMultimedia.QMediaRecorder.State:
-# class PySide2.QtMultimedia.QMediaRecorder.Status:
-    "PySide2.QtMultimedia.QMediaRecorder.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QMediaRecorder.actualLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.audioCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.audioSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availability": (),
-    "PySide2.QtMultimedia.QMediaRecorder.availableMetaData": (),
-    "PySide2.QtMultimedia.QMediaRecorder.containerDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.containerFormat": (),
-    "PySide2.QtMultimedia.QMediaRecorder.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorder.error": (),
-    "PySide2.QtMultimedia.QMediaRecorder.errorString": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMetaDataWritable": (),
-    "PySide2.QtMultimedia.QMediaRecorder.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorder.mediaObject": (),
-    "PySide2.QtMultimedia.QMediaRecorder.metaData": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorder.pause": (),
-    "PySide2.QtMultimedia.QMediaRecorder.record": (),
-    "PySide2.QtMultimedia.QMediaRecorder.setAudioSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setContainerFormat": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.setEncodingSettings": ('PySide2.QtMultimedia.QAudioEncoderSettings', 'PySide2.QtMultimedia.QVideoEncoderSettings', 'str'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QMediaRecorder.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QMediaRecorder.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorder.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QMediaRecorder.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorder.state": (),
-    "PySide2.QtMultimedia.QMediaRecorder.status": (),
-    "PySide2.QtMultimedia.QMediaRecorder.stop": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedAudioCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedContainers": (),
-    "PySide2.QtMultimedia.QMediaRecorder.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QMediaRecorder.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QMediaRecorder.videoSettings": (),
-    "PySide2.QtMultimedia.QMediaRecorder.volume": (),
-# class PySide2.QtMultimedia.QMediaRecorderControl:
-    "PySide2.QtMultimedia.QMediaRecorderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.applySettings": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.duration": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.isMuted": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.outputLocation": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setOutputLocation": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setState": ('PySide2.QtMultimedia.QMediaRecorder.State',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.setVolume": ('float',),
-    "PySide2.QtMultimedia.QMediaRecorderControl.state": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.status": (),
-    "PySide2.QtMultimedia.QMediaRecorderControl.volume": (),
-# class PySide2.QtMultimedia.QMediaResource:
-    "PySide2.QtMultimedia.QMediaResource.__init__": [(), ('PySide2.QtCore.QUrl', 'str'), ('PySide2.QtMultimedia.QMediaResource',), ('PySide2.QtNetwork.QNetworkRequest', 'str')],
-    "PySide2.QtMultimedia.QMediaResource.__copy__": (),
-    "PySide2.QtMultimedia.QMediaResource.audioBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.audioCodec": (),
-    "PySide2.QtMultimedia.QMediaResource.channelCount": (),
-    "PySide2.QtMultimedia.QMediaResource.dataSize": (),
-    "PySide2.QtMultimedia.QMediaResource.isNull": (),
-    "PySide2.QtMultimedia.QMediaResource.language": (),
-    "PySide2.QtMultimedia.QMediaResource.mimeType": (),
-    "PySide2.QtMultimedia.QMediaResource.request": (),
-    "PySide2.QtMultimedia.QMediaResource.resolution": (),
-    "PySide2.QtMultimedia.QMediaResource.sampleRate": (),
-    "PySide2.QtMultimedia.QMediaResource.setAudioBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setAudioCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setChannelCount": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setDataSize": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setLanguage": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaResource.setSampleRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoBitRate": ('int',),
-    "PySide2.QtMultimedia.QMediaResource.setVideoCodec": ('str',),
-    "PySide2.QtMultimedia.QMediaResource.url": (),
-    "PySide2.QtMultimedia.QMediaResource.videoBitRate": (),
-    "PySide2.QtMultimedia.QMediaResource.videoCodec": (),
-# class PySide2.QtMultimedia.QMediaService:
-    "PySide2.QtMultimedia.QMediaService.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaService.releaseControl": ('PySide2.QtMultimedia.QMediaControl',),
-    "PySide2.QtMultimedia.QMediaService.requestControl": ('str',),
-# class PySide2.QtMultimedia.QMediaServiceCameraInfoInterface:
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraOrientation": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtMultimedia.QMediaServiceCameraInfoInterface.cameraPosition": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface:
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceDefaultDeviceInterface.defaultDevice": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceFeaturesInterface:
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceFeaturesInterface.supportedFeatures": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceProviderHint:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Feature:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Features:
-# class PySide2.QtMultimedia.QMediaServiceProviderHint.Type:
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtMultimedia.QCamera.Position',), ('PySide2.QtMultimedia.QMediaServiceProviderHint',), ('PySide2.QtMultimedia.QMediaServiceProviderHint.Features',), ('str', 'typing.Sequence[str]')],
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.__copy__": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.cameraPosition": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.codecs": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.device": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.features": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.isNull": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.mimeType": (),
-    "PySide2.QtMultimedia.QMediaServiceProviderHint.type": (),
-# class PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.deviceDescription": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedDevicesInterface.devices": ('PySide2.QtCore.QByteArray',),
-# class PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface:
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.__init__": (),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.hasSupport": ('str', 'typing.Sequence[str]'),
-    "PySide2.QtMultimedia.QMediaServiceSupportedFormatsInterface.supportedMimeTypes": (),
-# class PySide2.QtMultimedia.QMediaStreamsControl:
-# class PySide2.QtMultimedia.QMediaStreamsControl.StreamType:
-    "PySide2.QtMultimedia.QMediaStreamsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.isActive": ('int',),
-    "PySide2.QtMultimedia.QMediaStreamsControl.metaData": ('int', 'str'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.setActive": ('int', 'bool'),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamCount": (),
-    "PySide2.QtMultimedia.QMediaStreamsControl.streamType": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeInterval:
-    "PySide2.QtMultimedia.QMediaTimeInterval.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeInterval.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeInterval.end": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.isNormal": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.normalized": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.start": (),
-    "PySide2.QtMultimedia.QMediaTimeInterval.translated": ('int',),
-# class PySide2.QtMultimedia.QMediaTimeRange:
-    "PySide2.QtMultimedia.QMediaTimeRange.__init__": [(), ('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.__add__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.__copy__": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.__iadd__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__isub__": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('PySide2.QtMultimedia.QMediaTimeRange',)],
-    "PySide2.QtMultimedia.QMediaTimeRange.__sub__": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.addInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.addTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-    "PySide2.QtMultimedia.QMediaTimeRange.clear": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.contains": ('int',),
-    "PySide2.QtMultimedia.QMediaTimeRange.earliestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.intervals": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isContinuous": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.isEmpty": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.latestTime": (),
-    "PySide2.QtMultimedia.QMediaTimeRange.removeInterval": [('PySide2.QtMultimedia.QMediaTimeInterval',), ('int', 'int')],
-    "PySide2.QtMultimedia.QMediaTimeRange.removeTimeRange": ('PySide2.QtMultimedia.QMediaTimeRange',),
-# class PySide2.QtMultimedia.QMediaVideoProbeControl:
-    "PySide2.QtMultimedia.QMediaVideoProbeControl.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.QtMultimedia.QMetaDataReaderControl:
-    "PySide2.QtMultimedia.QMetaDataReaderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataReaderControl.metaData": ('str',),
-# class PySide2.QtMultimedia.QMetaDataWriterControl:
-    "PySide2.QtMultimedia.QMetaDataWriterControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.availableMetaData": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isMetaDataAvailable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.isWritable": (),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.metaData": ('str',),
-    "PySide2.QtMultimedia.QMetaDataWriterControl.setMetaData": ('str', 'typing.Any'),
-# class PySide2.QtMultimedia.QMultimedia:
-# class PySide2.QtMultimedia.QMultimedia.AvailabilityStatus:
-# class PySide2.QtMultimedia.QMultimedia.EncodingMode:
-# class PySide2.QtMultimedia.QMultimedia.EncodingQuality:
-# class PySide2.QtMultimedia.QMultimedia.SupportEstimate:
-# class PySide2.QtMultimedia.QRadioData:
-# class PySide2.QtMultimedia.QRadioData.Error:
-# class PySide2.QtMultimedia.QRadioData.ProgramType:
-    "PySide2.QtMultimedia.QRadioData.__init__": ('PySide2.QtMultimedia.QMediaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QRadioData.availability": (),
-    "PySide2.QtMultimedia.QRadioData.error": (),
-    "PySide2.QtMultimedia.QRadioData.errorString": (),
-    "PySide2.QtMultimedia.QRadioData.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioData.mediaObject": (),
-    "PySide2.QtMultimedia.QRadioData.programType": (),
-    "PySide2.QtMultimedia.QRadioData.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioData.radioText": (),
-    "PySide2.QtMultimedia.QRadioData.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioData.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimedia.QRadioData.stationId": (),
-    "PySide2.QtMultimedia.QRadioData.stationName": (),
-# class PySide2.QtMultimedia.QRadioDataControl:
-    "PySide2.QtMultimedia.QRadioDataControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioDataControl.error": (),
-    "PySide2.QtMultimedia.QRadioDataControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioDataControl.isAlternativeFrequenciesEnabled": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programType": (),
-    "PySide2.QtMultimedia.QRadioDataControl.programTypeName": (),
-    "PySide2.QtMultimedia.QRadioDataControl.radioText": (),
-    "PySide2.QtMultimedia.QRadioDataControl.setAlternativeFrequenciesEnabled": ('bool',),
-    "PySide2.QtMultimedia.QRadioDataControl.stationId": (),
-    "PySide2.QtMultimedia.QRadioDataControl.stationName": (),
-# class PySide2.QtMultimedia.QRadioTuner:
-# class PySide2.QtMultimedia.QRadioTuner.Band:
-# class PySide2.QtMultimedia.QRadioTuner.Error:
-# class PySide2.QtMultimedia.QRadioTuner.SearchMode:
-# class PySide2.QtMultimedia.QRadioTuner.State:
-# class PySide2.QtMultimedia.QRadioTuner.StereoMode:
-    "PySide2.QtMultimedia.QRadioTuner.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTuner.availability": (),
-    "PySide2.QtMultimedia.QRadioTuner.band": (),
-    "PySide2.QtMultimedia.QRadioTuner.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTuner.error": (),
-    "PySide2.QtMultimedia.QRadioTuner.errorString": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequency": (),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTuner.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTuner.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTuner.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTuner.radioData": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTuner.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTuner.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTuner.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTuner.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTuner.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTuner.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTuner.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTuner.start": (),
-    "PySide2.QtMultimedia.QRadioTuner.state": (),
-    "PySide2.QtMultimedia.QRadioTuner.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTuner.stop": (),
-    "PySide2.QtMultimedia.QRadioTuner.volume": (),
-# class PySide2.QtMultimedia.QRadioTunerControl:
-    "PySide2.QtMultimedia.QRadioTunerControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QRadioTunerControl.band": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.cancelSearch": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.error": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.errorString": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequency": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyRange": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.frequencyStep": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isAntennaConnected": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isBandSupported": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.isMuted": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isSearching": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.isStereo": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchAllStations": ('PySide2.QtMultimedia.QRadioTuner.SearchMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchBackward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.searchForward": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.setBand": ('PySide2.QtMultimedia.QRadioTuner.Band',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setFrequency": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setStereoMode": ('PySide2.QtMultimedia.QRadioTuner.StereoMode',),
-    "PySide2.QtMultimedia.QRadioTunerControl.setVolume": ('int',),
-    "PySide2.QtMultimedia.QRadioTunerControl.signalStrength": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.start": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.state": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stereoMode": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.stop": (),
-    "PySide2.QtMultimedia.QRadioTunerControl.volume": (),
-# class PySide2.QtMultimedia.QSound:
-# class PySide2.QtMultimedia.QSound.Loop:
-    "PySide2.QtMultimedia.QSound.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtMultimedia.QSound.fileName": (),
-    "PySide2.QtMultimedia.QSound.isFinished": (),
-    "PySide2.QtMultimedia.QSound.loops": (),
-    "PySide2.QtMultimedia.QSound.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSound.play": [(), ('str',)],
-    "PySide2.QtMultimedia.QSound.setLoops": ('int',),
-    "PySide2.QtMultimedia.QSound.stop": (),
-# class PySide2.QtMultimedia.QSoundEffect:
-# class PySide2.QtMultimedia.QSoundEffect.Loop:
-# class PySide2.QtMultimedia.QSoundEffect.Status:
-    "PySide2.QtMultimedia.QSoundEffect.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtMultimedia.QAudioDeviceInfo', 'PySide2.QtCore.QObject')],
-    "PySide2.QtMultimedia.QSoundEffect.category": (),
-    "PySide2.QtMultimedia.QSoundEffect.isLoaded": (),
-    "PySide2.QtMultimedia.QSoundEffect.isMuted": (),
-    "PySide2.QtMultimedia.QSoundEffect.isPlaying": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopCount": (),
-    "PySide2.QtMultimedia.QSoundEffect.loopsRemaining": (),
-    "PySide2.QtMultimedia.QSoundEffect.play": (),
-    "PySide2.QtMultimedia.QSoundEffect.setCategory": ('str',),
-    "PySide2.QtMultimedia.QSoundEffect.setLoopCount": ('int',),
-    "PySide2.QtMultimedia.QSoundEffect.setMuted": ('bool',),
-    "PySide2.QtMultimedia.QSoundEffect.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtMultimedia.QSoundEffect.setVolume": ('float',),
-    "PySide2.QtMultimedia.QSoundEffect.source": (),
-    "PySide2.QtMultimedia.QSoundEffect.status": (),
-    "PySide2.QtMultimedia.QSoundEffect.stop": (),
-    "PySide2.QtMultimedia.QSoundEffect.supportedMimeTypes": (),
-    "PySide2.QtMultimedia.QSoundEffect.volume": (),
-# class PySide2.QtMultimedia.QVideoDeviceSelectorControl:
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.defaultDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceCount": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceDescription": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.deviceName": ('int',),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.selectedDevice": (),
-    "PySide2.QtMultimedia.QVideoDeviceSelectorControl.setSelectedDevice": ('int',),
-# class PySide2.QtMultimedia.QVideoEncoderSettings:
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__init__": [(), ('PySide2.QtMultimedia.QVideoEncoderSettings',)],
-    "PySide2.QtMultimedia.QVideoEncoderSettings.__copy__": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.bitRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.codec": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingMode": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOption": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.encodingOptions": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.frameRate": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.isNull": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.quality": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.resolution": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setBitRate": ('int',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setCodec": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingMode": ('PySide2.QtMultimedia.QMultimedia.EncodingMode',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOption": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setEncodingOptions": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setQuality": ('PySide2.QtMultimedia.QMultimedia.EncodingQuality',),
-    "PySide2.QtMultimedia.QVideoEncoderSettings.setResolution": [('PySide2.QtCore.QSize',), ('int', 'int')],
-# class PySide2.QtMultimedia.QVideoEncoderSettingsControl:
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.setVideoSettings": ('PySide2.QtMultimedia.QVideoEncoderSettings',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.supportedVideoCodecs": (),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoCodecDescription": ('str',),
-    "PySide2.QtMultimedia.QVideoEncoderSettingsControl.videoSettings": (),
-# class PySide2.QtMultimedia.QVideoFilterRunnable:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlag:
-# class PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags:
-    "PySide2.QtMultimedia.QVideoFilterRunnable.__init__": (),
-    "PySide2.QtMultimedia.QVideoFilterRunnable.run": ('PySide2.QtMultimedia.QVideoFrame', 'PySide2.QtMultimedia.QVideoSurfaceFormat', 'PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags'),
-# class PySide2.QtMultimedia.QVideoFrame:
-# class PySide2.QtMultimedia.QVideoFrame.FieldType:
-# class PySide2.QtMultimedia.QVideoFrame.PixelFormat:
-    "PySide2.QtMultimedia.QVideoFrame.__init__": [(), ('PySide2.QtGui.QImage',), ('PySide2.QtMultimedia.QAbstractVideoBuffer', 'PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat'), ('PySide2.QtMultimedia.QVideoFrame',), ('int', 'PySide2.QtCore.QSize', 'int', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat')],
-    "PySide2.QtMultimedia.QVideoFrame.__copy__": (),
-    "PySide2.QtMultimedia.QVideoFrame.availableMetaData": (),
-    "PySide2.QtMultimedia.QVideoFrame.bits": (),
-    "PySide2.QtMultimedia.QVideoFrame.buffer": (),
-    "PySide2.QtMultimedia.QVideoFrame.bytesPerLine": [(), ('int',)],
-    "PySide2.QtMultimedia.QVideoFrame.endTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.fieldType": (),
-    "PySide2.QtMultimedia.QVideoFrame.handle": (),
-    "PySide2.QtMultimedia.QVideoFrame.handleType": (),
-    "PySide2.QtMultimedia.QVideoFrame.height": (),
-    "PySide2.QtMultimedia.QVideoFrame.imageFormatFromPixelFormat": ('PySide2.QtMultimedia.QVideoFrame.PixelFormat',),
-    "PySide2.QtMultimedia.QVideoFrame.isMapped": (),
-    "PySide2.QtMultimedia.QVideoFrame.isReadable": (),
-    "PySide2.QtMultimedia.QVideoFrame.isValid": (),
-    "PySide2.QtMultimedia.QVideoFrame.isWritable": (),
-    "PySide2.QtMultimedia.QVideoFrame.map": ('PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode',),
-    "PySide2.QtMultimedia.QVideoFrame.mapMode": (),
-    "PySide2.QtMultimedia.QVideoFrame.mappedBytes": (),
-    "PySide2.QtMultimedia.QVideoFrame.metaData": ('str',),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoFrame.pixelFormatFromImageFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtMultimedia.QVideoFrame.planeCount": (),
-    "PySide2.QtMultimedia.QVideoFrame.setEndTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.setFieldType": ('PySide2.QtMultimedia.QVideoFrame.FieldType',),
-    "PySide2.QtMultimedia.QVideoFrame.setMetaData": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoFrame.setStartTime": ('int',),
-    "PySide2.QtMultimedia.QVideoFrame.size": (),
-    "PySide2.QtMultimedia.QVideoFrame.startTime": (),
-    "PySide2.QtMultimedia.QVideoFrame.unmap": (),
-    "PySide2.QtMultimedia.QVideoFrame.width": (),
-# class PySide2.QtMultimedia.QVideoProbe:
-    "PySide2.QtMultimedia.QVideoProbe.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoProbe.isActive": (),
-    "PySide2.QtMultimedia.QVideoProbe.setSource": [('PySide2.QtMultimedia.QMediaObject',), ('PySide2.QtMultimedia.QMediaRecorder',)],
-# class PySide2.QtMultimedia.QVideoRendererControl:
-    "PySide2.QtMultimedia.QVideoRendererControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoRendererControl.setSurface": ('PySide2.QtMultimedia.QAbstractVideoSurface',),
-    "PySide2.QtMultimedia.QVideoRendererControl.surface": (),
-# class PySide2.QtMultimedia.QVideoSurfaceFormat:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.Direction:
-# class PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace:
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__init__": [(), ('PySide2.QtCore.QSize', 'PySide2.QtMultimedia.QVideoFrame.PixelFormat', 'PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType'), ('PySide2.QtMultimedia.QVideoSurfaceFormat',)],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.__copy__": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameHeight": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameRate": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameSize": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.frameWidth": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.handleType": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isMirrored": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.isValid": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelAspectRatio": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.pixelFormat": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.property": ('str',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.propertyNames": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.scanLineDirection": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameRate": ('float',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setFrameSize": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setMirrored": ('bool',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setPixelAspectRatio": [('PySide2.QtCore.QSize',), ('int', 'int')],
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setProperty": ('str', 'typing.Any'),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setScanLineDirection": ('PySide2.QtMultimedia.QVideoSurfaceFormat.Direction',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.setYCbCrColorSpace": ('PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace',),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.sizeHint": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.viewport": (),
-    "PySide2.QtMultimedia.QVideoSurfaceFormat.yCbCrColorSpace": (),
-# class PySide2.QtMultimedia.QVideoWindowControl:
-    "PySide2.QtMultimedia.QVideoWindowControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimedia.QVideoWindowControl.aspectRatioMode": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.brightness": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.contrast": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.displayRect": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.hue": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.isFullScreen": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.nativeSize": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.repaint": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.saturation": (),
-    "PySide2.QtMultimedia.QVideoWindowControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setBrightness": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setContrast": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setDisplayRect": ('PySide2.QtCore.QRect',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setHue": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setSaturation": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.setWinId": ('int',),
-    "PySide2.QtMultimedia.QVideoWindowControl.winId": (),
-    }) if "PySide2.QtMultimedia" in sys.modules else None
-# Module PySide2.QtMultimediaWidgets
-sig_dict.update({
-# class PySide2.QtMultimediaWidgets.QCameraViewfinder:
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QCameraViewfinder.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-# class PySide2.QtMultimediaWidgets.QGraphicsVideoItem:
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.__init__": ('PySide2.QtWidgets.QGraphicsItem',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.boundingRect": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.itemChange": ('PySide2.QtWidgets.QGraphicsItem.GraphicsItemChange', 'typing.Any'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.nativeSize": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.offset": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setOffset": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.size": (),
-    "PySide2.QtMultimediaWidgets.QGraphicsVideoItem.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtMultimediaWidgets.QVideoWidget:
-    "PySide2.QtMultimediaWidgets.QVideoWidget.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.mediaObject": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.moveEvent": ('PySide2.QtGui.QMoveEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setMediaObject": ('PySide2.QtMultimedia.QMediaObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtMultimediaWidgets.QVideoWidget.sizeHint": (),
-# class PySide2.QtMultimediaWidgets.QVideoWidgetControl:
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.aspectRatioMode": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.brightness": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.contrast": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.hue": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.isFullScreen": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.saturation": (),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setAspectRatioMode": ('PySide2.QtCore.Qt.AspectRatioMode',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setBrightness": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setContrast": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setFullScreen": ('bool',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setHue": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.setSaturation": ('int',),
-    "PySide2.QtMultimediaWidgets.QVideoWidgetControl.videoWidget": (),
-    }) if "PySide2.QtMultimediaWidgets" in sys.modules else None
-# Module PySide2.QtOpenGL
-sig_dict.update({
-# class PySide2.QtOpenGL.QGL:
-# class PySide2.QtOpenGL.QGL.FormatOption:
-# class PySide2.QtOpenGL.QGL.FormatOptions:
-# class PySide2.QtOpenGL.QGLBuffer:
-# class PySide2.QtOpenGL.QGLBuffer.Access:
-# class PySide2.QtOpenGL.QGLBuffer.Type:
-# class PySide2.QtOpenGL.QGLBuffer.UsagePattern:
-    "PySide2.QtOpenGL.QGLBuffer.__init__": [(), ('PySide2.QtOpenGL.QGLBuffer',), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.allocate": [('int',), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLBuffer.bind": (),
-    "PySide2.QtOpenGL.QGLBuffer.bufferId": (),
-    "PySide2.QtOpenGL.QGLBuffer.create": (),
-    "PySide2.QtOpenGL.QGLBuffer.destroy": (),
-    "PySide2.QtOpenGL.QGLBuffer.isCreated": (),
-    "PySide2.QtOpenGL.QGLBuffer.map": ('PySide2.QtOpenGL.QGLBuffer.Access',),
-    "PySide2.QtOpenGL.QGLBuffer.read": ('int', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLBuffer.release": [(), ('PySide2.QtOpenGL.QGLBuffer.Type',)],
-    "PySide2.QtOpenGL.QGLBuffer.setUsagePattern": ('PySide2.QtOpenGL.QGLBuffer.UsagePattern',),
-    "PySide2.QtOpenGL.QGLBuffer.size": (),
-    "PySide2.QtOpenGL.QGLBuffer.type": (),
-    "PySide2.QtOpenGL.QGLBuffer.unmap": (),
-    "PySide2.QtOpenGL.QGLBuffer.usagePattern": (),
-    "PySide2.QtOpenGL.QGLBuffer.write": ('int', 'int', 'int'),
-# class PySide2.QtOpenGL.QGLColormap:
-    "PySide2.QtOpenGL.QGLColormap.__init__": [(), ('PySide2.QtOpenGL.QGLColormap',)],
-    "PySide2.QtOpenGL.QGLColormap.__copy__": (),
-    "PySide2.QtOpenGL.QGLColormap.entryColor": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.entryRgb": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.find": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.findNearest": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.handle": (),
-    "PySide2.QtOpenGL.QGLColormap.isEmpty": (),
-    "PySide2.QtOpenGL.QGLColormap.setEntry": [('int', 'PySide2.QtGui.QColor'), ('int', 'int')],
-    "PySide2.QtOpenGL.QGLColormap.setHandle": ('int',),
-    "PySide2.QtOpenGL.QGLColormap.size": (),
-# class PySide2.QtOpenGL.QGLContext:
-# class PySide2.QtOpenGL.QGLContext.BindOption:
-# class PySide2.QtOpenGL.QGLContext.BindOptions:
-    "PySide2.QtOpenGL.QGLContext.__init__": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.areSharing": ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLContext.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLContext.chooseContext": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.colorIndex": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLContext.contextHandle": (),
-    "PySide2.QtOpenGL.QGLContext.create": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLContext.currentContext": (),
-    "PySide2.QtOpenGL.QGLContext.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLContext.device": (),
-    "PySide2.QtOpenGL.QGLContext.deviceIsPixmap": (),
-    "PySide2.QtOpenGL.QGLContext.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLContext.format": (),
-    "PySide2.QtOpenGL.QGLContext.fromOpenGLContext": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtOpenGL.QGLContext.initialized": (),
-    "PySide2.QtOpenGL.QGLContext.isSharing": (),
-    "PySide2.QtOpenGL.QGLContext.isValid": (),
-    "PySide2.QtOpenGL.QGLContext.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLContext.moveToThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtOpenGL.QGLContext.overlayTransparentColor": (),
-    "PySide2.QtOpenGL.QGLContext.requestedFormat": (),
-    "PySide2.QtOpenGL.QGLContext.reset": (),
-    "PySide2.QtOpenGL.QGLContext.setDevice": ('PySide2.QtGui.QPaintDevice',),
-    "PySide2.QtOpenGL.QGLContext.setFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLContext.setInitialized": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setTextureCacheLimit": ('int',),
-    "PySide2.QtOpenGL.QGLContext.setValid": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.setWindowCreated": ('bool',),
-    "PySide2.QtOpenGL.QGLContext.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLContext.textureCacheLimit": (),
-    "PySide2.QtOpenGL.QGLContext.windowCreated": (),
-# class PySide2.QtOpenGL.QGLFormat:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlag:
-# class PySide2.QtOpenGL.QGLFormat.OpenGLVersionFlags:
-    "PySide2.QtOpenGL.QGLFormat.__init__": [(), ('PySide2.QtOpenGL.QGL.FormatOptions', 'int'), ('PySide2.QtOpenGL.QGLFormat',)],
-    "PySide2.QtOpenGL.QGLFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFormat.accum": (),
-    "PySide2.QtOpenGL.QGLFormat.accumBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.alpha": (),
-    "PySide2.QtOpenGL.QGLFormat.alphaBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.blueBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.defaultOverlayFormat": (),
-    "PySide2.QtOpenGL.QGLFormat.depth": (),
-    "PySide2.QtOpenGL.QGLFormat.depthBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.directRendering": (),
-    "PySide2.QtOpenGL.QGLFormat.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLFormat.fromSurfaceFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtOpenGL.QGLFormat.greenBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGL": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOpenGLOverlays": (),
-    "PySide2.QtOpenGL.QGLFormat.hasOverlay": (),
-    "PySide2.QtOpenGL.QGLFormat.majorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.minorVersion": (),
-    "PySide2.QtOpenGL.QGLFormat.openGLVersionFlags": (),
-    "PySide2.QtOpenGL.QGLFormat.plane": (),
-    "PySide2.QtOpenGL.QGLFormat.profile": (),
-    "PySide2.QtOpenGL.QGLFormat.redBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.rgba": (),
-    "PySide2.QtOpenGL.QGLFormat.sampleBuffers": (),
-    "PySide2.QtOpenGL.QGLFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFormat.setAccum": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAccumBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setAlpha": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setAlphaBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setBlueBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDefaultOverlayFormat": ('PySide2.QtOpenGL.QGLFormat',),
-    "PySide2.QtOpenGL.QGLFormat.setDepth": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDepthBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setDirectRendering": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setDoubleBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setGreenBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.setOverlay": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setPlane": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setProfile": ('PySide2.QtOpenGL.QGLFormat.OpenGLContextProfile',),
-    "PySide2.QtOpenGL.QGLFormat.setRedBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setRgba": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSampleBuffers": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStencil": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setStencilBufferSize": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setStereo": ('bool',),
-    "PySide2.QtOpenGL.QGLFormat.setSwapInterval": ('int',),
-    "PySide2.QtOpenGL.QGLFormat.setVersion": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLFormat.stencil": (),
-    "PySide2.QtOpenGL.QGLFormat.stencilBufferSize": (),
-    "PySide2.QtOpenGL.QGLFormat.stereo": (),
-    "PySide2.QtOpenGL.QGLFormat.swapInterval": (),
-    "PySide2.QtOpenGL.QGLFormat.testOption": ('PySide2.QtOpenGL.QGL.FormatOptions',),
-    "PySide2.QtOpenGL.QGLFormat.toSurfaceFormat": ('PySide2.QtOpenGL.QGLFormat',),
-# class PySide2.QtOpenGL.QGLFramebufferObject:
-# class PySide2.QtOpenGL.QGLFramebufferObject.Attachment:
-    "PySide2.QtOpenGL.QGLFramebufferObject.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('PySide2.QtCore.QSize', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObject.Attachment', 'int', 'int'), ('int', 'int', 'PySide2.QtOpenGL.QGLFramebufferObjectFormat'), ('int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bind": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.bindDefault": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.blitFramebuffer": ('PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'PySide2.QtOpenGL.QGLFramebufferObject', 'PySide2.QtCore.QRect', 'int', 'int'),
-    "PySide2.QtOpenGL.QGLFramebufferObject.devType": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLFramebufferObject.format": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.handle": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferBlit": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.hasOpenGLFramebufferObjects": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isBound": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.isValid": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLFramebufferObject.paintEngine": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.release": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.size": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.texture": (),
-    "PySide2.QtOpenGL.QGLFramebufferObject.toImage": (),
-# class PySide2.QtOpenGL.QGLFramebufferObjectFormat:
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__init__": [(), ('PySide2.QtOpenGL.QGLFramebufferObjectFormat',)],
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.__copy__": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.attachment": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.internalTextureFormat": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.mipmap": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.samples": (),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setAttachment": ('PySide2.QtOpenGL.QGLFramebufferObject.Attachment',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setInternalTextureFormat": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setMipmap": ('bool',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setSamples": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.setTextureTarget": ('int',),
-    "PySide2.QtOpenGL.QGLFramebufferObjectFormat.textureTarget": (),
-# class PySide2.QtOpenGL.QGLPixelBuffer:
-    "PySide2.QtOpenGL.QGLPixelBuffer.__init__": [('PySide2.QtCore.QSize', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget'), ('int', 'int', 'PySide2.QtOpenGL.QGLFormat', 'PySide2.QtOpenGL.QGLWidget')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindTexture": [('PySide2.QtGui.QImage', 'int'), ('PySide2.QtGui.QPixmap', 'int'), ('str',)],
-    "PySide2.QtOpenGL.QGLPixelBuffer.bindToDynamicTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.context": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.devType": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLPixelBuffer.format": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.generateDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.handle": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.hasOpenGLPbuffers": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.isValid": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtOpenGL.QGLPixelBuffer.paintEngine": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.releaseFromDynamicTexture": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.size": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.toImage": (),
-    "PySide2.QtOpenGL.QGLPixelBuffer.updateDynamicTexture": ('int',),
-# class PySide2.QtOpenGL.QGLShader:
-# class PySide2.QtOpenGL.QGLShader.ShaderType:
-# class PySide2.QtOpenGL.QGLShader.ShaderTypeBit:
-    "PySide2.QtOpenGL.QGLShader.__init__": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QObject'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShader.compileSourceCode": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShader.compileSourceFile": ('str',),
-    "PySide2.QtOpenGL.QGLShader.hasOpenGLShaders": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtOpenGL.QGLContext'),
-    "PySide2.QtOpenGL.QGLShader.isCompiled": (),
-    "PySide2.QtOpenGL.QGLShader.log": (),
-    "PySide2.QtOpenGL.QGLShader.shaderId": (),
-    "PySide2.QtOpenGL.QGLShader.shaderType": (),
-    "PySide2.QtOpenGL.QGLShader.sourceCode": (),
-# class PySide2.QtOpenGL.QGLShaderProgram:
-    "PySide2.QtOpenGL.QGLShaderProgram.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtOpenGL.QGLContext', 'PySide2.QtCore.QObject')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceCode": [('PySide2.QtOpenGL.QGLShader.ShaderType', 'PySide2.QtCore.QByteArray'), ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str')],
-    "PySide2.QtOpenGL.QGLShaderProgram.addShaderFromSourceFile": ('PySide2.QtOpenGL.QGLShader.ShaderType', 'str'),
-    "PySide2.QtOpenGL.QGLShaderProgram.attributeLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.bind": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.bindAttributeLocation": [('PySide2.QtCore.QByteArray', 'int'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.disableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.enableAttributeArray": [('int',), ('str',)],
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryInputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputType": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.geometryOutputVertexCount": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.hasOpenGLShaderPrograms": ('PySide2.QtOpenGL.QGLContext',),
-    "PySide2.QtOpenGL.QGLShaderProgram.isLinked": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.link": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.log": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.maxGeometryOutputVertices": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.programId": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.release": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeAllShaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.removeShader": ('PySide2.QtOpenGL.QGLShader',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeBuffer": [('int', 'int', 'int', 'int', 'int'), ('str', 'int', 'int', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setAttributeValue": [('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryInputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputType": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setGeometryOutputVertexCount": ('int',),
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValue": [('int', 'PySide2.QtCore.QPoint'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'PySide2.QtCore.QSize'), ('int', 'PySide2.QtCore.QSizeF'), ('int', 'PySide2.QtGui.QColor'), ('int', 'PySide2.QtGui.QMatrix2x2'), ('int', 'PySide2.QtGui.QMatrix2x3'), ('int', 'PySide2.QtGui.QMatrix2x4'), ('int', 'PySide2.QtGui.QMatrix3x2'), ('int', 'PySide2.QtGui.QMatrix3x3'), ('int', 'PySide2.QtGui.QMatrix3x4'), ('int', 'PySide2.QtGui.QMatrix4x2'), ('int', 'PySide2.QtGui.QMatrix4x3'), ('int', 'PySide2.QtGui.QMatrix4x4'), ('int', 'PySide2.QtGui.QTransform'), ('int', 'PySide2.QtGui.QVector2D'), ('int', 'PySide2.QtGui.QVector3D'), ('int', 'PySide2.QtGui.QVector4D'), ('int', 'float'), ('int', 'float', 'float'), ('int', 'float', 'float', 'float'), ('int', 'float', 'float', 'float', 'float'), ('int', 'int'), ('str', 'PySide2.QtCore.QPoint'), ('str', 'PySide2.QtCore.QPointF'), ('str', 'PySide2.QtCore.QSize'), ('str', 'PySide2.QtCore.QSizeF'), ('str', 'PySide2.QtGui.QColor'), ('str', 'PySide2.QtGui.QMatrix2x2'), ('str', 'PySide2.QtGui.QMatrix2x3'), ('str', 'PySide2.QtGui.QMatrix2x4'), ('str', 'PySide2.QtGui.QMatrix3x2'), ('str', 'PySide2.QtGui.QMatrix3x3'), ('str', 'PySide2.QtGui.QMatrix3x4'), ('str', 'PySide2.QtGui.QMatrix4x2'), ('str', 'PySide2.QtGui.QMatrix4x3'), ('str', 'PySide2.QtGui.QMatrix4x4'), ('str', 'PySide2.QtGui.QTransform'), ('str', 'PySide2.QtGui.QVector2D'), ('str', 'PySide2.QtGui.QVector3D'), ('str', 'PySide2.QtGui.QVector4D'), ('str', 'float'), ('str', 'float', 'float'), ('str', 'float', 'float', 'float'), ('str', 'float', 'float', 'float', 'float'), ('str', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2D": [('int', 'PySide2.QtGui.QVector2D', 'int'), ('str', 'PySide2.QtGui.QVector2D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x2": [('int', 'PySide2.QtGui.QMatrix2x2', 'int'), ('str', 'PySide2.QtGui.QMatrix2x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x3": [('int', 'PySide2.QtGui.QMatrix2x3', 'int'), ('str', 'PySide2.QtGui.QMatrix2x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray2x4": [('int', 'PySide2.QtGui.QMatrix2x4', 'int'), ('str', 'PySide2.QtGui.QMatrix2x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3D": [('int', 'PySide2.QtGui.QVector3D', 'int'), ('str', 'PySide2.QtGui.QVector3D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x2": [('int', 'PySide2.QtGui.QMatrix3x2', 'int'), ('str', 'PySide2.QtGui.QMatrix3x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x3": [('int', 'PySide2.QtGui.QMatrix3x3', 'int'), ('str', 'PySide2.QtGui.QMatrix3x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray3x4": [('int', 'PySide2.QtGui.QMatrix3x4', 'int'), ('str', 'PySide2.QtGui.QMatrix3x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4D": [('int', 'PySide2.QtGui.QVector4D', 'int'), ('str', 'PySide2.QtGui.QVector4D', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x2": [('int', 'PySide2.QtGui.QMatrix4x2', 'int'), ('str', 'PySide2.QtGui.QMatrix4x2', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x3": [('int', 'PySide2.QtGui.QMatrix4x3', 'int'), ('str', 'PySide2.QtGui.QMatrix4x3', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArray4x4": [('int', 'PySide2.QtGui.QMatrix4x4', 'int'), ('str', 'PySide2.QtGui.QMatrix4x4', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayInt": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.setUniformValueArrayUint": [('int', 'typing.Sequence[int]', 'int'), ('str', 'typing.Sequence[int]', 'int')],
-    "PySide2.QtOpenGL.QGLShaderProgram.shaders": (),
-    "PySide2.QtOpenGL.QGLShaderProgram.uniformLocation": [('PySide2.QtCore.QByteArray',), ('str',)],
-# class PySide2.QtOpenGL.QGLWidget:
-    "PySide2.QtOpenGL.QGLWidget.__init__": [('PySide2.QtOpenGL.QGLContext', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtOpenGL.QGLFormat', 'PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QWidget', 'PySide2.QtOpenGL.QGLWidget', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtOpenGL.QGLWidget.autoBufferSwap": (),
-    "PySide2.QtOpenGL.QGLWidget.bindTexture": [('PySide2.QtGui.QImage', 'int', 'int'), ('PySide2.QtGui.QImage', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('PySide2.QtGui.QPixmap', 'int', 'int'), ('PySide2.QtGui.QPixmap', 'int', 'int', 'PySide2.QtOpenGL.QGLContext.BindOptions'), ('str',)],
-    "PySide2.QtOpenGL.QGLWidget.colormap": (),
-    "PySide2.QtOpenGL.QGLWidget.context": (),
-    "PySide2.QtOpenGL.QGLWidget.convertToGLFormat": ('PySide2.QtGui.QImage',),
-    "PySide2.QtOpenGL.QGLWidget.deleteTexture": ('int',),
-    "PySide2.QtOpenGL.QGLWidget.doneCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.doubleBuffer": (),
-    "PySide2.QtOpenGL.QGLWidget.drawTexture": [('PySide2.QtCore.QPointF', 'int', 'int'), ('PySide2.QtCore.QRectF', 'int', 'int')],
-    "PySide2.QtOpenGL.QGLWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtOpenGL.QGLWidget.format": (),
-    "PySide2.QtOpenGL.QGLWidget.glDraw": (),
-    "PySide2.QtOpenGL.QGLWidget.glInit": (),
-    "PySide2.QtOpenGL.QGLWidget.grabFrameBuffer": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.initializeGL": (),
-    "PySide2.QtOpenGL.QGLWidget.initializeOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.isSharing": (),
-    "PySide2.QtOpenGL.QGLWidget.isValid": (),
-    "PySide2.QtOpenGL.QGLWidget.makeCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.makeOverlayCurrent": (),
-    "PySide2.QtOpenGL.QGLWidget.overlayContext": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEngine": (),
-    "PySide2.QtOpenGL.QGLWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtOpenGL.QGLWidget.paintGL": (),
-    "PySide2.QtOpenGL.QGLWidget.paintOverlayGL": (),
-    "PySide2.QtOpenGL.QGLWidget.qglClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.qglColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtOpenGL.QGLWidget.renderPixmap": ('int', 'int', 'bool'),
-    "PySide2.QtOpenGL.QGLWidget.renderText": [('float', 'float', 'float', 'str', 'PySide2.QtGui.QFont'), ('int', 'int', 'str', 'PySide2.QtGui.QFont')],
-    "PySide2.QtOpenGL.QGLWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtOpenGL.QGLWidget.resizeGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.resizeOverlayGL": ('int', 'int'),
-    "PySide2.QtOpenGL.QGLWidget.setAutoBufferSwap": ('bool',),
-    "PySide2.QtOpenGL.QGLWidget.setColormap": ('PySide2.QtOpenGL.QGLColormap',),
-    "PySide2.QtOpenGL.QGLWidget.swapBuffers": (),
-    "PySide2.QtOpenGL.QGLWidget.updateGL": (),
-    "PySide2.QtOpenGL.QGLWidget.updateOverlayGL": (),
-    }) if "PySide2.QtOpenGL" in sys.modules else None
-# Module PySide2.QtOpenGLFunctions
-sig_dict.update({
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_2.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_3.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_4.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_1_5.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_2_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_0.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_1.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_3_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_0_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_1_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_2_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_3_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_4_Core.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAccum": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAlphaFunc": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glArrayElement": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBegin": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCallLists": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearAccum": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearIndex": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClientActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glClipPlane": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4b": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ub": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4us": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColor4usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorMaterial": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorSubTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTable": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glColorTableParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glConvolutionParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorSubTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyConvolutionFilter2D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteLists": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawPixels": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlag": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEdgeFlagPointer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableClientState": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEnd": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndList": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh1": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalMesh2": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint1": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glEvalPoint2": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoorddv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogCoordfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFogiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glFrustum": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenLists": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetColorTable": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetConvolutionFilter": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetHistogram": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetMinmax": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnColorTable": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnConvolutionFilter": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnHistogram": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnMinmax": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnSeparableFilter": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glHistogram": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexd": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexdv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexfv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexi": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexs": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexsv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexub": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIndexubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInitNames": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInterleavedArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsList": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModelfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeli": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightModeliv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLighti": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLightiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineStipple": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glListBase": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadIdentity": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLoadTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1d": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap1f": ('int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2d": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMap2f": ('int', 'float', 'float', 'int', 'int', 'float', 'float', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid1f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2d": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapGrid2f": ('int', 'float', 'float', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMateriali": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMaterialiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMatrixMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMinmax": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixd": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultTransposeMatrixf": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoord4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glMultiTexCoordP4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNewList": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormal3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glNormalPointer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glOrtho": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPassThrough": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelMapusv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelTransferi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPixelZoom": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopClientAttrib": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPopName": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPrioritizeTextures": ('int', 'typing.Sequence[int]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushClientAttrib": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushMatrix": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glPushName": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRasterPos4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectd": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectdv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectf": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectfv": ('typing.Sequence[float]', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRecti": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectiv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRects": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRectsv": ('typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderMode": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetHistogram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResetMinmax": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotated": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glRotatef": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScaled": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScalef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3b": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3bv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ub": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ubv": ('str',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3uiv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3us": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColor3usv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSecondaryColorPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glSeparableFilter2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShadeModel": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1d": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1f": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1i": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1s": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord1sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoord4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexCoordPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnvi": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexEnviv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGend": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGendv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGenfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeni": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexGeniv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslated": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glTranslatef": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4d": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4f": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertex4sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexArrayVertexBuffers": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexP4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glVertexPointer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2d": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2f": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos2sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3d": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3dv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3f": ('float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3fv": ('typing.Sequence[float]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3iv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.glWindowPos3sv": ('typing.Sequence[int]',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Compatibility.initializeOpenGLFunctions": (),
-# class PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core:
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.__init__": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveShaderProgram": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glActiveTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glAttachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginConditionalRender": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQuery": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginQueryIndexed": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBeginTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindAttribLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersBase": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindBuffersRange": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFragDataLocationIndexed": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindFramebuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTexture": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindImageTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindRenderbuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSampler": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindSamplers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTexture": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextureUnit": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTextures": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBindVertexBuffers": ('int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquation": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationSeparatei": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendEquationi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunc": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFuncSeparatei": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlendFunci": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glBlitNamedFramebuffer": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckFramebufferStatus": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCheckNamedFramebufferStatus": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClampColor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClear": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearBufferuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearColor": ('float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearDepthf": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedBufferData": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfi": ('int', 'int', 'float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferfv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearNamedFramebufferuiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearStencil": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClearTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glClipControl": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMask": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glColorMaski": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompileShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCompressedTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyImageSubData": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCopyTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateProgram": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCreateShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glCullFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageControl": ('int', 'int', 'int', 'int', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDebugMessageInsert": ('int', 'int', 'int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteFramebuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteProgramPipelines": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteQueries": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteRenderbuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteSamplers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTextures": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteTransformFeedbacks": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDeleteVertexArrays": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthFunc": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRange": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangeIndexed": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDepthRangef": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDetachShader": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDisablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDispatchCompute": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArrays": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysIndirect": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawArraysInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawBuffers": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElements": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsBaseVertex": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsIndirect": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstanced": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawElementsInstancedBaseVertexBaseInstance": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElements": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawRangeElementsBaseVertex": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedback": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackInstanced": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStream": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glDrawTransformFeedbackStreamInstanced": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnable": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexArrayAttrib": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnableVertexAttribArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEnablei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndConditionalRender": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndQueryIndexed": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glEndTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFinish": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFlush": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture1D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTexture3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glFrontFace": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGenerateTextureMipmap": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetAttribLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTexImage": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetCompressedTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetError": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetFragDataLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetGraphicsResetStatus": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetProgramResourceLocationIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetString": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetStringi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineIndex": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetSubroutineUniformLocation": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTexImage": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetTextureSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformBlockIndex": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetUniformLocation": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnCompressedTexImage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glGetnTexImage": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glHint": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateBufferData": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateFramebuffer": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferData": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateNamedFramebufferSubData": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateSubFramebuffer": ('int', 'int', 'typing.Sequence[int]', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexImage": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glInvalidateTexSubImage": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabled": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsEnabledi": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsFramebuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsQuery": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsRenderbuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsSampler": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsShader": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTexture": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsTransformFeedback": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glIsVertexArray": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLineWidth": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLinkProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glLogicOp": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMapNamedBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrier": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMemoryBarrierByRegion": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMinSampleShading": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArrays": ('int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glMultiDrawArraysIndirect": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferData": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedBufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferDrawBuffers": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferReadBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferRenderbuffer": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTexture": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedFramebufferTextureLayer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glNamedRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectLabel": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glObjectPtrLabel": ('int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPatchParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPauseTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStoref": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPixelStorei": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterf": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameterfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteri": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointParameteriv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPointSize": ('float',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonMode": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPolygonOffset": ('float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPopDebugGroup": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPrimitiveRestartIndex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramBinary": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1d": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1f": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2d": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2f": ('int', 'int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3d": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3f": ('int', 'int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4d": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4f": ('int', 'int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4i": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4iv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4ui": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniform4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix2x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix3x4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x2fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3dv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProgramUniformMatrix4x3fv": ('int', 'int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glProvokingVertex": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glPushDebugGroup": ('int', 'int', 'int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glQueryCounter": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReadnPixels": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glReleaseShaderCompiler": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorage": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glRenderbufferStorageMultisample": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glResumeTransformFeedback": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleCoverage": ('float', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSampleMaski": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glSamplerParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissor": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorArrayv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexed": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glScissorIndexedv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderBinary": ('int', 'typing.Sequence[int]', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glShaderStorageBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFunc": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilFuncSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMask": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilMaskSeparate": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOp": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glStencilOpSeparate": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexImage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTexSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBarrier": (),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureBuffer": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterIuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterf": ('int', 'int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameterfv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteri": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureParameteriv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage1D": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2D": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage2DMultisample": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3D": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureStorage3DMultisample": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage1D": ('int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage2D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureSubImage3D": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTextureView": ('int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glTransformFeedbackBufferBase": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform1uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform2uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform3uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4dv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4fv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4iv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniform4uiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformBlockBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix2x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix3x4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x2fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3dv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformMatrix4x3fv": ('int', 'int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUniformSubroutinesuiv": ('int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUnmapNamedBuffer": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glUseProgramStages": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgram": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glValidateProgramPipeline": ('int',),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribBinding": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribFormat": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribIFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayAttribLFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayBindingDivisor": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayElementBuffer": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexArrayVertexBuffers": ('int', 'int', 'int', 'typing.Sequence[int]', 'typing.Sequence[int]', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1f": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1s": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib1sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2f": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2s": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib2sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3f": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3s": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib3sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nbv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Niv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nsv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nub": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nuiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4Nusv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4f": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4fv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4s": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttrib4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribBinding": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribFormat": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1i": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1ui": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI1uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2i": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2ui": ('int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI2uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3i": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI3uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4bv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4i": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4iv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4sv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ubv": ('int', 'str'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4ui": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4uiv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribI4usv": ('int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribIPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1d": ('int', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL1dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2d": ('int', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL2dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3d": ('int', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL3dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4d": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribL4dv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLFormat": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribLPointer": ('int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP1uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP2uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP3uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4ui": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribP4uiv": ('int', 'int', 'int', 'typing.Sequence[int]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexAttribPointer": ('int', 'int', 'int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glVertexBindingDivisor": ('int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewport": ('int', 'int', 'int', 'int'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportArrayv": ('int', 'int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedf": ('int', 'float', 'float', 'float', 'float'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.glViewportIndexedfv": ('int', 'typing.Sequence[float]'),
-    "PySide2.QtOpenGLFunctions.QOpenGLFunctions_4_5_Core.initializeOpenGLFunctions": (),
-    }) if "PySide2.QtOpenGLFunctions" in sys.modules else None
-# Module PySide2.QtPositioning
-sig_dict.update({
-# class PySide2.QtPositioning.QGeoAddress:
-    "PySide2.QtPositioning.QGeoAddress.__init__": [(), ('PySide2.QtPositioning.QGeoAddress',)],
-    "PySide2.QtPositioning.QGeoAddress.__copy__": (),
-    "PySide2.QtPositioning.QGeoAddress.city": (),
-    "PySide2.QtPositioning.QGeoAddress.clear": (),
-    "PySide2.QtPositioning.QGeoAddress.country": (),
-    "PySide2.QtPositioning.QGeoAddress.countryCode": (),
-    "PySide2.QtPositioning.QGeoAddress.county": (),
-    "PySide2.QtPositioning.QGeoAddress.district": (),
-    "PySide2.QtPositioning.QGeoAddress.isEmpty": (),
-    "PySide2.QtPositioning.QGeoAddress.isTextGenerated": (),
-    "PySide2.QtPositioning.QGeoAddress.postalCode": (),
-    "PySide2.QtPositioning.QGeoAddress.setCity": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountry": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCountryCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setCounty": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setDistrict": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setPostalCode": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setState": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setStreet": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.setText": ('str',),
-    "PySide2.QtPositioning.QGeoAddress.state": (),
-    "PySide2.QtPositioning.QGeoAddress.street": (),
-    "PySide2.QtPositioning.QGeoAddress.text": (),
-# class PySide2.QtPositioning.QGeoAreaMonitorInfo:
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__init__": [('PySide2.QtPositioning.QGeoAreaMonitorInfo',), ('str',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.area": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.expiration": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.identifier": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isPersistent": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.name": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.notificationParameters": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setExpiration": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setName": ('str',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setNotificationParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtPositioning.QGeoAreaMonitorInfo.setPersistent": ('bool',),
-# class PySide2.QtPositioning.QGeoAreaMonitorSource:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeature:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.AreaMonitorFeatures:
-# class PySide2.QtPositioning.QGeoAreaMonitorSource.Error:
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.activeMonitors": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createDefaultSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.createSource": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.error": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.positionInfoSource": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.requestUpdate": ('PySide2.QtPositioning.QGeoAreaMonitorInfo', 'str'),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.setPositionInfoSource": ('PySide2.QtPositioning.QGeoPositionInfoSource',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.startMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.stopMonitoring": ('PySide2.QtPositioning.QGeoAreaMonitorInfo',),
-    "PySide2.QtPositioning.QGeoAreaMonitorSource.supportedAreaMonitorFeatures": (),
-# class PySide2.QtPositioning.QGeoCircle:
-    "PySide2.QtPositioning.QGeoCircle.__init__": [(), ('PySide2.QtPositioning.QGeoCircle',), ('PySide2.QtPositioning.QGeoCoordinate', 'float'), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoCircle.__copy__": (),
-    "PySide2.QtPositioning.QGeoCircle.center": (),
-    "PySide2.QtPositioning.QGeoCircle.extendCircle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.radius": (),
-    "PySide2.QtPositioning.QGeoCircle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCircle.setRadius": ('float',),
-    "PySide2.QtPositioning.QGeoCircle.toString": (),
-    "PySide2.QtPositioning.QGeoCircle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoCircle.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoCoordinate:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat:
-# class PySide2.QtPositioning.QGeoCoordinate.CoordinateType:
-    "PySide2.QtPositioning.QGeoCoordinate.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate',), ('float', 'float'), ('float', 'float', 'float')],
-    "PySide2.QtPositioning.QGeoCoordinate.__copy__": (),
-    "PySide2.QtPositioning.QGeoCoordinate.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoCoordinate.altitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.atDistanceAndAzimuth": ('float', 'float', 'float'),
-    "PySide2.QtPositioning.QGeoCoordinate.azimuthTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.distanceTo": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoCoordinate.isValid": (),
-    "PySide2.QtPositioning.QGeoCoordinate.latitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.longitude": (),
-    "PySide2.QtPositioning.QGeoCoordinate.setAltitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLatitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.setLongitude": ('float',),
-    "PySide2.QtPositioning.QGeoCoordinate.toString": ('PySide2.QtPositioning.QGeoCoordinate.CoordinateFormat',),
-    "PySide2.QtPositioning.QGeoCoordinate.type": (),
-# class PySide2.QtPositioning.QGeoLocation:
-    "PySide2.QtPositioning.QGeoLocation.__init__": [(), ('PySide2.QtPositioning.QGeoLocation',)],
-    "PySide2.QtPositioning.QGeoLocation.__copy__": (),
-    "PySide2.QtPositioning.QGeoLocation.address": (),
-    "PySide2.QtPositioning.QGeoLocation.boundingBox": (),
-    "PySide2.QtPositioning.QGeoLocation.coordinate": (),
-    "PySide2.QtPositioning.QGeoLocation.extendedAttributes": (),
-    "PySide2.QtPositioning.QGeoLocation.isEmpty": (),
-    "PySide2.QtPositioning.QGeoLocation.setAddress": ('PySide2.QtPositioning.QGeoAddress',),
-    "PySide2.QtPositioning.QGeoLocation.setBoundingBox": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoLocation.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoLocation.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtPositioning.QGeoPath:
-    "PySide2.QtPositioning.QGeoPath.__init__": [(), ('PySide2.QtPositioning.QGeoPath',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]', 'float')],
-    "PySide2.QtPositioning.QGeoPath.__copy__": (),
-    "PySide2.QtPositioning.QGeoPath.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.clearPath": (),
-    "PySide2.QtPositioning.QGeoPath.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPath.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPath.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPath.path": (),
-    "PySide2.QtPositioning.QGeoPath.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPath.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPath.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPath.setVariantPath": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPath.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoPath.size": (),
-    "PySide2.QtPositioning.QGeoPath.toString": (),
-    "PySide2.QtPositioning.QGeoPath.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPath.variantPath": (),
-    "PySide2.QtPositioning.QGeoPath.width": (),
-# class PySide2.QtPositioning.QGeoPolygon:
-    "PySide2.QtPositioning.QGeoPolygon.__init__": [(), ('PySide2.QtPositioning.QGeoPolygon',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.__copy__": (),
-    "PySide2.QtPositioning.QGeoPolygon.addCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.addHole": [('typing.Any',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoPolygon.containsCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPolygon.coordinateAt": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.hole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holePath": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.holesCount": (),
-    "PySide2.QtPositioning.QGeoPolygon.insertCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.length": ('int', 'int'),
-    "PySide2.QtPositioning.QGeoPolygon.path": (),
-    "PySide2.QtPositioning.QGeoPolygon.perimeter": (),
-    "PySide2.QtPositioning.QGeoPolygon.removeCoordinate": [('PySide2.QtPositioning.QGeoCoordinate',), ('int',)],
-    "PySide2.QtPositioning.QGeoPolygon.removeHole": ('int',),
-    "PySide2.QtPositioning.QGeoPolygon.replaceCoordinate": ('int', 'PySide2.QtPositioning.QGeoCoordinate'),
-    "PySide2.QtPositioning.QGeoPolygon.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtPositioning.QGeoPolygon.setPerimeter": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtPositioning.QGeoPolygon.size": (),
-    "PySide2.QtPositioning.QGeoPolygon.toString": (),
-    "PySide2.QtPositioning.QGeoPolygon.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoPolygon.translated": ('float', 'float'),
-# class PySide2.QtPositioning.QGeoPositionInfo:
-# class PySide2.QtPositioning.QGeoPositionInfo.Attribute:
-    "PySide2.QtPositioning.QGeoPositionInfo.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtCore.QDateTime'), ('PySide2.QtPositioning.QGeoPositionInfo',)],
-    "PySide2.QtPositioning.QGeoPositionInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoPositionInfo.attribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.coordinate": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.hasAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.isValid": (),
-    "PySide2.QtPositioning.QGeoPositionInfo.removeAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setAttribute": ('PySide2.QtPositioning.QGeoPositionInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoPositionInfo.setCoordinate": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoPositionInfo.setTimestamp": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtPositioning.QGeoPositionInfo.timestamp": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSource:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.Error:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethod:
-# class PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods:
-    "PySide2.QtPositioning.QGeoPositionInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.backendProperty": ('str',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.preferredPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setBackendProperty": ('str', 'typing.Any'),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setPreferredPositioningMethods": ('PySide2.QtPositioning.QGeoPositionInfoSource.PositioningMethods',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoPositionInfoSourceFactory:
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.__init__": (),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.areaMonitor": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.positionInfoSource": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoPositionInfoSourceFactory.satelliteInfoSource": ('PySide2.QtCore.QObject',),
-# class PySide2.QtPositioning.QGeoRectangle:
-    "PySide2.QtPositioning.QGeoRectangle.__init__": [(), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('PySide2.QtPositioning.QGeoCoordinate', 'float', 'float'), ('PySide2.QtPositioning.QGeoRectangle',), ('PySide2.QtPositioning.QGeoShape',), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtPositioning.QGeoRectangle.__copy__": (),
-    "PySide2.QtPositioning.QGeoRectangle.__ior__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.__or__": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.bottomLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.bottomRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.center": (),
-    "PySide2.QtPositioning.QGeoRectangle.contains": [('PySide2.QtPositioning.QGeoCoordinate',), ('PySide2.QtPositioning.QGeoRectangle',)],
-    "PySide2.QtPositioning.QGeoRectangle.extendRectangle": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.height": (),
-    "PySide2.QtPositioning.QGeoRectangle.intersects": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setBottomRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setCenter": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setHeight": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopLeft": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setTopRight": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoRectangle.setWidth": ('float',),
-    "PySide2.QtPositioning.QGeoRectangle.toString": (),
-    "PySide2.QtPositioning.QGeoRectangle.topLeft": (),
-    "PySide2.QtPositioning.QGeoRectangle.topRight": (),
-    "PySide2.QtPositioning.QGeoRectangle.translate": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.translated": ('float', 'float'),
-    "PySide2.QtPositioning.QGeoRectangle.united": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtPositioning.QGeoRectangle.width": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfo:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.Attribute:
-# class PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem:
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__init__": [(), ('PySide2.QtPositioning.QGeoSatelliteInfo',)],
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__copy__": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.attribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.hasAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.removeAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteIdentifier": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.satelliteSystem": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setAttribute": ('PySide2.QtPositioning.QGeoSatelliteInfo.Attribute', 'float'),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteIdentifier": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSatelliteSystem": ('PySide2.QtPositioning.QGeoSatelliteInfo.SatelliteSystem',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.setSignalStrength": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfo.signalStrength": (),
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource:
-# class PySide2.QtPositioning.QGeoSatelliteInfoSource.Error:
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.availableSources": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createDefaultSource": [('PySide2.QtCore.QObject',), ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.createSource": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.error": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.sourceName": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QGeoSatelliteInfoSource.updateInterval": (),
-# class PySide2.QtPositioning.QGeoShape:
-# class PySide2.QtPositioning.QGeoShape.ShapeType:
-    "PySide2.QtPositioning.QGeoShape.__init__": [(), ('PySide2.QtPositioning.QGeoShape',)],
-    "PySide2.QtPositioning.QGeoShape.__copy__": (),
-    "PySide2.QtPositioning.QGeoShape.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtPositioning.QGeoShape.boundingGeoRectangle": (),
-    "PySide2.QtPositioning.QGeoShape.center": (),
-    "PySide2.QtPositioning.QGeoShape.contains": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.extendShape": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtPositioning.QGeoShape.isEmpty": (),
-    "PySide2.QtPositioning.QGeoShape.isValid": (),
-    "PySide2.QtPositioning.QGeoShape.toString": (),
-    "PySide2.QtPositioning.QGeoShape.type": (),
-# class PySide2.QtPositioning.QNmeaPositionInfoSource:
-# class PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode:
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.__init__": ('PySide2.QtPositioning.QNmeaPositionInfoSource.UpdateMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.device": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.error": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.lastKnownPosition": ('bool',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.minimumUpdateInterval": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.parsePosInfoFromNmeaData": ('str', 'int', 'PySide2.QtPositioning.QGeoPositionInfo'),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.requestUpdate": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUpdateInterval": ('int',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.setUserEquivalentRangeError": ('float',),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.startUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.stopUpdates": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.supportedPositioningMethods": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.updateMode": (),
-    "PySide2.QtPositioning.QNmeaPositionInfoSource.userEquivalentRangeError": (),
-    }) if "PySide2.QtPositioning" in sys.modules else None
-# Module PySide2.QtLocation
-sig_dict.update({
-# class PySide2.QtLocation.QGeoCodeReply:
-# class PySide2.QtLocation.QGeoCodeReply.Error:
-    "PySide2.QtLocation.QGeoCodeReply.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtLocation.QGeoCodeReply.Error', 'str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoCodeReply.abort": (),
-    "PySide2.QtLocation.QGeoCodeReply.addLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QGeoCodeReply.error": (),
-    "PySide2.QtLocation.QGeoCodeReply.errorString": (),
-    "PySide2.QtLocation.QGeoCodeReply.isFinished": (),
-    "PySide2.QtLocation.QGeoCodeReply.limit": (),
-    "PySide2.QtLocation.QGeoCodeReply.locations": (),
-    "PySide2.QtLocation.QGeoCodeReply.offset": (),
-    "PySide2.QtLocation.QGeoCodeReply.setError": ('PySide2.QtLocation.QGeoCodeReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoCodeReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoCodeReply.setLimit": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setLocations": ('typing.Sequence[PySide2.QtPositioning.QGeoLocation]',),
-    "PySide2.QtLocation.QGeoCodeReply.setOffset": ('int',),
-    "PySide2.QtLocation.QGeoCodeReply.setViewport": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QGeoCodeReply.viewport": (),
-# class PySide2.QtLocation.QGeoCodingManager:
-    "PySide2.QtLocation.QGeoCodingManager.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManager.locale": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManager.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManager.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoCodingManagerEngine:
-    "PySide2.QtLocation.QGeoCodingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.geocode": [('PySide2.QtPositioning.QGeoAddress', 'PySide2.QtPositioning.QGeoShape'), ('str', 'int', 'int', 'PySide2.QtPositioning.QGeoShape')],
-    "PySide2.QtLocation.QGeoCodingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.reverseGeocode": ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoShape'),
-    "PySide2.QtLocation.QGeoCodingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-# class PySide2.QtLocation.QGeoManeuver:
-# class PySide2.QtLocation.QGeoManeuver.InstructionDirection:
-    "PySide2.QtLocation.QGeoManeuver.__init__": [(), ('PySide2.QtLocation.QGeoManeuver',)],
-    "PySide2.QtLocation.QGeoManeuver.__copy__": (),
-    "PySide2.QtLocation.QGeoManeuver.direction": (),
-    "PySide2.QtLocation.QGeoManeuver.distanceToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoManeuver.instructionText": (),
-    "PySide2.QtLocation.QGeoManeuver.isValid": (),
-    "PySide2.QtLocation.QGeoManeuver.position": (),
-    "PySide2.QtLocation.QGeoManeuver.setDirection": ('PySide2.QtLocation.QGeoManeuver.InstructionDirection',),
-    "PySide2.QtLocation.QGeoManeuver.setDistanceToNextInstruction": ('float',),
-    "PySide2.QtLocation.QGeoManeuver.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoManeuver.setInstructionText": ('str',),
-    "PySide2.QtLocation.QGeoManeuver.setPosition": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.setTimeToNextInstruction": ('int',),
-    "PySide2.QtLocation.QGeoManeuver.setWaypoint": ('PySide2.QtPositioning.QGeoCoordinate',),
-    "PySide2.QtLocation.QGeoManeuver.timeToNextInstruction": (),
-    "PySide2.QtLocation.QGeoManeuver.waypoint": (),
-# class PySide2.QtLocation.QGeoRoute:
-    "PySide2.QtLocation.QGeoRoute.__init__": [(), ('PySide2.QtLocation.QGeoRoute',)],
-    "PySide2.QtLocation.QGeoRoute.__copy__": (),
-    "PySide2.QtLocation.QGeoRoute.bounds": (),
-    "PySide2.QtLocation.QGeoRoute.distance": (),
-    "PySide2.QtLocation.QGeoRoute.extendedAttributes": (),
-    "PySide2.QtLocation.QGeoRoute.firstRouteSegment": (),
-    "PySide2.QtLocation.QGeoRoute.path": (),
-    "PySide2.QtLocation.QGeoRoute.request": (),
-    "PySide2.QtLocation.QGeoRoute.routeId": (),
-    "PySide2.QtLocation.QGeoRoute.setBounds": ('PySide2.QtPositioning.QGeoRectangle',),
-    "PySide2.QtLocation.QGeoRoute.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRoute.setExtendedAttributes": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRoute.setFirstRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRoute.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRoute.setRequest": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoute.setRouteId": ('str',),
-    "PySide2.QtLocation.QGeoRoute.setTravelMode": ('PySide2.QtLocation.QGeoRouteRequest.TravelMode',),
-    "PySide2.QtLocation.QGeoRoute.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRoute.travelMode": (),
-    "PySide2.QtLocation.QGeoRoute.travelTime": (),
-# class PySide2.QtLocation.QGeoRouteReply:
-# class PySide2.QtLocation.QGeoRouteReply.Error:
-    "PySide2.QtLocation.QGeoRouteReply.__init__": [('PySide2.QtLocation.QGeoRouteReply.Error', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtLocation.QGeoRouteRequest', 'PySide2.QtCore.QObject')],
-    "PySide2.QtLocation.QGeoRouteReply.abort": (),
-    "PySide2.QtLocation.QGeoRouteReply.addRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-    "PySide2.QtLocation.QGeoRouteReply.error": (),
-    "PySide2.QtLocation.QGeoRouteReply.errorString": (),
-    "PySide2.QtLocation.QGeoRouteReply.isFinished": (),
-    "PySide2.QtLocation.QGeoRouteReply.request": (),
-    "PySide2.QtLocation.QGeoRouteReply.routes": (),
-    "PySide2.QtLocation.QGeoRouteReply.setError": ('PySide2.QtLocation.QGeoRouteReply.Error', 'str'),
-    "PySide2.QtLocation.QGeoRouteReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QGeoRouteReply.setRoutes": ('typing.Sequence[PySide2.QtLocation.QGeoRoute]',),
-# class PySide2.QtLocation.QGeoRouteRequest:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureType:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureTypes:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeight:
-# class PySide2.QtLocation.QGeoRouteRequest.FeatureWeights:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimization:
-# class PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetail:
-# class PySide2.QtLocation.QGeoRouteRequest.SegmentDetails:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelMode:
-# class PySide2.QtLocation.QGeoRouteRequest.TravelModes:
-    "PySide2.QtLocation.QGeoRouteRequest.__init__": [('PySide2.QtLocation.QGeoRouteRequest',), ('PySide2.QtPositioning.QGeoCoordinate', 'PySide2.QtPositioning.QGeoCoordinate'), ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',)],
-    "PySide2.QtLocation.QGeoRouteRequest.departureTime": (),
-    "PySide2.QtLocation.QGeoRouteRequest.excludeAreas": (),
-    "PySide2.QtLocation.QGeoRouteRequest.extraParameters": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureTypes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.featureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType',),
-    "PySide2.QtLocation.QGeoRouteRequest.maneuverDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.numberAlternativeRoutes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.routeOptimization": (),
-    "PySide2.QtLocation.QGeoRouteRequest.segmentDetail": (),
-    "PySide2.QtLocation.QGeoRouteRequest.setDepartureTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExcludeAreas": ('typing.Sequence[PySide2.QtPositioning.QGeoRectangle]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setExtraParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setFeatureWeight": ('PySide2.QtLocation.QGeoRouteRequest.FeatureType', 'PySide2.QtLocation.QGeoRouteRequest.FeatureWeight'),
-    "PySide2.QtLocation.QGeoRouteRequest.setManeuverDetail": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setNumberAlternativeRoutes": ('int',),
-    "PySide2.QtLocation.QGeoRouteRequest.setRouteOptimization": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRouteRequest.setSegmentDetail": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetail',),
-    "PySide2.QtLocation.QGeoRouteRequest.setTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypoints": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteRequest.setWaypointsMetadata": ('typing.Sequence[typing.Dict]',),
-    "PySide2.QtLocation.QGeoRouteRequest.travelModes": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypoints": (),
-    "PySide2.QtLocation.QGeoRouteRequest.waypointsMetadata": (),
-# class PySide2.QtLocation.QGeoRouteSegment:
-    "PySide2.QtLocation.QGeoRouteSegment.__init__": [(), ('PySide2.QtLocation.QGeoRouteSegment',)],
-    "PySide2.QtLocation.QGeoRouteSegment.__copy__": (),
-    "PySide2.QtLocation.QGeoRouteSegment.distance": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isLegLastSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.isValid": (),
-    "PySide2.QtLocation.QGeoRouteSegment.maneuver": (),
-    "PySide2.QtLocation.QGeoRouteSegment.nextRouteSegment": (),
-    "PySide2.QtLocation.QGeoRouteSegment.path": (),
-    "PySide2.QtLocation.QGeoRouteSegment.setDistance": ('float',),
-    "PySide2.QtLocation.QGeoRouteSegment.setManeuver": ('PySide2.QtLocation.QGeoManeuver',),
-    "PySide2.QtLocation.QGeoRouteSegment.setNextRouteSegment": ('PySide2.QtLocation.QGeoRouteSegment',),
-    "PySide2.QtLocation.QGeoRouteSegment.setPath": ('typing.Sequence[PySide2.QtPositioning.QGeoCoordinate]',),
-    "PySide2.QtLocation.QGeoRouteSegment.setTravelTime": ('int',),
-    "PySide2.QtLocation.QGeoRouteSegment.travelTime": (),
-# class PySide2.QtLocation.QGeoRoutingManager:
-    "PySide2.QtLocation.QGeoRoutingManager.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManager.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManager.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManager.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManager.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManager.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManager.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoRoutingManagerEngine:
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.calculateRoute": ('PySide2.QtLocation.QGeoRouteRequest',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.locale": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerName": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.measurementSystem": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setMeasurementSystem": ('PySide2.QtCore.QLocale.MeasurementSystem',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureTypes": ('PySide2.QtLocation.QGeoRouteRequest.FeatureTypes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedFeatureWeights": ('PySide2.QtLocation.QGeoRouteRequest.FeatureWeights',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedManeuverDetails": ('PySide2.QtLocation.QGeoRouteRequest.ManeuverDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedRouteOptimizations": ('PySide2.QtLocation.QGeoRouteRequest.RouteOptimizations',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedSegmentDetails": ('PySide2.QtLocation.QGeoRouteRequest.SegmentDetails',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.setSupportedTravelModes": ('PySide2.QtLocation.QGeoRouteRequest.TravelModes',),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureTypes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedFeatureWeights": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedManeuverDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedRouteOptimizations": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedSegmentDetails": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.supportedTravelModes": (),
-    "PySide2.QtLocation.QGeoRoutingManagerEngine.updateRoute": ('PySide2.QtLocation.QGeoRoute', 'PySide2.QtPositioning.QGeoCoordinate'),
-# class PySide2.QtLocation.QGeoServiceProvider:
-# class PySide2.QtLocation.QGeoServiceProvider.Error:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.GeocodingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.MappingFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.NavigationFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.PlacesFeatures:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeature:
-# class PySide2.QtLocation.QGeoServiceProvider.RoutingFeatures:
-    "PySide2.QtLocation.QGeoServiceProvider.__init__": ('str', 'typing.Dict[str, typing.Any]', 'bool'),
-    "PySide2.QtLocation.QGeoServiceProvider.availableServiceProviders": (),
-    "PySide2.QtLocation.QGeoServiceProvider.error": (),
-    "PySide2.QtLocation.QGeoServiceProvider.errorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.geocodingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.mappingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.navigationFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placeManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.placesFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingError": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingErrorString": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingFeatures": (),
-    "PySide2.QtLocation.QGeoServiceProvider.routingManager": (),
-    "PySide2.QtLocation.QGeoServiceProvider.setAllowExperimental": ('bool',),
-    "PySide2.QtLocation.QGeoServiceProvider.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QGeoServiceProvider.setParameters": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtLocation.QGeoServiceProviderFactory:
-    "PySide2.QtLocation.QGeoServiceProviderFactory.__init__": (),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createGeocodingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createPlaceManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-    "PySide2.QtLocation.QGeoServiceProviderFactory.createRoutingManagerEngine": ('typing.Dict[str, typing.Any]', 'PySide2.QtLocation.QGeoServiceProvider.Error'),
-# class PySide2.QtLocation.QGeoServiceProviderFactoryV2:
-    "PySide2.QtLocation.QGeoServiceProviderFactoryV2.__init__": (),
-# class PySide2.QtLocation.QPlace:
-    "PySide2.QtLocation.QPlace.__init__": [(), ('PySide2.QtLocation.QPlace',)],
-    "PySide2.QtLocation.QPlace.__copy__": (),
-    "PySide2.QtLocation.QPlace.appendContactDetail": ('str', 'PySide2.QtLocation.QPlaceContactDetail'),
-    "PySide2.QtLocation.QPlace.attribution": (),
-    "PySide2.QtLocation.QPlace.categories": (),
-    "PySide2.QtLocation.QPlace.contactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.contactTypes": (),
-    "PySide2.QtLocation.QPlace.content": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlace.detailsFetched": (),
-    "PySide2.QtLocation.QPlace.extendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.extendedAttributeTypes": (),
-    "PySide2.QtLocation.QPlace.icon": (),
-    "PySide2.QtLocation.QPlace.insertContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.isEmpty": (),
-    "PySide2.QtLocation.QPlace.location": (),
-    "PySide2.QtLocation.QPlace.name": (),
-    "PySide2.QtLocation.QPlace.placeId": (),
-    "PySide2.QtLocation.QPlace.primaryEmail": (),
-    "PySide2.QtLocation.QPlace.primaryFax": (),
-    "PySide2.QtLocation.QPlace.primaryPhone": (),
-    "PySide2.QtLocation.QPlace.primaryWebsite": (),
-    "PySide2.QtLocation.QPlace.ratings": (),
-    "PySide2.QtLocation.QPlace.removeContactDetails": ('str',),
-    "PySide2.QtLocation.QPlace.removeExtendedAttribute": ('str',),
-    "PySide2.QtLocation.QPlace.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlace.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlace.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlace.setContactDetails": ('str', 'typing.Sequence[PySide2.QtLocation.QPlaceContactDetail]'),
-    "PySide2.QtLocation.QPlace.setContent": ('PySide2.QtLocation.QPlaceContent.Type', 'typing.Dict[int, PySide2.QtLocation.QPlaceContent]'),
-    "PySide2.QtLocation.QPlace.setDetailsFetched": ('bool',),
-    "PySide2.QtLocation.QPlace.setExtendedAttribute": ('str', 'PySide2.QtLocation.QPlaceAttribute'),
-    "PySide2.QtLocation.QPlace.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlace.setLocation": ('PySide2.QtPositioning.QGeoLocation',),
-    "PySide2.QtLocation.QPlace.setName": ('str',),
-    "PySide2.QtLocation.QPlace.setPlaceId": ('str',),
-    "PySide2.QtLocation.QPlace.setRatings": ('PySide2.QtLocation.QPlaceRatings',),
-    "PySide2.QtLocation.QPlace.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlace.setTotalContentCount": ('PySide2.QtLocation.QPlaceContent.Type', 'int'),
-    "PySide2.QtLocation.QPlace.supplier": (),
-    "PySide2.QtLocation.QPlace.totalContentCount": ('PySide2.QtLocation.QPlaceContent.Type',),
-# class PySide2.QtLocation.QPlaceAttribute:
-    "PySide2.QtLocation.QPlaceAttribute.__init__": [(), ('PySide2.QtLocation.QPlaceAttribute',)],
-    "PySide2.QtLocation.QPlaceAttribute.__copy__": (),
-    "PySide2.QtLocation.QPlaceAttribute.isEmpty": (),
-    "PySide2.QtLocation.QPlaceAttribute.label": (),
-    "PySide2.QtLocation.QPlaceAttribute.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.setText": ('str',),
-    "PySide2.QtLocation.QPlaceAttribute.text": (),
-# class PySide2.QtLocation.QPlaceCategory:
-    "PySide2.QtLocation.QPlaceCategory.__init__": [(), ('PySide2.QtLocation.QPlaceCategory',)],
-    "PySide2.QtLocation.QPlaceCategory.__copy__": (),
-    "PySide2.QtLocation.QPlaceCategory.categoryId": (),
-    "PySide2.QtLocation.QPlaceCategory.icon": (),
-    "PySide2.QtLocation.QPlaceCategory.isEmpty": (),
-    "PySide2.QtLocation.QPlaceCategory.name": (),
-    "PySide2.QtLocation.QPlaceCategory.setCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceCategory.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceCategory.setName": ('str',),
-# class PySide2.QtLocation.QPlaceContactDetail:
-    "PySide2.QtLocation.QPlaceContactDetail.__init__": [(), ('PySide2.QtLocation.QPlaceContactDetail',)],
-    "PySide2.QtLocation.QPlaceContactDetail.__copy__": (),
-    "PySide2.QtLocation.QPlaceContactDetail.clear": (),
-    "PySide2.QtLocation.QPlaceContactDetail.label": (),
-    "PySide2.QtLocation.QPlaceContactDetail.setLabel": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.setValue": ('str',),
-    "PySide2.QtLocation.QPlaceContactDetail.value": (),
-# class PySide2.QtLocation.QPlaceContent:
-# class PySide2.QtLocation.QPlaceContent.Type:
-    "PySide2.QtLocation.QPlaceContent.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceContent.__copy__": (),
-    "PySide2.QtLocation.QPlaceContent.attribution": (),
-    "PySide2.QtLocation.QPlaceContent.setAttribution": ('str',),
-    "PySide2.QtLocation.QPlaceContent.setSupplier": ('PySide2.QtLocation.QPlaceSupplier',),
-    "PySide2.QtLocation.QPlaceContent.setUser": ('PySide2.QtLocation.QPlaceUser',),
-    "PySide2.QtLocation.QPlaceContent.supplier": (),
-    "PySide2.QtLocation.QPlaceContent.type": (),
-    "PySide2.QtLocation.QPlaceContent.user": (),
-# class PySide2.QtLocation.QPlaceContentReply:
-    "PySide2.QtLocation.QPlaceContentReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceContentReply.content": (),
-    "PySide2.QtLocation.QPlaceContentReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceContentReply.request": (),
-    "PySide2.QtLocation.QPlaceContentReply.setContent": ('typing.Dict[int, PySide2.QtLocation.QPlaceContent]',),
-    "PySide2.QtLocation.QPlaceContentReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setRequest": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceContentReply.setTotalCount": ('int',),
-    "PySide2.QtLocation.QPlaceContentReply.totalCount": (),
-    "PySide2.QtLocation.QPlaceContentReply.type": (),
-# class PySide2.QtLocation.QPlaceContentRequest:
-    "PySide2.QtLocation.QPlaceContentRequest.__init__": [(), ('PySide2.QtLocation.QPlaceContentRequest',)],
-    "PySide2.QtLocation.QPlaceContentRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceContentRequest.clear": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentContext": (),
-    "PySide2.QtLocation.QPlaceContentRequest.contentType": (),
-    "PySide2.QtLocation.QPlaceContentRequest.limit": (),
-    "PySide2.QtLocation.QPlaceContentRequest.placeId": (),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceContentRequest.setContentType": ('PySide2.QtLocation.QPlaceContent.Type',),
-    "PySide2.QtLocation.QPlaceContentRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceContentRequest.setPlaceId": ('str',),
-# class PySide2.QtLocation.QPlaceDetailsReply:
-    "PySide2.QtLocation.QPlaceDetailsReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceDetailsReply.place": (),
-    "PySide2.QtLocation.QPlaceDetailsReply.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceDetailsReply.type": (),
-# class PySide2.QtLocation.QPlaceEditorial:
-    "PySide2.QtLocation.QPlaceEditorial.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceEditorial.language": (),
-    "PySide2.QtLocation.QPlaceEditorial.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setText": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceEditorial.text": (),
-    "PySide2.QtLocation.QPlaceEditorial.title": (),
-# class PySide2.QtLocation.QPlaceIcon:
-    "PySide2.QtLocation.QPlaceIcon.__init__": [(), ('PySide2.QtLocation.QPlaceIcon',)],
-    "PySide2.QtLocation.QPlaceIcon.__copy__": (),
-    "PySide2.QtLocation.QPlaceIcon.isEmpty": (),
-    "PySide2.QtLocation.QPlaceIcon.manager": (),
-    "PySide2.QtLocation.QPlaceIcon.parameters": (),
-    "PySide2.QtLocation.QPlaceIcon.setManager": ('PySide2.QtLocation.QPlaceManager',),
-    "PySide2.QtLocation.QPlaceIcon.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceIcon.url": ('PySide2.QtCore.QSize',),
-# class PySide2.QtLocation.QPlaceIdReply:
-# class PySide2.QtLocation.QPlaceIdReply.OperationType:
-    "PySide2.QtLocation.QPlaceIdReply.__init__": ('PySide2.QtLocation.QPlaceIdReply.OperationType', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceIdReply.id": (),
-    "PySide2.QtLocation.QPlaceIdReply.operationType": (),
-    "PySide2.QtLocation.QPlaceIdReply.setId": ('str',),
-    "PySide2.QtLocation.QPlaceIdReply.type": (),
-# class PySide2.QtLocation.QPlaceImage:
-    "PySide2.QtLocation.QPlaceImage.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceImage.imageId": (),
-    "PySide2.QtLocation.QPlaceImage.mimeType": (),
-    "PySide2.QtLocation.QPlaceImage.setImageId": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setMimeType": ('str',),
-    "PySide2.QtLocation.QPlaceImage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceImage.url": (),
-# class PySide2.QtLocation.QPlaceManager:
-    "PySide2.QtLocation.QPlaceManager.category": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManager.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManager.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManager.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManager.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManager.locales": (),
-    "PySide2.QtLocation.QPlaceManager.managerName": (),
-    "PySide2.QtLocation.QPlaceManager.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManager.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManager.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManager.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManager.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManager.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManager.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManager.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtLocation.QPlaceManager.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceManagerEngine:
-    "PySide2.QtLocation.QPlaceManagerEngine.__init__": ('typing.Dict[str, typing.Any]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtLocation.QPlaceManagerEngine.category": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategories": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.childCategoryIds": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.compatiblePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.constructIconUrl": ('PySide2.QtLocation.QPlaceIcon', 'PySide2.QtCore.QSize'),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceContent": ('PySide2.QtLocation.QPlaceContentRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.getPlaceDetails": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.initializeCategories": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.locales": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.manager": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerName": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.managerVersion": (),
-    "PySide2.QtLocation.QPlaceManagerEngine.matchingPlaces": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.parentCategoryId": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removeCategory": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.removePlace": ('str',),
-    "PySide2.QtLocation.QPlaceManagerEngine.saveCategory": ('PySide2.QtLocation.QPlaceCategory', 'str'),
-    "PySide2.QtLocation.QPlaceManagerEngine.savePlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceManagerEngine.search": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.searchSuggestions": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceManagerEngine.setLocales": ('typing.Sequence[PySide2.QtCore.QLocale]',),
-# class PySide2.QtLocation.QPlaceMatchReply:
-    "PySide2.QtLocation.QPlaceMatchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceMatchReply.places": (),
-    "PySide2.QtLocation.QPlaceMatchReply.request": (),
-    "PySide2.QtLocation.QPlaceMatchReply.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchReply.setRequest": ('PySide2.QtLocation.QPlaceMatchRequest',),
-    "PySide2.QtLocation.QPlaceMatchReply.type": (),
-# class PySide2.QtLocation.QPlaceMatchRequest:
-    "PySide2.QtLocation.QPlaceMatchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceMatchRequest',)],
-    "PySide2.QtLocation.QPlaceMatchRequest.__copy__": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.parameters": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.places": (),
-    "PySide2.QtLocation.QPlaceMatchRequest.setParameters": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setPlaces": ('typing.Sequence[PySide2.QtLocation.QPlace]',),
-    "PySide2.QtLocation.QPlaceMatchRequest.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-# class PySide2.QtLocation.QPlaceProposedSearchResult:
-    "PySide2.QtLocation.QPlaceProposedSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceProposedSearchResult.searchRequest": (),
-    "PySide2.QtLocation.QPlaceProposedSearchResult.setSearchRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-# class PySide2.QtLocation.QPlaceRatings:
-    "PySide2.QtLocation.QPlaceRatings.__init__": [(), ('PySide2.QtLocation.QPlaceRatings',)],
-    "PySide2.QtLocation.QPlaceRatings.__copy__": (),
-    "PySide2.QtLocation.QPlaceRatings.average": (),
-    "PySide2.QtLocation.QPlaceRatings.count": (),
-    "PySide2.QtLocation.QPlaceRatings.isEmpty": (),
-    "PySide2.QtLocation.QPlaceRatings.maximum": (),
-    "PySide2.QtLocation.QPlaceRatings.setAverage": ('float',),
-    "PySide2.QtLocation.QPlaceRatings.setCount": ('int',),
-    "PySide2.QtLocation.QPlaceRatings.setMaximum": ('float',),
-# class PySide2.QtLocation.QPlaceReply:
-# class PySide2.QtLocation.QPlaceReply.Error:
-# class PySide2.QtLocation.QPlaceReply.Type:
-    "PySide2.QtLocation.QPlaceReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceReply.abort": (),
-    "PySide2.QtLocation.QPlaceReply.error": (),
-    "PySide2.QtLocation.QPlaceReply.errorString": (),
-    "PySide2.QtLocation.QPlaceReply.isFinished": (),
-    "PySide2.QtLocation.QPlaceReply.setError": ('PySide2.QtLocation.QPlaceReply.Error', 'str'),
-    "PySide2.QtLocation.QPlaceReply.setFinished": ('bool',),
-    "PySide2.QtLocation.QPlaceReply.type": (),
-# class PySide2.QtLocation.QPlaceResult:
-    "PySide2.QtLocation.QPlaceResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceResult.distance": (),
-    "PySide2.QtLocation.QPlaceResult.isSponsored": (),
-    "PySide2.QtLocation.QPlaceResult.place": (),
-    "PySide2.QtLocation.QPlaceResult.setDistance": ('float',),
-    "PySide2.QtLocation.QPlaceResult.setPlace": ('PySide2.QtLocation.QPlace',),
-    "PySide2.QtLocation.QPlaceResult.setSponsored": ('bool',),
-# class PySide2.QtLocation.QPlaceReview:
-    "PySide2.QtLocation.QPlaceReview.__init__": [(), ('PySide2.QtLocation.QPlaceContent',)],
-    "PySide2.QtLocation.QPlaceReview.dateTime": (),
-    "PySide2.QtLocation.QPlaceReview.language": (),
-    "PySide2.QtLocation.QPlaceReview.rating": (),
-    "PySide2.QtLocation.QPlaceReview.reviewId": (),
-    "PySide2.QtLocation.QPlaceReview.setDateTime": ('PySide2.QtCore.QDateTime',),
-    "PySide2.QtLocation.QPlaceReview.setLanguage": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setRating": ('float',),
-    "PySide2.QtLocation.QPlaceReview.setReviewId": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setText": ('str',),
-    "PySide2.QtLocation.QPlaceReview.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceReview.text": (),
-    "PySide2.QtLocation.QPlaceReview.title": (),
-# class PySide2.QtLocation.QPlaceSearchReply:
-    "PySide2.QtLocation.QPlaceSearchReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchReply.nextPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.previousPageRequest": (),
-    "PySide2.QtLocation.QPlaceSearchReply.request": (),
-    "PySide2.QtLocation.QPlaceSearchReply.results": (),
-    "PySide2.QtLocation.QPlaceSearchReply.setNextPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setPreviousPageRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setRequest": ('PySide2.QtLocation.QPlaceSearchRequest',),
-    "PySide2.QtLocation.QPlaceSearchReply.setResults": ('typing.Sequence[PySide2.QtLocation.QPlaceSearchResult]',),
-    "PySide2.QtLocation.QPlaceSearchReply.type": (),
-# class PySide2.QtLocation.QPlaceSearchRequest:
-# class PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint:
-    "PySide2.QtLocation.QPlaceSearchRequest.__init__": [(), ('PySide2.QtLocation.QPlaceSearchRequest',)],
-    "PySide2.QtLocation.QPlaceSearchRequest.categories": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.clear": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.limit": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.recommendationId": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.relevanceHint": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchArea": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchContext": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.searchTerm": (),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategories": ('typing.Sequence[PySide2.QtLocation.QPlaceCategory]',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setCategory": ('PySide2.QtLocation.QPlaceCategory',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setLimit": ('int',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRecommendationId": ('str',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setRelevanceHint": ('PySide2.QtLocation.QPlaceSearchRequest.RelevanceHint',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchArea": ('PySide2.QtPositioning.QGeoShape',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchContext": ('typing.Any',),
-    "PySide2.QtLocation.QPlaceSearchRequest.setSearchTerm": ('str',),
-# class PySide2.QtLocation.QPlaceSearchResult:
-# class PySide2.QtLocation.QPlaceSearchResult.SearchResultType:
-    "PySide2.QtLocation.QPlaceSearchResult.__init__": [(), ('PySide2.QtLocation.QPlaceSearchResult',)],
-    "PySide2.QtLocation.QPlaceSearchResult.icon": (),
-    "PySide2.QtLocation.QPlaceSearchResult.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSearchResult.setTitle": ('str',),
-    "PySide2.QtLocation.QPlaceSearchResult.title": (),
-    "PySide2.QtLocation.QPlaceSearchResult.type": (),
-# class PySide2.QtLocation.QPlaceSearchSuggestionReply:
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.setSuggestions": ('typing.Sequence[str]',),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.suggestions": (),
-    "PySide2.QtLocation.QPlaceSearchSuggestionReply.type": (),
-# class PySide2.QtLocation.QPlaceSupplier:
-    "PySide2.QtLocation.QPlaceSupplier.__init__": [(), ('PySide2.QtLocation.QPlaceSupplier',)],
-    "PySide2.QtLocation.QPlaceSupplier.__copy__": (),
-    "PySide2.QtLocation.QPlaceSupplier.icon": (),
-    "PySide2.QtLocation.QPlaceSupplier.isEmpty": (),
-    "PySide2.QtLocation.QPlaceSupplier.name": (),
-    "PySide2.QtLocation.QPlaceSupplier.setIcon": ('PySide2.QtLocation.QPlaceIcon',),
-    "PySide2.QtLocation.QPlaceSupplier.setName": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setSupplierId": ('str',),
-    "PySide2.QtLocation.QPlaceSupplier.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtLocation.QPlaceSupplier.supplierId": (),
-    "PySide2.QtLocation.QPlaceSupplier.url": (),
-# class PySide2.QtLocation.QPlaceUser:
-    "PySide2.QtLocation.QPlaceUser.__init__": [(), ('PySide2.QtLocation.QPlaceUser',)],
-    "PySide2.QtLocation.QPlaceUser.__copy__": (),
-    "PySide2.QtLocation.QPlaceUser.name": (),
-    "PySide2.QtLocation.QPlaceUser.setName": ('str',),
-    "PySide2.QtLocation.QPlaceUser.setUserId": ('str',),
-    "PySide2.QtLocation.QPlaceUser.userId": (),
-    }) if "PySide2.QtLocation" in sys.modules else None
-# Module PySide2.QtQml
-sig_dict.update({
-# class PySide2.QtQml.ListProperty:
-    "PySide2.QtQml.ListProperty.__init__": ('type', 'typing.Callable', 'typing.Callable', 'typing.Callable', 'typing.Callable'),
-# class PySide2.QtQml.QJSEngine:
-# class PySide2.QtQml.QJSEngine.Extension:
-# class PySide2.QtQml.QJSEngine.Extensions:
-    "PySide2.QtQml.QJSEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QJSEngine.collectGarbage": (),
-    "PySide2.QtQml.QJSEngine.evaluate": ('str', 'str', 'int'),
-    "PySide2.QtQml.QJSEngine.globalObject": (),
-    "PySide2.QtQml.QJSEngine.importModule": ('str',),
-    "PySide2.QtQml.QJSEngine.installExtensions": ('PySide2.QtQml.QJSEngine.Extensions', 'PySide2.QtQml.QJSValue'),
-    "PySide2.QtQml.QJSEngine.installTranslatorFunctions": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSEngine.isInterrupted": (),
-    "PySide2.QtQml.QJSEngine.newArray": ('int',),
-    "PySide2.QtQml.QJSEngine.newErrorObject": ('PySide2.QtQml.QJSValue.ErrorType', 'str'),
-    "PySide2.QtQml.QJSEngine.newObject": (),
-    "PySide2.QtQml.QJSEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject',),
-    "PySide2.QtQml.QJSEngine.newQObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QJSEngine.setInterrupted": ('bool',),
-    "PySide2.QtQml.QJSEngine.throwError": [('PySide2.QtQml.QJSValue.ErrorType', 'str'), ('str',)],
-    "PySide2.QtQml.QJSEngine.toScriptValue": ('typing.Any',),
-# class PySide2.QtQml.QJSValue:
-# class PySide2.QtQml.QJSValue.ErrorType:
-# class PySide2.QtQml.QJSValue.SpecialValue:
-    "PySide2.QtQml.QJSValue.__init__": [('PySide2.QtQml.QJSValue',), ('PySide2.QtQml.QJSValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.__copy__": (),
-    "PySide2.QtQml.QJSValue.call": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callAsConstructor": ('typing.Sequence[PySide2.QtQml.QJSValue]',),
-    "PySide2.QtQml.QJSValue.callWithInstance": ('PySide2.QtQml.QJSValue', 'typing.Sequence[PySide2.QtQml.QJSValue]'),
-    "PySide2.QtQml.QJSValue.deleteProperty": ('str',),
-    "PySide2.QtQml.QJSValue.engine": (),
-    "PySide2.QtQml.QJSValue.equals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.errorType": (),
-    "PySide2.QtQml.QJSValue.hasOwnProperty": ('str',),
-    "PySide2.QtQml.QJSValue.hasProperty": ('str',),
-    "PySide2.QtQml.QJSValue.isArray": (),
-    "PySide2.QtQml.QJSValue.isBool": (),
-    "PySide2.QtQml.QJSValue.isCallable": (),
-    "PySide2.QtQml.QJSValue.isDate": (),
-    "PySide2.QtQml.QJSValue.isError": (),
-    "PySide2.QtQml.QJSValue.isNull": (),
-    "PySide2.QtQml.QJSValue.isNumber": (),
-    "PySide2.QtQml.QJSValue.isObject": (),
-    "PySide2.QtQml.QJSValue.isQMetaObject": (),
-    "PySide2.QtQml.QJSValue.isQObject": (),
-    "PySide2.QtQml.QJSValue.isRegExp": (),
-    "PySide2.QtQml.QJSValue.isString": (),
-    "PySide2.QtQml.QJSValue.isUndefined": (),
-    "PySide2.QtQml.QJSValue.isVariant": (),
-    "PySide2.QtQml.QJSValue.property": [('int',), ('str',)],
-    "PySide2.QtQml.QJSValue.prototype": (),
-    "PySide2.QtQml.QJSValue.setProperty": [('int', 'PySide2.QtQml.QJSValue'), ('str', 'PySide2.QtQml.QJSValue')],
-    "PySide2.QtQml.QJSValue.setPrototype": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.strictlyEquals": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValue.toBool": (),
-    "PySide2.QtQml.QJSValue.toDateTime": (),
-    "PySide2.QtQml.QJSValue.toInt": (),
-    "PySide2.QtQml.QJSValue.toNumber": (),
-    "PySide2.QtQml.QJSValue.toQMetaObject": (),
-    "PySide2.QtQml.QJSValue.toQObject": (),
-    "PySide2.QtQml.QJSValue.toString": (),
-    "PySide2.QtQml.QJSValue.toUInt": (),
-    "PySide2.QtQml.QJSValue.toVariant": (),
-# class PySide2.QtQml.QJSValueIterator:
-    "PySide2.QtQml.QJSValueIterator.__init__": ('PySide2.QtQml.QJSValue',),
-    "PySide2.QtQml.QJSValueIterator.hasNext": (),
-    "PySide2.QtQml.QJSValueIterator.name": (),
-    "PySide2.QtQml.QJSValueIterator.value": (),
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor:
-# class PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType:
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.__init__": (),
-    "PySide2.QtQml.QQmlAbstractUrlInterceptor.intercept": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlAbstractUrlInterceptor.DataType'),
-# class PySide2.QtQml.QQmlApplicationEngine:
-    "PySide2.QtQml.QQmlApplicationEngine.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlApplicationEngine.load": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlApplicationEngine.loadData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlApplicationEngine.rootObjects": (),
-    "PySide2.QtQml.QQmlApplicationEngine.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtQml.QQmlComponent:
-# class PySide2.QtQml.QQmlComponent.CompilationMode:
-# class PySide2.QtQml.QQmlComponent.Status:
-    "PySide2.QtQml.QQmlComponent.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'str', 'PySide2.QtQml.QQmlComponent.CompilationMode', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlComponent.beginCreate": ('PySide2.QtQml.QQmlContext',),
-    "PySide2.QtQml.QQmlComponent.completeCreate": (),
-    "PySide2.QtQml.QQmlComponent.create": [('PySide2.QtQml.QQmlContext',), ('PySide2.QtQml.QQmlIncubator', 'PySide2.QtQml.QQmlContext', 'PySide2.QtQml.QQmlContext')],
-    "PySide2.QtQml.QQmlComponent.createWithInitialProperties": ('typing.Dict[str, typing.Any]', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlComponent.creationContext": (),
-    "PySide2.QtQml.QQmlComponent.engine": (),
-    "PySide2.QtQml.QQmlComponent.errorString": (),
-    "PySide2.QtQml.QQmlComponent.errors": (),
-    "PySide2.QtQml.QQmlComponent.isError": (),
-    "PySide2.QtQml.QQmlComponent.isLoading": (),
-    "PySide2.QtQml.QQmlComponent.isNull": (),
-    "PySide2.QtQml.QQmlComponent.isReady": (),
-    "PySide2.QtQml.QQmlComponent.loadUrl": [('PySide2.QtCore.QUrl',), ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent.CompilationMode')],
-    "PySide2.QtQml.QQmlComponent.progress": (),
-    "PySide2.QtQml.QQmlComponent.setData": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtQml.QQmlComponent.setInitialProperties": ('PySide2.QtCore.QObject', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlComponent.status": (),
-    "PySide2.QtQml.QQmlComponent.url": (),
-# class PySide2.QtQml.QQmlContext:
-    "PySide2.QtQml.QQmlContext.__init__": [('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlContext.baseUrl": (),
-    "PySide2.QtQml.QQmlContext.contextObject": (),
-    "PySide2.QtQml.QQmlContext.contextProperty": ('str',),
-    "PySide2.QtQml.QQmlContext.engine": (),
-    "PySide2.QtQml.QQmlContext.isValid": (),
-    "PySide2.QtQml.QQmlContext.nameForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.parentContext": (),
-    "PySide2.QtQml.QQmlContext.resolvedUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlContext.setContextObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlContext.setContextProperty": [('str', 'PySide2.QtCore.QObject'), ('str', 'typing.Any')],
-# class PySide2.QtQml.QQmlDebuggingEnabler:
-# class PySide2.QtQml.QQmlDebuggingEnabler.StartMode:
-    "PySide2.QtQml.QQmlDebuggingEnabler.__init__": ('bool',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.connectToLocalDebugger": ('str', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.debuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.inspectorServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.nativeDebuggerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.profilerServices": (),
-    "PySide2.QtQml.QQmlDebuggingEnabler.setServices": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startDebugConnector": ('str', 'typing.Dict[str, typing.Any]'),
-    "PySide2.QtQml.QQmlDebuggingEnabler.startTcpDebugServer": ('int', 'PySide2.QtQml.QQmlDebuggingEnabler.StartMode', 'str'),
-# class PySide2.QtQml.QQmlEngine:
-# class PySide2.QtQml.QQmlEngine.ObjectOwnership:
-    "PySide2.QtQml.QQmlEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.addImageProvider": ('str', 'PySide2.QtQml.QQmlImageProviderBase'),
-    "PySide2.QtQml.QQmlEngine.addImportPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.addNamedBundle": ('str', 'str'),
-    "PySide2.QtQml.QQmlEngine.addPluginPath": ('str',),
-    "PySide2.QtQml.QQmlEngine.baseUrl": (),
-    "PySide2.QtQml.QQmlEngine.clearComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.contextForObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQml.QQmlEngine.imageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.importPathList": (),
-    "PySide2.QtQml.QQmlEngine.importPlugin": ('str', 'str', 'typing.Sequence[PySide2.QtQml.QQmlError]'),
-    "PySide2.QtQml.QQmlEngine.incubationController": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManager": (),
-    "PySide2.QtQml.QQmlEngine.networkAccessManagerFactory": (),
-    "PySide2.QtQml.QQmlEngine.objectOwnership": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlEngine.offlineStorageDatabaseFilePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.offlineStoragePath": (),
-    "PySide2.QtQml.QQmlEngine.outputWarningsToStandardError": (),
-    "PySide2.QtQml.QQmlEngine.pluginPathList": (),
-    "PySide2.QtQml.QQmlEngine.removeImageProvider": ('str',),
-    "PySide2.QtQml.QQmlEngine.retranslate": (),
-    "PySide2.QtQml.QQmlEngine.rootContext": (),
-    "PySide2.QtQml.QQmlEngine.setBaseUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlEngine.setContextForObject": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'),
-    "PySide2.QtQml.QQmlEngine.setImportPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setIncubationController": ('PySide2.QtQml.QQmlIncubationController',),
-    "PySide2.QtQml.QQmlEngine.setNetworkAccessManagerFactory": ('PySide2.QtQml.QQmlNetworkAccessManagerFactory',),
-    "PySide2.QtQml.QQmlEngine.setObjectOwnership": ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine.ObjectOwnership'),
-    "PySide2.QtQml.QQmlEngine.setOfflineStoragePath": ('str',),
-    "PySide2.QtQml.QQmlEngine.setOutputWarningsToStandardError": ('bool',),
-    "PySide2.QtQml.QQmlEngine.setPluginPathList": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlEngine.setUrlInterceptor": ('PySide2.QtQml.QQmlAbstractUrlInterceptor',),
-    "PySide2.QtQml.QQmlEngine.trimComponentCache": (),
-    "PySide2.QtQml.QQmlEngine.urlInterceptor": (),
-# class PySide2.QtQml.QQmlError:
-    "PySide2.QtQml.QQmlError.__init__": [(), ('PySide2.QtQml.QQmlError',)],
-    "PySide2.QtQml.QQmlError.__copy__": (),
-    "PySide2.QtQml.QQmlError.column": (),
-    "PySide2.QtQml.QQmlError.description": (),
-    "PySide2.QtQml.QQmlError.isValid": (),
-    "PySide2.QtQml.QQmlError.line": (),
-    "PySide2.QtQml.QQmlError.messageType": (),
-    "PySide2.QtQml.QQmlError.object": (),
-    "PySide2.QtQml.QQmlError.setColumn": ('int',),
-    "PySide2.QtQml.QQmlError.setDescription": ('str',),
-    "PySide2.QtQml.QQmlError.setLine": ('int',),
-    "PySide2.QtQml.QQmlError.setMessageType": ('PySide2.QtCore.QtMsgType',),
-    "PySide2.QtQml.QQmlError.setObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlError.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQml.QQmlError.toString": (),
-    "PySide2.QtQml.QQmlError.url": (),
-# class PySide2.QtQml.QQmlExpression:
-    "PySide2.QtQml.QQmlExpression.__init__": [(), ('PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtQml.QQmlScriptString', 'PySide2.QtQml.QQmlContext', 'PySide2.QtCore.QObject', 'PySide2.QtCore.QObject')],
-    "PySide2.QtQml.QQmlExpression.clearError": (),
-    "PySide2.QtQml.QQmlExpression.columnNumber": (),
-    "PySide2.QtQml.QQmlExpression.context": (),
-    "PySide2.QtQml.QQmlExpression.engine": (),
-    "PySide2.QtQml.QQmlExpression.error": (),
-    "PySide2.QtQml.QQmlExpression.evaluate": (),
-    "PySide2.QtQml.QQmlExpression.expression": (),
-    "PySide2.QtQml.QQmlExpression.hasError": (),
-    "PySide2.QtQml.QQmlExpression.lineNumber": (),
-    "PySide2.QtQml.QQmlExpression.notifyOnValueChanged": (),
-    "PySide2.QtQml.QQmlExpression.scopeObject": (),
-    "PySide2.QtQml.QQmlExpression.setExpression": ('str',),
-    "PySide2.QtQml.QQmlExpression.setNotifyOnValueChanged": ('bool',),
-    "PySide2.QtQml.QQmlExpression.setSourceLocation": ('str', 'int', 'int'),
-    "PySide2.QtQml.QQmlExpression.sourceFile": (),
-# class PySide2.QtQml.QQmlExtensionInterface:
-    "PySide2.QtQml.QQmlExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlExtensionInterface.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-# class PySide2.QtQml.QQmlExtensionPlugin:
-    "PySide2.QtQml.QQmlExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlExtensionPlugin.baseUrl": (),
-    "PySide2.QtQml.QQmlExtensionPlugin.initializeEngine": ('PySide2.QtQml.QQmlEngine', 'str'),
-    "PySide2.QtQml.QQmlExtensionPlugin.registerTypes": ('str',),
-# class PySide2.QtQml.QQmlFile:
-# class PySide2.QtQml.QQmlFile.Status:
-    "PySide2.QtQml.QQmlFile.__init__": [(), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.clear": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtQml.QQmlFile.connectDownloadProgress": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.connectFinished": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlFile.data": (),
-    "PySide2.QtQml.QQmlFile.dataByteArray": (),
-    "PySide2.QtQml.QQmlFile.error": (),
-    "PySide2.QtQml.QQmlFile.isError": (),
-    "PySide2.QtQml.QQmlFile.isLoading": (),
-    "PySide2.QtQml.QQmlFile.isLocalFile": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.isNull": (),
-    "PySide2.QtQml.QQmlFile.isReady": (),
-    "PySide2.QtQml.QQmlFile.isSynchronous": [('PySide2.QtCore.QUrl',), ('str',)],
-    "PySide2.QtQml.QQmlFile.load": [('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QUrl'), ('PySide2.QtQml.QQmlEngine', 'str')],
-    "PySide2.QtQml.QQmlFile.size": (),
-    "PySide2.QtQml.QQmlFile.status": (),
-    "PySide2.QtQml.QQmlFile.url": (),
-    "PySide2.QtQml.QQmlFile.urlToLocalFileOrQrc": [('PySide2.QtCore.QUrl',), ('str',)],
-# class PySide2.QtQml.QQmlFileSelector:
-    "PySide2.QtQml.QQmlFileSelector.__init__": ('PySide2.QtQml.QQmlEngine', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQml.QQmlFileSelector.get": ('PySide2.QtQml.QQmlEngine',),
-    "PySide2.QtQml.QQmlFileSelector.selector": (),
-    "PySide2.QtQml.QQmlFileSelector.setExtraSelectors": ('typing.Sequence[str]',),
-    "PySide2.QtQml.QQmlFileSelector.setSelector": ('PySide2.QtCore.QFileSelector',),
-# class PySide2.QtQml.QQmlImageProviderBase:
-# class PySide2.QtQml.QQmlImageProviderBase.Flag:
-# class PySide2.QtQml.QQmlImageProviderBase.Flags:
-# class PySide2.QtQml.QQmlImageProviderBase.ImageType:
-    "PySide2.QtQml.QQmlImageProviderBase.flags": (),
-    "PySide2.QtQml.QQmlImageProviderBase.imageType": (),
-# class PySide2.QtQml.QQmlIncubationController:
-    "PySide2.QtQml.QQmlIncubationController.__init__": (),
-    "PySide2.QtQml.QQmlIncubationController.engine": (),
-    "PySide2.QtQml.QQmlIncubationController.incubateFor": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubateWhile": ('int',),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCount": (),
-    "PySide2.QtQml.QQmlIncubationController.incubatingObjectCountChanged": ('int',),
-# class PySide2.QtQml.QQmlIncubator:
-# class PySide2.QtQml.QQmlIncubator.IncubationMode:
-# class PySide2.QtQml.QQmlIncubator.Status:
-    "PySide2.QtQml.QQmlIncubator.__init__": ('PySide2.QtQml.QQmlIncubator.IncubationMode',),
-    "PySide2.QtQml.QQmlIncubator.clear": (),
-    "PySide2.QtQml.QQmlIncubator.errors": (),
-    "PySide2.QtQml.QQmlIncubator.forceCompletion": (),
-    "PySide2.QtQml.QQmlIncubator.incubationMode": (),
-    "PySide2.QtQml.QQmlIncubator.isError": (),
-    "PySide2.QtQml.QQmlIncubator.isLoading": (),
-    "PySide2.QtQml.QQmlIncubator.isNull": (),
-    "PySide2.QtQml.QQmlIncubator.isReady": (),
-    "PySide2.QtQml.QQmlIncubator.object": (),
-    "PySide2.QtQml.QQmlIncubator.setInitialState": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlIncubator.status": (),
-    "PySide2.QtQml.QQmlIncubator.statusChanged": ('PySide2.QtQml.QQmlIncubator.Status',),
-# class PySide2.QtQml.QQmlListReference:
-    "PySide2.QtQml.QQmlListReference.__init__": [(), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlListReference',)],
-    "PySide2.QtQml.QQmlListReference.__copy__": (),
-    "PySide2.QtQml.QQmlListReference.append": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlListReference.at": ('int',),
-    "PySide2.QtQml.QQmlListReference.canAppend": (),
-    "PySide2.QtQml.QQmlListReference.canAt": (),
-    "PySide2.QtQml.QQmlListReference.canClear": (),
-    "PySide2.QtQml.QQmlListReference.canCount": (),
-    "PySide2.QtQml.QQmlListReference.clear": (),
-    "PySide2.QtQml.QQmlListReference.count": (),
-    "PySide2.QtQml.QQmlListReference.isManipulable": (),
-    "PySide2.QtQml.QQmlListReference.isReadable": (),
-    "PySide2.QtQml.QQmlListReference.isValid": (),
-    "PySide2.QtQml.QQmlListReference.listElementType": (),
-    "PySide2.QtQml.QQmlListReference.object": (),
-# class PySide2.QtQml.QQmlNetworkAccessManagerFactory:
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.__init__": (),
-    "PySide2.QtQml.QQmlNetworkAccessManagerFactory.create": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.QQmlParserStatus:
-    "PySide2.QtQml.QQmlParserStatus.__init__": (),
-    "PySide2.QtQml.QQmlParserStatus.classBegin": (),
-    "PySide2.QtQml.QQmlParserStatus.componentComplete": (),
-# class PySide2.QtQml.QQmlProperty:
-# class PySide2.QtQml.QQmlProperty.PropertyTypeCategory:
-# class PySide2.QtQml.QQmlProperty.Type:
-    "PySide2.QtQml.QQmlProperty.__init__": [(), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine'), ('PySide2.QtQml.QQmlProperty',)],
-    "PySide2.QtQml.QQmlProperty.__copy__": (),
-    "PySide2.QtQml.QQmlProperty.connectNotifySignal": [('PySide2.QtCore.QObject', 'int'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtQml.QQmlProperty.hasNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.index": (),
-    "PySide2.QtQml.QQmlProperty.isDesignable": (),
-    "PySide2.QtQml.QQmlProperty.isProperty": (),
-    "PySide2.QtQml.QQmlProperty.isResettable": (),
-    "PySide2.QtQml.QQmlProperty.isSignalProperty": (),
-    "PySide2.QtQml.QQmlProperty.isValid": (),
-    "PySide2.QtQml.QQmlProperty.isWritable": (),
-    "PySide2.QtQml.QQmlProperty.method": (),
-    "PySide2.QtQml.QQmlProperty.name": (),
-    "PySide2.QtQml.QQmlProperty.needsNotifySignal": (),
-    "PySide2.QtQml.QQmlProperty.object": (),
-    "PySide2.QtQml.QQmlProperty.property": (),
-    "PySide2.QtQml.QQmlProperty.propertyType": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeCategory": (),
-    "PySide2.QtQml.QQmlProperty.propertyTypeName": (),
-    "PySide2.QtQml.QQmlProperty.read": [(), ('PySide2.QtCore.QObject', 'str'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'PySide2.QtQml.QQmlEngine')],
-    "PySide2.QtQml.QQmlProperty.reset": (),
-    "PySide2.QtQml.QQmlProperty.type": (),
-    "PySide2.QtQml.QQmlProperty.write": [('PySide2.QtCore.QObject', 'str', 'typing.Any'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlContext'), ('PySide2.QtCore.QObject', 'str', 'typing.Any', 'PySide2.QtQml.QQmlEngine'), ('typing.Any',)],
-# class PySide2.QtQml.QQmlPropertyMap:
-    "PySide2.QtQml.QQmlPropertyMap.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QQmlPropertyMap.clear": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.contains": ('str',),
-    "PySide2.QtQml.QQmlPropertyMap.count": (),
-    "PySide2.QtQml.QQmlPropertyMap.insert": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.isEmpty": (),
-    "PySide2.QtQml.QQmlPropertyMap.keys": (),
-    "PySide2.QtQml.QQmlPropertyMap.size": (),
-    "PySide2.QtQml.QQmlPropertyMap.updateValue": ('str', 'typing.Any'),
-    "PySide2.QtQml.QQmlPropertyMap.value": ('str',),
-# class PySide2.QtQml.QQmlPropertyValueSource:
-    "PySide2.QtQml.QQmlPropertyValueSource.__init__": (),
-    "PySide2.QtQml.QQmlPropertyValueSource.setTarget": ('PySide2.QtQml.QQmlProperty',),
-# class PySide2.QtQml.QQmlScriptString:
-    "PySide2.QtQml.QQmlScriptString.__init__": [(), ('PySide2.QtQml.QQmlScriptString',)],
-    "PySide2.QtQml.QQmlScriptString.__copy__": (),
-    "PySide2.QtQml.QQmlScriptString.booleanLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isEmpty": (),
-    "PySide2.QtQml.QQmlScriptString.isNullLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.isUndefinedLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.numberLiteral": (),
-    "PySide2.QtQml.QQmlScriptString.stringLiteral": (),
-# class PySide2.QtQml.QQmlTypesExtensionInterface:
-    "PySide2.QtQml.QQmlTypesExtensionInterface.__init__": (),
-    "PySide2.QtQml.QQmlTypesExtensionInterface.registerTypes": ('str',),
-# class PySide2.QtQml.QtQml:
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObject": ('PySide2.QtCore.QObject', 'PySide2.QtCore.QMetaObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlAttachedPropertiesObjectById": ('int', 'PySide2.QtCore.QObject', 'bool'),
-    "PySide2.QtQml.QtQml.qmlContext": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlEngine": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQml.QtQml.qmlExecuteDeferred": ('PySide2.QtCore.QObject',),
-# class PySide2.QtQml.VolatileBool:
-    "PySide2.QtQml.VolatileBool.get": (),
-    "PySide2.QtQml.VolatileBool.set": ('object',),
-    "PySide2.QtQml.VolatileBool.qmlRegisterType": ('type', 'str', 'int', 'int', 'str'),
-    }) if "PySide2.QtQml" in sys.modules else None
-# Module PySide2.QtQuick
-sig_dict.update({
-# class PySide2.QtQuick.QQuickAsyncImageProvider:
-    "PySide2.QtQuick.QQuickAsyncImageProvider.__init__": (),
-    "PySide2.QtQuick.QQuickAsyncImageProvider.requestImageResponse": ('str', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickFramebufferObject:
-# class PySide2.QtQuick.QQuickFramebufferObject.Renderer:
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.__init__": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.createFramebufferObject": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.framebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.invalidateFramebufferObject": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.render": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.synchronize": ('PySide2.QtQuick.QQuickFramebufferObject',),
-    "PySide2.QtQuick.QQuickFramebufferObject.Renderer.update": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickFramebufferObject.createRenderer": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickFramebufferObject.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.mirrorVertically": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.releaseResources": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.setMirrorVertically": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.setTextureFollowsItemSize": ('bool',),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureFollowsItemSize": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.textureProvider": (),
-    "PySide2.QtQuick.QQuickFramebufferObject.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickImageProvider:
-    "PySide2.QtQuick.QQuickImageProvider.__init__": ('PySide2.QtQml.QQmlImageProviderBase.ImageType', 'PySide2.QtQml.QQmlImageProviderBase.Flags'),
-    "PySide2.QtQuick.QQuickImageProvider.flags": (),
-    "PySide2.QtQuick.QQuickImageProvider.imageType": (),
-    "PySide2.QtQuick.QQuickImageProvider.requestImage": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestPixmap": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-    "PySide2.QtQuick.QQuickImageProvider.requestTexture": ('str', 'PySide2.QtCore.QSize', 'PySide2.QtCore.QSize'),
-# class PySide2.QtQuick.QQuickImageResponse:
-    "PySide2.QtQuick.QQuickImageResponse.__init__": (),
-    "PySide2.QtQuick.QQuickImageResponse.cancel": (),
-    "PySide2.QtQuick.QQuickImageResponse.errorString": (),
-    "PySide2.QtQuick.QQuickImageResponse.textureFactory": (),
-# class PySide2.QtQuick.QQuickItem:
-# class PySide2.QtQuick.QQuickItem.Flag:
-# class PySide2.QtQuick.QQuickItem.Flags:
-# class PySide2.QtQuick.QQuickItem.ItemChange:
-# class PySide2.QtQuick.QQuickItem.TransformOrigin:
-# class PySide2.QtQuick.QQuickItem.UpdatePaintNodeData:
-    "PySide2.QtQuick.QQuickItem.UpdatePaintNodeData.__copy__": (),
-    "PySide2.QtQuick.QQuickItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.acceptHoverEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptTouchEvents": (),
-    "PySide2.QtQuick.QQuickItem.acceptedMouseButtons": (),
-    "PySide2.QtQuick.QQuickItem.activeFocusOnTab": (),
-    "PySide2.QtQuick.QQuickItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickItem.baselineOffset": (),
-    "PySide2.QtQuick.QQuickItem.boundingRect": (),
-    "PySide2.QtQuick.QQuickItem.childAt": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.childItems": (),
-    "PySide2.QtQuick.QQuickItem.childMouseEventFilter": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickItem.childrenRect": (),
-    "PySide2.QtQuick.QQuickItem.classBegin": (),
-    "PySide2.QtQuick.QQuickItem.clip": (),
-    "PySide2.QtQuick.QQuickItem.clipRect": (),
-    "PySide2.QtQuick.QQuickItem.componentComplete": (),
-    "PySide2.QtQuick.QQuickItem.containmentMask": (),
-    "PySide2.QtQuick.QQuickItem.contains": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.cursor": (),
-    "PySide2.QtQuick.QQuickItem.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuick.QQuickItem.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuick.QQuickItem.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuick.QQuickItem.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuick.QQuickItem.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItem.filtersChildMouseEvents": (),
-    "PySide2.QtQuick.QQuickItem.flags": (),
-    "PySide2.QtQuick.QQuickItem.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickItem.forceActiveFocus": [(), ('PySide2.QtCore.Qt.FocusReason',)],
-    "PySide2.QtQuick.QQuickItem.geometryChanged": ('PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.grabMouse": (),
-    "PySide2.QtQuick.QQuickItem.grabToImage": [('PySide2.QtCore.QSize',), ('PySide2.QtQml.QJSValue', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickItem.grabTouchPoints": ('typing.List[int]',),
-    "PySide2.QtQuick.QQuickItem.hasActiveFocus": (),
-    "PySide2.QtQuick.QQuickItem.hasFocus": (),
-    "PySide2.QtQuick.QQuickItem.height": (),
-    "PySide2.QtQuick.QQuickItem.heightValid": (),
-    "PySide2.QtQuick.QQuickItem.hoverEnterEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverLeaveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.hoverMoveEvent": ('PySide2.QtGui.QHoverEvent',),
-    "PySide2.QtQuick.QQuickItem.implicitHeight": (),
-    "PySide2.QtQuick.QQuickItem.implicitWidth": (),
-    "PySide2.QtQuick.QQuickItem.inputMethodEvent": ('PySide2.QtGui.QInputMethodEvent',),
-    "PySide2.QtQuick.QQuickItem.inputMethodQuery": ('PySide2.QtCore.Qt.InputMethodQuery',),
-    "PySide2.QtQuick.QQuickItem.isAncestorOf": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.isComponentComplete": (),
-    "PySide2.QtQuick.QQuickItem.isEnabled": (),
-    "PySide2.QtQuick.QQuickItem.isFocusScope": (),
-    "PySide2.QtQuick.QQuickItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickItem.isUnderMouse": (),
-    "PySide2.QtQuick.QQuickItem.isVisible": (),
-    "PySide2.QtQuick.QQuickItem.itemTransform": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.keepMouseGrab": (),
-    "PySide2.QtQuick.QQuickItem.keepTouchGrab": (),
-    "PySide2.QtQuick.QQuickItem.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickItem.mapFromGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapFromScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapRectFromItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectFromScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapRectToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QQuickItem.mapRectToScene": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QQuickItem.mapToGlobal": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mapToItem": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtQuick.QQuickItem.mapToScene": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickItem.mouseUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.nextItemInFocusChain": ('bool',),
-    "PySide2.QtQuick.QQuickItem.opacity": (),
-    "PySide2.QtQuick.QQuickItem.parentItem": (),
-    "PySide2.QtQuick.QQuickItem.polish": (),
-    "PySide2.QtQuick.QQuickItem.position": (),
-    "PySide2.QtQuick.QQuickItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickItem.resetAntialiasing": (),
-    "PySide2.QtQuick.QQuickItem.resetHeight": (),
-    "PySide2.QtQuick.QQuickItem.resetWidth": (),
-    "PySide2.QtQuick.QQuickItem.rotation": (),
-    "PySide2.QtQuick.QQuickItem.scale": (),
-    "PySide2.QtQuick.QQuickItem.scopedFocusItem": (),
-    "PySide2.QtQuick.QQuickItem.setAcceptHoverEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptTouchEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAcceptedMouseButtons": ('PySide2.QtCore.Qt.MouseButtons',),
-    "PySide2.QtQuick.QQuickItem.setActiveFocusOnTab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setBaselineOffset": ('float',),
-    "PySide2.QtQuick.QQuickItem.setClip": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setContainmentMask": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickItem.setCursor": ('PySide2.QtGui.QCursor',),
-    "PySide2.QtQuick.QQuickItem.setEnabled": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFiltersChildMouseEvents": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setFlag": ('PySide2.QtQuick.QQuickItem.Flag', 'bool'),
-    "PySide2.QtQuick.QQuickItem.setFlags": ('PySide2.QtQuick.QQuickItem.Flags',),
-    "PySide2.QtQuick.QQuickItem.setFocus": [('bool',), ('bool', 'PySide2.QtCore.Qt.FocusReason')],
-    "PySide2.QtQuick.QQuickItem.setHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitHeight": ('float',),
-    "PySide2.QtQuick.QQuickItem.setImplicitSize": ('float', 'float'),
-    "PySide2.QtQuick.QQuickItem.setImplicitWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setKeepMouseGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setKeepTouchGrab": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setOpacity": ('float',),
-    "PySide2.QtQuick.QQuickItem.setParentItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.setPosition": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setRotation": ('float',),
-    "PySide2.QtQuick.QQuickItem.setScale": ('float',),
-    "PySide2.QtQuick.QQuickItem.setSize": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtQuick.QQuickItem.setSmooth": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setState": ('str',),
-    "PySide2.QtQuick.QQuickItem.setTransformOrigin": ('PySide2.QtQuick.QQuickItem.TransformOrigin',),
-    "PySide2.QtQuick.QQuickItem.setTransformOriginPoint": ('PySide2.QtCore.QPointF',),
-    "PySide2.QtQuick.QQuickItem.setVisible": ('bool',),
-    "PySide2.QtQuick.QQuickItem.setWidth": ('float',),
-    "PySide2.QtQuick.QQuickItem.setX": ('float',),
-    "PySide2.QtQuick.QQuickItem.setY": ('float',),
-    "PySide2.QtQuick.QQuickItem.setZ": ('float',),
-    "PySide2.QtQuick.QQuickItem.size": (),
-    "PySide2.QtQuick.QQuickItem.smooth": (),
-    "PySide2.QtQuick.QQuickItem.stackAfter": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.stackBefore": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickItem.state": (),
-    "PySide2.QtQuick.QQuickItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickItem.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtQuick.QQuickItem.touchUngrabEvent": (),
-    "PySide2.QtQuick.QQuickItem.transformOrigin": (),
-    "PySide2.QtQuick.QQuickItem.transformOriginPoint": (),
-    "PySide2.QtQuick.QQuickItem.ungrabMouse": (),
-    "PySide2.QtQuick.QQuickItem.ungrabTouchPoints": (),
-    "PySide2.QtQuick.QQuickItem.unsetCursor": (),
-    "PySide2.QtQuick.QQuickItem.update": (),
-    "PySide2.QtQuick.QQuickItem.updateInputMethod": ('PySide2.QtCore.Qt.InputMethodQueries',),
-    "PySide2.QtQuick.QQuickItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-    "PySide2.QtQuick.QQuickItem.updatePolish": (),
-    "PySide2.QtQuick.QQuickItem.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    "PySide2.QtQuick.QQuickItem.width": (),
-    "PySide2.QtQuick.QQuickItem.widthValid": (),
-    "PySide2.QtQuick.QQuickItem.window": (),
-    "PySide2.QtQuick.QQuickItem.windowDeactivateEvent": (),
-    "PySide2.QtQuick.QQuickItem.x": (),
-    "PySide2.QtQuick.QQuickItem.y": (),
-    "PySide2.QtQuick.QQuickItem.z": (),
-# class PySide2.QtQuick.QQuickItemGrabResult:
-    "PySide2.QtQuick.QQuickItemGrabResult.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickItemGrabResult.image": (),
-    "PySide2.QtQuick.QQuickItemGrabResult.saveToFile": ('str',),
-    "PySide2.QtQuick.QQuickItemGrabResult.url": (),
-# class PySide2.QtQuick.QQuickPaintedItem:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHint:
-# class PySide2.QtQuick.QQuickPaintedItem.PerformanceHints:
-# class PySide2.QtQuick.QQuickPaintedItem.RenderTarget:
-    "PySide2.QtQuick.QQuickPaintedItem.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickPaintedItem.antialiasing": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsBoundingRect": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsScale": (),
-    "PySide2.QtQuick.QQuickPaintedItem.contentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.fillColor": (),
-    "PySide2.QtQuick.QQuickPaintedItem.isTextureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.mipmap": (),
-    "PySide2.QtQuick.QQuickPaintedItem.opaquePainting": (),
-    "PySide2.QtQuick.QQuickPaintedItem.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.QtQuick.QQuickPaintedItem.performanceHints": (),
-    "PySide2.QtQuick.QQuickPaintedItem.releaseResources": (),
-    "PySide2.QtQuick.QQuickPaintedItem.renderTarget": (),
-    "PySide2.QtQuick.QQuickPaintedItem.resetContentsSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.setAntialiasing": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsScale": ('float',),
-    "PySide2.QtQuick.QQuickPaintedItem.setContentsSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.setFillColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickPaintedItem.setMipmap": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setOpaquePainting": ('bool',),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHint": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHint', 'bool'),
-    "PySide2.QtQuick.QQuickPaintedItem.setPerformanceHints": ('PySide2.QtQuick.QQuickPaintedItem.PerformanceHints',),
-    "PySide2.QtQuick.QQuickPaintedItem.setRenderTarget": ('PySide2.QtQuick.QQuickPaintedItem.RenderTarget',),
-    "PySide2.QtQuick.QQuickPaintedItem.setTextureSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtQuick.QQuickPaintedItem.textureProvider": (),
-    "PySide2.QtQuick.QQuickPaintedItem.textureSize": (),
-    "PySide2.QtQuick.QQuickPaintedItem.update": [(), ('PySide2.QtCore.QRect',)],
-    "PySide2.QtQuick.QQuickPaintedItem.updatePaintNode": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QQuickItem.UpdatePaintNodeData'),
-# class PySide2.QtQuick.QQuickRenderControl:
-    "PySide2.QtQuick.QQuickRenderControl.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickRenderControl.grab": (),
-    "PySide2.QtQuick.QQuickRenderControl.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QQuickRenderControl.invalidate": (),
-    "PySide2.QtQuick.QQuickRenderControl.polishItems": (),
-    "PySide2.QtQuick.QQuickRenderControl.prepareThread": ('PySide2.QtCore.QThread',),
-    "PySide2.QtQuick.QQuickRenderControl.render": (),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindow": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtQuick.QQuickRenderControl.renderWindowFor": ('PySide2.QtQuick.QQuickWindow', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtQuick.QQuickRenderControl.sync": (),
-# class PySide2.QtQuick.QQuickTextDocument:
-    "PySide2.QtQuick.QQuickTextDocument.__init__": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTextDocument.textDocument": (),
-# class PySide2.QtQuick.QQuickTextureFactory:
-    "PySide2.QtQuick.QQuickTextureFactory.__init__": (),
-    "PySide2.QtQuick.QQuickTextureFactory.createTexture": ('PySide2.QtQuick.QQuickWindow',),
-    "PySide2.QtQuick.QQuickTextureFactory.image": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureByteCount": (),
-    "PySide2.QtQuick.QQuickTextureFactory.textureFactoryForImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtQuick.QQuickTextureFactory.textureSize": (),
-# class PySide2.QtQuick.QQuickTransform:
-    "PySide2.QtQuick.QQuickTransform.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QQuickTransform.appendToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.applyTo": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QQuickTransform.prependToItem": ('PySide2.QtQuick.QQuickItem',),
-    "PySide2.QtQuick.QQuickTransform.update": (),
-# class PySide2.QtQuick.QQuickView:
-# class PySide2.QtQuick.QQuickView.ResizeMode:
-# class PySide2.QtQuick.QQuickView.Status:
-    "PySide2.QtQuick.QQuickView.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtGui.QWindow'), ('PySide2.QtCore.QUrl', 'PySide2.QtQuick.QQuickRenderControl'), ('PySide2.QtGui.QWindow',), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtGui.QWindow')],
-    "PySide2.QtQuick.QQuickView.engine": (),
-    "PySide2.QtQuick.QQuickView.errors": (),
-    "PySide2.QtQuick.QQuickView.initialSize": (),
-    "PySide2.QtQuick.QQuickView.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickView.resizeMode": (),
-    "PySide2.QtQuick.QQuickView.rootContext": (),
-    "PySide2.QtQuick.QQuickView.rootObject": (),
-    "PySide2.QtQuick.QQuickView.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuick.QQuickView.setInitialProperties": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtQuick.QQuickView.setResizeMode": ('PySide2.QtQuick.QQuickView.ResizeMode',),
-    "PySide2.QtQuick.QQuickView.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuick.QQuickView.sizeHint": (),
-    "PySide2.QtQuick.QQuickView.source": (),
-    "PySide2.QtQuick.QQuickView.status": (),
-    "PySide2.QtQuick.QQuickView.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-# class PySide2.QtQuick.QQuickWindow:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOption:
-# class PySide2.QtQuick.QQuickWindow.CreateTextureOptions:
-# class PySide2.QtQuick.QQuickWindow.NativeObjectType:
-# class PySide2.QtQuick.QQuickWindow.RenderStage:
-# class PySide2.QtQuick.QQuickWindow.SceneGraphError:
-# class PySide2.QtQuick.QQuickWindow.TextRenderType:
-    "PySide2.QtQuick.QQuickWindow.__init__": [('PySide2.QtGui.QWindow',), ('PySide2.QtQuick.QQuickRenderControl',)],
-    "PySide2.QtQuick.QQuickWindow.accessibleRoot": (),
-    "PySide2.QtQuick.QQuickWindow.activeFocusItem": (),
-    "PySide2.QtQuick.QQuickWindow.beginExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.clearBeforeRendering": (),
-    "PySide2.QtQuick.QQuickWindow.color": (),
-    "PySide2.QtQuick.QQuickWindow.contentItem": (),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.createTextureFromImage": [('PySide2.QtGui.QImage',), ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions')],
-    "PySide2.QtQuick.QQuickWindow.createTextureFromNativeObject": ('PySide2.QtQuick.QQuickWindow.NativeObjectType', 'int', 'int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QQuickWindow.CreateTextureOptions'),
-    "PySide2.QtQuick.QQuickWindow.effectiveDevicePixelRatio": (),
-    "PySide2.QtQuick.QQuickWindow.endExternalCommands": (),
-    "PySide2.QtQuick.QQuickWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuick.QQuickWindow.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.focusObject": (),
-    "PySide2.QtQuick.QQuickWindow.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuick.QQuickWindow.grabWindow": (),
-    "PySide2.QtQuick.QQuickWindow.hasDefaultAlphaBuffer": (),
-    "PySide2.QtQuick.QQuickWindow.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuick.QQuickWindow.incubationController": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentOpenGLContext": (),
-    "PySide2.QtQuick.QQuickWindow.isPersistentSceneGraph": (),
-    "PySide2.QtQuick.QQuickWindow.isSceneGraphInitialized": (),
-    "PySide2.QtQuick.QQuickWindow.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseGrabberItem": (),
-    "PySide2.QtQuick.QQuickWindow.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuick.QQuickWindow.openglContext": (),
-    "PySide2.QtQuick.QQuickWindow.releaseResources": (),
-    "PySide2.QtQuick.QQuickWindow.renderTarget": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetId": (),
-    "PySide2.QtQuick.QQuickWindow.renderTargetSize": (),
-    "PySide2.QtQuick.QQuickWindow.resetOpenGLState": (),
-    "PySide2.QtQuick.QQuickWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuick.QQuickWindow.sceneGraphBackend": (),
-    "PySide2.QtQuick.QQuickWindow.scheduleRenderJob": ('PySide2.QtCore.QRunnable', 'PySide2.QtQuick.QQuickWindow.RenderStage'),
-    "PySide2.QtQuick.QQuickWindow.sendEvent": ('PySide2.QtQuick.QQuickItem', 'PySide2.QtCore.QEvent'),
-    "PySide2.QtQuick.QQuickWindow.setClearBeforeRendering": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QQuickWindow.setDefaultAlphaBuffer": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentOpenGLContext": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setPersistentSceneGraph": ('bool',),
-    "PySide2.QtQuick.QQuickWindow.setRenderTarget": [('PySide2.QtGui.QOpenGLFramebufferObject',), ('int', 'PySide2.QtCore.QSize')],
-    "PySide2.QtQuick.QQuickWindow.setSceneGraphBackend": ('str',),
-    "PySide2.QtQuick.QQuickWindow.setTextRenderType": ('PySide2.QtQuick.QQuickWindow.TextRenderType',),
-    "PySide2.QtQuick.QQuickWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuick.QQuickWindow.textRenderType": (),
-    "PySide2.QtQuick.QQuickWindow.update": (),
-    "PySide2.QtQuick.QQuickWindow.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtQuick.QSGAbstractRenderer:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearMode:
-# class PySide2.QtQuick.QSGAbstractRenderer.ClearModeBit:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlag:
-# class PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags:
-    "PySide2.QtQuick.QSGAbstractRenderer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearColor": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.clearMode": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.deviceRect": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.nodeChanged": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode.DirtyState'),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrix": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.projectionMatrixWithNativeNDC": (),
-    "PySide2.QtQuick.QSGAbstractRenderer.renderScene": ('int',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setClearMode": ('PySide2.QtQuick.QSGAbstractRenderer.ClearMode',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setDeviceRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixToRect": [('PySide2.QtCore.QRectF',), ('PySide2.QtCore.QRectF', 'PySide2.QtQuick.QSGAbstractRenderer.MatrixTransformFlags')],
-    "PySide2.QtQuick.QSGAbstractRenderer.setProjectionMatrixWithNativeNDC": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGAbstractRenderer.setViewportRect": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QSize',)],
-    "PySide2.QtQuick.QSGAbstractRenderer.viewportRect": (),
-# class PySide2.QtQuick.QSGBasicGeometryNode:
-    "PySide2.QtQuick.QSGBasicGeometryNode.__init__": ('PySide2.QtQuick.QSGNode.NodeType',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.clipList": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.geometry": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.matrix": (),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setGeometry": ('PySide2.QtQuick.QSGGeometry',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererClipList": ('PySide2.QtQuick.QSGClipNode',),
-    "PySide2.QtQuick.QSGBasicGeometryNode.setRendererMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSGClipNode:
-    "PySide2.QtQuick.QSGClipNode.__init__": (),
-    "PySide2.QtQuick.QSGClipNode.clipRect": (),
-    "PySide2.QtQuick.QSGClipNode.isRectangular": (),
-    "PySide2.QtQuick.QSGClipNode.setClipRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGClipNode.setIsRectangular": ('bool',),
-# class PySide2.QtQuick.QSGDynamicTexture:
-    "PySide2.QtQuick.QSGDynamicTexture.__init__": (),
-    "PySide2.QtQuick.QSGDynamicTexture.updateTexture": (),
-# class PySide2.QtQuick.QSGEngine:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOption:
-# class PySide2.QtQuick.QSGEngine.CreateTextureOptions:
-    "PySide2.QtQuick.QSGEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtQuick.QSGEngine.createRenderer": (),
-    "PySide2.QtQuick.QSGEngine.createTextureFromId": ('int', 'PySide2.QtCore.QSize', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.createTextureFromImage": ('PySide2.QtGui.QImage', 'PySide2.QtQuick.QSGEngine.CreateTextureOptions'),
-    "PySide2.QtQuick.QSGEngine.initialize": ('PySide2.QtGui.QOpenGLContext',),
-    "PySide2.QtQuick.QSGEngine.invalidate": (),
-# class PySide2.QtQuick.QSGGeometry:
-# class PySide2.QtQuick.QSGGeometry.Attribute:
-    "PySide2.QtQuick.QSGGeometry.Attribute.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Attribute',)],
-    "PySide2.QtQuick.QSGGeometry.Attribute.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Attribute.create": ('int', 'int', 'int', 'bool'),
-    "PySide2.QtQuick.QSGGeometry.Attribute.createWithAttributeType": ('int', 'int', 'int', 'PySide2.QtQuick.QSGGeometry.AttributeType'),
-# class PySide2.QtQuick.QSGGeometry.AttributeSet:
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__init__": [(), ('PySide2.QtQuick.QSGGeometry.AttributeSet',)],
-    "PySide2.QtQuick.QSGGeometry.AttributeSet.__copy__": (),
-# class PySide2.QtQuick.QSGGeometry.AttributeType:
-# class PySide2.QtQuick.QSGGeometry.ColoredPoint2D:
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.ColoredPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.ColoredPoint2D.set": ('float', 'float', 'int', 'int', 'int', 'int'),
-# class PySide2.QtQuick.QSGGeometry.DataPattern:
-# class PySide2.QtQuick.QSGGeometry.DrawingMode:
-# class PySide2.QtQuick.QSGGeometry.Point2D:
-    "PySide2.QtQuick.QSGGeometry.Point2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.Point2D',)],
-    "PySide2.QtQuick.QSGGeometry.Point2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.Point2D.set": ('float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.TexturedPoint2D:
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__init__": [(), ('PySide2.QtQuick.QSGGeometry.TexturedPoint2D',)],
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.__copy__": (),
-    "PySide2.QtQuick.QSGGeometry.TexturedPoint2D.set": ('float', 'float', 'float', 'float'),
-# class PySide2.QtQuick.QSGGeometry.Type:
-    "PySide2.QtQuick.QSGGeometry.__init__": ('PySide2.QtQuick.QSGGeometry.AttributeSet', 'int', 'int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.allocate": ('int', 'int'),
-    "PySide2.QtQuick.QSGGeometry.attributeCount": (),
-    "PySide2.QtQuick.QSGGeometry.attributes": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_ColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_Point2D": (),
-    "PySide2.QtQuick.QSGGeometry.defaultAttributes_TexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.drawingMode": (),
-    "PySide2.QtQuick.QSGGeometry.indexCount": (),
-    "PySide2.QtQuick.QSGGeometry.indexData": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUInt": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataAsUShort": (),
-    "PySide2.QtQuick.QSGGeometry.indexDataPattern": (),
-    "PySide2.QtQuick.QSGGeometry.indexType": (),
-    "PySide2.QtQuick.QSGGeometry.lineWidth": (),
-    "PySide2.QtQuick.QSGGeometry.markIndexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.markVertexDataDirty": (),
-    "PySide2.QtQuick.QSGGeometry.setDrawingMode": ('int',),
-    "PySide2.QtQuick.QSGGeometry.setIndexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.setLineWidth": ('float',),
-    "PySide2.QtQuick.QSGGeometry.setVertexDataPattern": ('PySide2.QtQuick.QSGGeometry.DataPattern',),
-    "PySide2.QtQuick.QSGGeometry.sizeOfIndex": (),
-    "PySide2.QtQuick.QSGGeometry.sizeOfVertex": (),
-    "PySide2.QtQuick.QSGGeometry.updateColoredRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.updateTexturedRectGeometry": ('PySide2.QtQuick.QSGGeometry', 'PySide2.QtCore.QRectF', 'PySide2.QtCore.QRectF'),
-    "PySide2.QtQuick.QSGGeometry.vertexCount": (),
-    "PySide2.QtQuick.QSGGeometry.vertexData": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsColoredPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataAsTexturedPoint2D": (),
-    "PySide2.QtQuick.QSGGeometry.vertexDataPattern": (),
-# class PySide2.QtQuick.QSGGeometryNode:
-    "PySide2.QtQuick.QSGGeometryNode.__init__": (),
-    "PySide2.QtQuick.QSGGeometryNode.inheritedOpacity": (),
-    "PySide2.QtQuick.QSGGeometryNode.renderOrder": (),
-    "PySide2.QtQuick.QSGGeometryNode.setInheritedOpacity": ('float',),
-    "PySide2.QtQuick.QSGGeometryNode.setRenderOrder": ('int',),
-# class PySide2.QtQuick.QSGMaterialType:
-    "PySide2.QtQuick.QSGMaterialType.__init__": (),
-# class PySide2.QtQuick.QSGNode:
-# class PySide2.QtQuick.QSGNode.DirtyState:
-# class PySide2.QtQuick.QSGNode.DirtyStateBit:
-# class PySide2.QtQuick.QSGNode.Flag:
-# class PySide2.QtQuick.QSGNode.Flags:
-# class PySide2.QtQuick.QSGNode.NodeType:
-    "PySide2.QtQuick.QSGNode.__init__": [(), ('PySide2.QtQuick.QSGNode.NodeType',)],
-    "PySide2.QtQuick.QSGNode.appendChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.childAtIndex": ('int',),
-    "PySide2.QtQuick.QSGNode.childCount": (),
-    "PySide2.QtQuick.QSGNode.clearDirty": (),
-    "PySide2.QtQuick.QSGNode.dirtyState": (),
-    "PySide2.QtQuick.QSGNode.firstChild": (),
-    "PySide2.QtQuick.QSGNode.flags": (),
-    "PySide2.QtQuick.QSGNode.insertChildNodeAfter": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.insertChildNodeBefore": ('PySide2.QtQuick.QSGNode', 'PySide2.QtQuick.QSGNode'),
-    "PySide2.QtQuick.QSGNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGNode.lastChild": (),
-    "PySide2.QtQuick.QSGNode.markDirty": ('PySide2.QtQuick.QSGNode.DirtyState',),
-    "PySide2.QtQuick.QSGNode.nextSibling": (),
-    "PySide2.QtQuick.QSGNode.parent": (),
-    "PySide2.QtQuick.QSGNode.prependChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.preprocess": (),
-    "PySide2.QtQuick.QSGNode.previousSibling": (),
-    "PySide2.QtQuick.QSGNode.removeAllChildNodes": (),
-    "PySide2.QtQuick.QSGNode.removeChildNode": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.reparentChildNodesTo": ('PySide2.QtQuick.QSGNode',),
-    "PySide2.QtQuick.QSGNode.setFlag": ('PySide2.QtQuick.QSGNode.Flag', 'bool'),
-    "PySide2.QtQuick.QSGNode.setFlags": ('PySide2.QtQuick.QSGNode.Flags', 'bool'),
-    "PySide2.QtQuick.QSGNode.type": (),
-# class PySide2.QtQuick.QSGOpacityNode:
-    "PySide2.QtQuick.QSGOpacityNode.__init__": (),
-    "PySide2.QtQuick.QSGOpacityNode.combinedOpacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.isSubtreeBlocked": (),
-    "PySide2.QtQuick.QSGOpacityNode.opacity": (),
-    "PySide2.QtQuick.QSGOpacityNode.setCombinedOpacity": ('float',),
-    "PySide2.QtQuick.QSGOpacityNode.setOpacity": ('float',),
-# class PySide2.QtQuick.QSGSimpleRectNode:
-    "PySide2.QtQuick.QSGSimpleRectNode.__init__": [(), ('PySide2.QtCore.QRectF', 'PySide2.QtGui.QColor')],
-    "PySide2.QtQuick.QSGSimpleRectNode.color": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleRectNode.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuick.QSGSimpleRectNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-# class PySide2.QtQuick.QSGSimpleTextureNode:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformFlag:
-# class PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode:
-    "PySide2.QtQuick.QSGSimpleTextureNode.__init__": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.filtering": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.ownsTexture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.rect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setOwnsTexture": ('bool',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setSourceRect": [('PySide2.QtCore.QRectF',), ('float', 'float', 'float', 'float')],
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTexture": ('PySide2.QtQuick.QSGTexture',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.setTextureCoordinatesTransform": ('PySide2.QtQuick.QSGSimpleTextureNode.TextureCoordinatesTransformMode',),
-    "PySide2.QtQuick.QSGSimpleTextureNode.sourceRect": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.texture": (),
-    "PySide2.QtQuick.QSGSimpleTextureNode.textureCoordinatesTransform": (),
-# class PySide2.QtQuick.QSGTexture:
-# class PySide2.QtQuick.QSGTexture.AnisotropyLevel:
-# class PySide2.QtQuick.QSGTexture.Filtering:
-# class PySide2.QtQuick.QSGTexture.WrapMode:
-    "PySide2.QtQuick.QSGTexture.__init__": (),
-    "PySide2.QtQuick.QSGTexture.anisotropyLevel": (),
-    "PySide2.QtQuick.QSGTexture.bind": (),
-    "PySide2.QtQuick.QSGTexture.comparisonKey": (),
-    "PySide2.QtQuick.QSGTexture.convertToNormalizedSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtQuick.QSGTexture.filtering": (),
-    "PySide2.QtQuick.QSGTexture.hasAlphaChannel": (),
-    "PySide2.QtQuick.QSGTexture.hasMipmaps": (),
-    "PySide2.QtQuick.QSGTexture.horizontalWrapMode": (),
-    "PySide2.QtQuick.QSGTexture.isAtlasTexture": (),
-    "PySide2.QtQuick.QSGTexture.mipmapFiltering": (),
-    "PySide2.QtQuick.QSGTexture.normalizedTextureSubRect": (),
-    "PySide2.QtQuick.QSGTexture.removedFromAtlas": (),
-    "PySide2.QtQuick.QSGTexture.setAnisotropyLevel": ('PySide2.QtQuick.QSGTexture.AnisotropyLevel',),
-    "PySide2.QtQuick.QSGTexture.setFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setHorizontalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.setMipmapFiltering": ('PySide2.QtQuick.QSGTexture.Filtering',),
-    "PySide2.QtQuick.QSGTexture.setVerticalWrapMode": ('PySide2.QtQuick.QSGTexture.WrapMode',),
-    "PySide2.QtQuick.QSGTexture.textureId": (),
-    "PySide2.QtQuick.QSGTexture.textureSize": (),
-    "PySide2.QtQuick.QSGTexture.updateBindOptions": ('bool',),
-    "PySide2.QtQuick.QSGTexture.verticalWrapMode": (),
-# class PySide2.QtQuick.QSGTextureProvider:
-    "PySide2.QtQuick.QSGTextureProvider.__init__": (),
-    "PySide2.QtQuick.QSGTextureProvider.texture": (),
-# class PySide2.QtQuick.QSGTransformNode:
-    "PySide2.QtQuick.QSGTransformNode.__init__": (),
-    "PySide2.QtQuick.QSGTransformNode.combinedMatrix": (),
-    "PySide2.QtQuick.QSGTransformNode.matrix": (),
-    "PySide2.QtQuick.QSGTransformNode.setCombinedMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.QtQuick.QSGTransformNode.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-# class PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >:
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.__copy__": (),
-    "PySide2.QtQuick.QSharedPointer<QQuickItemGrabResult >.data": (),
-    }) if "PySide2.QtQuick" in sys.modules else None
-# Module PySide2.QtQuickWidgets
-sig_dict.update({
-# class PySide2.QtQuickWidgets.QQuickWidget:
-# class PySide2.QtQuickWidgets.QQuickWidget.ResizeMode:
-# class PySide2.QtQuickWidgets.QQuickWidget.Status:
-    "PySide2.QtQuickWidgets.QQuickWidget.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtQml.QQmlEngine', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtQuickWidgets.QQuickWidget.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.engine": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.errors": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusInEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusNextPrevChild": ('bool',),
-    "PySide2.QtQuickWidgets.QQuickWidget.focusOutEvent": ('PySide2.QtGui.QFocusEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.format": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.grabFramebuffer": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.initialSize": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyPressEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.keyReleaseEvent": ('PySide2.QtGui.QKeyEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.quickWindow": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.resizeMode": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootContext": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.rootObject": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setContent": ('PySide2.QtCore.QUrl', 'PySide2.QtQml.QQmlComponent', 'PySide2.QtCore.QObject'),
-    "PySide2.QtQuickWidgets.QQuickWidget.setFormat": ('PySide2.QtGui.QSurfaceFormat',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setResizeMode": ('PySide2.QtQuickWidgets.QQuickWidget.ResizeMode',),
-    "PySide2.QtQuickWidgets.QQuickWidget.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtQuickWidgets.QQuickWidget.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.sizeHint": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.source": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.status": (),
-    "PySide2.QtQuickWidgets.QQuickWidget.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtQuickWidgets.QQuickWidget.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-    }) if "PySide2.QtQuickWidgets" in sys.modules else None
-# Module PySide2.QtRemoteObjects
-sig_dict.update({
-# class PySide2.QtRemoteObjects.QAbstractItemModelReplica:
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.availableRoles": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.columnCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.data": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.flags": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasChildren": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.hasData": ('PySide2.QtCore.QModelIndex', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.headerData": ('int', 'PySide2.QtCore.Qt.Orientation', 'int'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.index": ('int', 'int', 'PySide2.QtCore.QModelIndex'),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.parent": [(), ('PySide2.QtCore.QModelIndex',)],
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.roleNames": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.rowCount": ('PySide2.QtCore.QModelIndex',),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.selectionModel": (),
-    "PySide2.QtRemoteObjects.QAbstractItemModelReplica.setData": ('PySide2.QtCore.QModelIndex', 'typing.Any', 'int'),
-# class PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-# class PySide2.QtRemoteObjects.QRemoteObjectDynamicReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHost.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase:
-# class PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas:
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.addHostSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.disableRemoting": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.enableRemoting": [('PySide2.QtCore.QAbstractItemModel', 'str', 'typing.List[int]', 'PySide2.QtCore.QItemSelectionModel'), ('PySide2.QtCore.QObject', 'str')],
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.hostUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.proxy": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.reverseProxy": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setHostUrl": ('PySide2.QtCore.QUrl', 'PySide2.QtRemoteObjects.QRemoteObjectHostBase.AllowedSchemas'),
-    "PySide2.QtRemoteObjects.QRemoteObjectHostBase.setName": ('str',),
-# class PySide2.QtRemoteObjects.QRemoteObjectNode:
-# class PySide2.QtRemoteObjects.QRemoteObjectNode.ErrorCode:
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject')],
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireDynamic": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.acquireModel": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.addClientSideConnection": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.connectToNode": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.heartbeatInterval": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.instances": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.lastError": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.persistedStore": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registry": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.registryUrl": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setHeartbeatInterval": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setName": ('str',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setPersistedStore": ('PySide2.QtRemoteObjects.QRemoteObjectAbstractPersistedStore',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.timerEvent": ('PySide2.QtCore.QTimerEvent',),
-    "PySide2.QtRemoteObjects.QRemoteObjectNode.waitForRegistry": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall:
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCall.Error:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.__init__": [(), ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall',)],
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.error": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.fromCompletedCall": ('typing.Any',),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.returnValue": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCall.waitForFinished": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher:
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.__init__": ('PySide2.QtRemoteObjects.QRemoteObjectPendingCall', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.isFinished": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectPendingCallWatcher.waitForFinished": [(), ('int',)],
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistry:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.pushToRegistryIfNeeded": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistry.registerMetatypes": (),
-# class PySide2.QtRemoteObjects.QRemoteObjectRegistryHost:
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.__init__": ('PySide2.QtCore.QUrl', 'PySide2.QtCore.QObject'),
-    "PySide2.QtRemoteObjects.QRemoteObjectRegistryHost.setRegistryUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica:
-# class PySide2.QtRemoteObjects.QRemoteObjectReplica.State:
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.__init__": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initialize": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.initializeNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode', 'str'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isInitialized": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.isReplicaValid": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.node": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.persistProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.propAsVariant": ('int',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.retrieveProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.send": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.sendWithReply": ('PySide2.QtCore.QMetaObject.Call', 'int', 'typing.Sequence[typing.Any]'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setChild": ('int', 'typing.Any'),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setNode": ('PySide2.QtRemoteObjects.QRemoteObjectNode',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.setProperties": ('typing.Sequence[typing.Any]',),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.state": (),
-    "PySide2.QtRemoteObjects.QRemoteObjectReplica.waitForSource": ('int',),
-# class PySide2.QtRemoteObjects.QRemoteObjectSettingsStore:
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.restoreProperties": ('str', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtRemoteObjects.QRemoteObjectSettingsStore.saveProperties": ('str', 'PySide2.QtCore.QByteArray', 'typing.Sequence[typing.Any]'),
-    }) if "PySide2.QtRemoteObjects" in sys.modules else None
-# Module PySide2.QtScxml
-sig_dict.update({
-# class PySide2.QtScxml.QScxmlCompiler:
-# class PySide2.QtScxml.QScxmlCompiler.Loader:
-    "PySide2.QtScxml.QScxmlCompiler.Loader.__init__": (),
-    "PySide2.QtScxml.QScxmlCompiler.Loader.load": ('str', 'str'),
-    "PySide2.QtScxml.QScxmlCompiler.__init__": ('PySide2.QtCore.QXmlStreamReader',),
-    "PySide2.QtScxml.QScxmlCompiler.compile": (),
-    "PySide2.QtScxml.QScxmlCompiler.errors": (),
-    "PySide2.QtScxml.QScxmlCompiler.fileName": (),
-    "PySide2.QtScxml.QScxmlCompiler.loader": (),
-    "PySide2.QtScxml.QScxmlCompiler.setFileName": ('str',),
-    "PySide2.QtScxml.QScxmlCompiler.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-# class PySide2.QtScxml.QScxmlCppDataModel:
-    "PySide2.QtScxml.QScxmlCppDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlCppDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlCppDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.inState": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlEvent": (),
-    "PySide2.QtScxml.QScxmlCppDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlCppDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlCppDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlDataModel:
-# class PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody:
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.__init__": (),
-    "PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody.run": (),
-    "PySide2.QtScxml.QScxmlDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlDataModel.setStateMachine": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlDataModel.setup": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlDataModel.stateMachine": (),
-# class PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlDynamicScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlEcmaScriptDataModel:
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlEcmaScriptDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlError:
-    "PySide2.QtScxml.QScxmlError.__init__": [(), ('PySide2.QtScxml.QScxmlError',), ('str', 'int', 'int', 'str')],
-    "PySide2.QtScxml.QScxmlError.__copy__": (),
-    "PySide2.QtScxml.QScxmlError.column": (),
-    "PySide2.QtScxml.QScxmlError.description": (),
-    "PySide2.QtScxml.QScxmlError.fileName": (),
-    "PySide2.QtScxml.QScxmlError.isValid": (),
-    "PySide2.QtScxml.QScxmlError.line": (),
-    "PySide2.QtScxml.QScxmlError.toString": (),
-# class PySide2.QtScxml.QScxmlEvent:
-# class PySide2.QtScxml.QScxmlEvent.EventType:
-    "PySide2.QtScxml.QScxmlEvent.__init__": [(), ('PySide2.QtScxml.QScxmlEvent',)],
-    "PySide2.QtScxml.QScxmlEvent.clear": (),
-    "PySide2.QtScxml.QScxmlEvent.data": (),
-    "PySide2.QtScxml.QScxmlEvent.delay": (),
-    "PySide2.QtScxml.QScxmlEvent.errorMessage": (),
-    "PySide2.QtScxml.QScxmlEvent.eventType": (),
-    "PySide2.QtScxml.QScxmlEvent.invokeId": (),
-    "PySide2.QtScxml.QScxmlEvent.isErrorEvent": (),
-    "PySide2.QtScxml.QScxmlEvent.name": (),
-    "PySide2.QtScxml.QScxmlEvent.origin": (),
-    "PySide2.QtScxml.QScxmlEvent.originType": (),
-    "PySide2.QtScxml.QScxmlEvent.scxmlType": (),
-    "PySide2.QtScxml.QScxmlEvent.sendId": (),
-    "PySide2.QtScxml.QScxmlEvent.setData": ('typing.Any',),
-    "PySide2.QtScxml.QScxmlEvent.setDelay": ('int',),
-    "PySide2.QtScxml.QScxmlEvent.setErrorMessage": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setEventType": ('PySide2.QtScxml.QScxmlEvent.EventType',),
-    "PySide2.QtScxml.QScxmlEvent.setInvokeId": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setName": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOrigin": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setOriginType": ('str',),
-    "PySide2.QtScxml.QScxmlEvent.setSendId": ('str',),
-# class PySide2.QtScxml.QScxmlExecutableContent:
-# class PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.AssignmentInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.EvaluatorInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ForeachInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo:
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__init__": [(), ('PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo',)],
-    "PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo.__copy__": (),
-# class PySide2.QtScxml.QScxmlInvokableService:
-    "PySide2.QtScxml.QScxmlInvokableService.__init__": ('PySide2.QtScxml.QScxmlStateMachine', 'PySide2.QtScxml.QScxmlInvokableServiceFactory'),
-    "PySide2.QtScxml.QScxmlInvokableService.id": (),
-    "PySide2.QtScxml.QScxmlInvokableService.name": (),
-    "PySide2.QtScxml.QScxmlInvokableService.parentStateMachine": (),
-    "PySide2.QtScxml.QScxmlInvokableService.postEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlInvokableService.start": (),
-# class PySide2.QtScxml.QScxmlInvokableServiceFactory:
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.__init__": ('PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.invokeInfo": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.names": (),
-    "PySide2.QtScxml.QScxmlInvokableServiceFactory.parameters": (),
-# class PySide2.QtScxml.QScxmlNullDataModel:
-    "PySide2.QtScxml.QScxmlNullDataModel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateAssignment": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateForeach": ('int', 'PySide2.QtScxml.QScxmlDataModel.ForeachLoopBody'),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateInitialization": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToBool": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToString": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVariant": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.evaluateToVoid": ('int',),
-    "PySide2.QtScxml.QScxmlNullDataModel.hasScxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.scxmlProperty": ('str',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlEvent": ('PySide2.QtScxml.QScxmlEvent',),
-    "PySide2.QtScxml.QScxmlNullDataModel.setScxmlProperty": ('str', 'typing.Any', 'str'),
-    "PySide2.QtScxml.QScxmlNullDataModel.setup": ('typing.Dict[str, typing.Any]',),
-# class PySide2.QtScxml.QScxmlStateMachine:
-    "PySide2.QtScxml.QScxmlStateMachine.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStateMachine.activeStateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.cancelDelayedEvent": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToEvent": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.connectToState": ('str', 'PySide2.QtCore.QObject', 'str', 'PySide2.QtCore.Qt.ConnectionType'),
-    "PySide2.QtScxml.QScxmlStateMachine.dataModel": (),
-    "PySide2.QtScxml.QScxmlStateMachine.fromData": ('PySide2.QtCore.QIODevice', 'str'),
-    "PySide2.QtScxml.QScxmlStateMachine.fromFile": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.init": (),
-    "PySide2.QtScxml.QScxmlStateMachine.initialValues": (),
-    "PySide2.QtScxml.QScxmlStateMachine.invokedServices": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isActive": [('int',), ('str',)],
-    "PySide2.QtScxml.QScxmlStateMachine.isDispatchableTarget": ('str',),
-    "PySide2.QtScxml.QScxmlStateMachine.isInitialized": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isInvoked": (),
-    "PySide2.QtScxml.QScxmlStateMachine.isRunning": (),
-    "PySide2.QtScxml.QScxmlStateMachine.loader": (),
-    "PySide2.QtScxml.QScxmlStateMachine.name": (),
-    "PySide2.QtScxml.QScxmlStateMachine.parseErrors": (),
-    "PySide2.QtScxml.QScxmlStateMachine.sessionId": (),
-    "PySide2.QtScxml.QScxmlStateMachine.setDataModel": ('PySide2.QtScxml.QScxmlDataModel',),
-    "PySide2.QtScxml.QScxmlStateMachine.setInitialValues": ('typing.Dict[str, typing.Any]',),
-    "PySide2.QtScxml.QScxmlStateMachine.setLoader": ('PySide2.QtScxml.QScxmlCompiler.Loader',),
-    "PySide2.QtScxml.QScxmlStateMachine.setRunning": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.setTableData": ('PySide2.QtScxml.QScxmlTableData',),
-    "PySide2.QtScxml.QScxmlStateMachine.start": (),
-    "PySide2.QtScxml.QScxmlStateMachine.stateNames": ('bool',),
-    "PySide2.QtScxml.QScxmlStateMachine.stop": (),
-    "PySide2.QtScxml.QScxmlStateMachine.submitEvent": [('PySide2.QtScxml.QScxmlEvent',), ('str',), ('str', 'typing.Any')],
-    "PySide2.QtScxml.QScxmlStateMachine.tableData": (),
-# class PySide2.QtScxml.QScxmlStaticScxmlServiceFactory:
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.__init__": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScxml.QScxmlExecutableContent.InvokeInfo', 'typing.List[int]', 'typing.List[PySide2.QtScxml.QScxmlExecutableContent.ParameterInfo]', 'PySide2.QtCore.QObject'),
-    "PySide2.QtScxml.QScxmlStaticScxmlServiceFactory.invoke": ('PySide2.QtScxml.QScxmlStateMachine',),
-# class PySide2.QtScxml.QScxmlTableData:
-    "PySide2.QtScxml.QScxmlTableData.__init__": (),
-    "PySide2.QtScxml.QScxmlTableData.assignmentInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.dataNames": (),
-    "PySide2.QtScxml.QScxmlTableData.evaluatorInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.foreachInfo": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.initialSetup": (),
-    "PySide2.QtScxml.QScxmlTableData.instructions": (),
-    "PySide2.QtScxml.QScxmlTableData.name": (),
-    "PySide2.QtScxml.QScxmlTableData.serviceFactory": ('int',),
-    "PySide2.QtScxml.QScxmlTableData.stateMachineTable": (),
-    "PySide2.QtScxml.QScxmlTableData.string": ('int',),
-    }) if "PySide2.QtScxml" in sys.modules else None
-# Module PySide2.QtScript
-sig_dict.update({
-# class PySide2.QtScript.QScriptClass:
-# class PySide2.QtScript.QScriptClass.Extension:
-# class PySide2.QtScript.QScriptClass.QueryFlag:
-    "PySide2.QtScript.QScriptClass.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptClass.engine": (),
-    "PySide2.QtScript.QScriptClass.extension": ('PySide2.QtScript.QScriptClass.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptClass.name": (),
-    "PySide2.QtScript.QScriptClass.newIterator": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClass.property": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.propertyFlags": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int'),
-    "PySide2.QtScript.QScriptClass.prototype": (),
-    "PySide2.QtScript.QScriptClass.setProperty": ('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptString', 'int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptClass.supportsExtension": ('PySide2.QtScript.QScriptClass.Extension',),
-# class PySide2.QtScript.QScriptClassPropertyIterator:
-    "PySide2.QtScript.QScriptClassPropertyIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptClassPropertyIterator.flags": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasNext": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.id": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.name": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.object": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.previous": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toBack": (),
-    "PySide2.QtScript.QScriptClassPropertyIterator.toFront": (),
-# class PySide2.QtScript.QScriptContext:
-# class PySide2.QtScript.QScriptContext.Error:
-# class PySide2.QtScript.QScriptContext.ExecutionState:
-    "PySide2.QtScript.QScriptContext.activationObject": (),
-    "PySide2.QtScript.QScriptContext.argument": ('int',),
-    "PySide2.QtScript.QScriptContext.argumentCount": (),
-    "PySide2.QtScript.QScriptContext.argumentsObject": (),
-    "PySide2.QtScript.QScriptContext.backtrace": (),
-    "PySide2.QtScript.QScriptContext.callee": (),
-    "PySide2.QtScript.QScriptContext.engine": (),
-    "PySide2.QtScript.QScriptContext.isCalledAsConstructor": (),
-    "PySide2.QtScript.QScriptContext.parentContext": (),
-    "PySide2.QtScript.QScriptContext.popScope": (),
-    "PySide2.QtScript.QScriptContext.pushScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.returnValue": (),
-    "PySide2.QtScript.QScriptContext.scopeChain": (),
-    "PySide2.QtScript.QScriptContext.setActivationObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setReturnValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.setThisObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.state": (),
-    "PySide2.QtScript.QScriptContext.thisObject": (),
-    "PySide2.QtScript.QScriptContext.throwError": [('PySide2.QtScript.QScriptContext.Error', 'str'), ('str',)],
-    "PySide2.QtScript.QScriptContext.throwValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptContext.toString": (),
-# class PySide2.QtScript.QScriptContextInfo:
-# class PySide2.QtScript.QScriptContextInfo.FunctionType:
-    "PySide2.QtScript.QScriptContextInfo.__init__": [(), ('PySide2.QtScript.QScriptContext',), ('PySide2.QtScript.QScriptContextInfo',)],
-    "PySide2.QtScript.QScriptContextInfo.__copy__": (),
-    "PySide2.QtScript.QScriptContextInfo.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtScript.QScriptContextInfo.columnNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.fileName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionEndLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionMetaIndex": (),
-    "PySide2.QtScript.QScriptContextInfo.functionName": (),
-    "PySide2.QtScript.QScriptContextInfo.functionParameterNames": (),
-    "PySide2.QtScript.QScriptContextInfo.functionStartLineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.functionType": (),
-    "PySide2.QtScript.QScriptContextInfo.isNull": (),
-    "PySide2.QtScript.QScriptContextInfo.lineNumber": (),
-    "PySide2.QtScript.QScriptContextInfo.scriptId": (),
-# class PySide2.QtScript.QScriptEngine:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOption:
-# class PySide2.QtScript.QScriptEngine.QObjectWrapOptions:
-# class PySide2.QtScript.QScriptEngine.ValueOwnership:
-    "PySide2.QtScript.QScriptEngine.__init__": [(), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtScript.QScriptEngine.abortEvaluation": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.agent": (),
-    "PySide2.QtScript.QScriptEngine.availableExtensions": (),
-    "PySide2.QtScript.QScriptEngine.canEvaluate": ('str',),
-    "PySide2.QtScript.QScriptEngine.clearExceptions": (),
-    "PySide2.QtScript.QScriptEngine.collectGarbage": (),
-    "PySide2.QtScript.QScriptEngine.currentContext": (),
-    "PySide2.QtScript.QScriptEngine.defaultPrototype": ('int',),
-    "PySide2.QtScript.QScriptEngine.evaluate": [('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptEngine.globalObject": (),
-    "PySide2.QtScript.QScriptEngine.hasUncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.importExtension": ('str',),
-    "PySide2.QtScript.QScriptEngine.importedExtensions": (),
-    "PySide2.QtScript.QScriptEngine.installTranslatorFunctions": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.isEvaluating": (),
-    "PySide2.QtScript.QScriptEngine.newActivationObject": (),
-    "PySide2.QtScript.QScriptEngine.newArray": ('int',),
-    "PySide2.QtScript.QScriptEngine.newDate": [('PySide2.QtCore.QDateTime',), ('float',)],
-    "PySide2.QtScript.QScriptEngine.newObject": [(), ('PySide2.QtScript.QScriptClass', 'PySide2.QtScript.QScriptValue')],
-    "PySide2.QtScript.QScriptEngine.newQMetaObject": ('PySide2.QtCore.QMetaObject', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.newQObject": [('PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions'), ('PySide2.QtScript.QScriptValue', 'PySide2.QtCore.QObject', 'PySide2.QtScript.QScriptEngine.ValueOwnership', 'PySide2.QtScript.QScriptEngine.QObjectWrapOptions')],
-    "PySide2.QtScript.QScriptEngine.newRegExp": [('PySide2.QtCore.QRegExp',), ('str', 'str')],
-    "PySide2.QtScript.QScriptEngine.newVariant": [('PySide2.QtScript.QScriptValue', 'typing.Any'), ('typing.Any',)],
-    "PySide2.QtScript.QScriptEngine.nullValue": (),
-    "PySide2.QtScript.QScriptEngine.objectById": ('int',),
-    "PySide2.QtScript.QScriptEngine.popContext": (),
-    "PySide2.QtScript.QScriptEngine.processEventsInterval": (),
-    "PySide2.QtScript.QScriptEngine.pushContext": (),
-    "PySide2.QtScript.QScriptEngine.reportAdditionalMemoryCost": ('int',),
-    "PySide2.QtScript.QScriptEngine.setAgent": ('PySide2.QtScript.QScriptEngineAgent',),
-    "PySide2.QtScript.QScriptEngine.setDefaultPrototype": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngine.setGlobalObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.setProcessEventsInterval": ('int',),
-    "PySide2.QtScript.QScriptEngine.toObject": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptEngine.toStringHandle": ('str',),
-    "PySide2.QtScript.QScriptEngine.uncaughtException": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionBacktrace": (),
-    "PySide2.QtScript.QScriptEngine.uncaughtExceptionLineNumber": (),
-    "PySide2.QtScript.QScriptEngine.undefinedValue": (),
-# class PySide2.QtScript.QScriptEngineAgent:
-# class PySide2.QtScript.QScriptEngineAgent.Extension:
-    "PySide2.QtScript.QScriptEngineAgent.__init__": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScript.QScriptEngineAgent.contextPop": (),
-    "PySide2.QtScript.QScriptEngineAgent.contextPush": (),
-    "PySide2.QtScript.QScriptEngineAgent.engine": (),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionCatch": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.exceptionThrow": ('int', 'PySide2.QtScript.QScriptValue', 'bool'),
-    "PySide2.QtScript.QScriptEngineAgent.extension": ('PySide2.QtScript.QScriptEngineAgent.Extension', 'typing.Any'),
-    "PySide2.QtScript.QScriptEngineAgent.functionEntry": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.functionExit": ('int', 'PySide2.QtScript.QScriptValue'),
-    "PySide2.QtScript.QScriptEngineAgent.positionChange": ('int', 'int', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptLoad": ('int', 'str', 'str', 'int'),
-    "PySide2.QtScript.QScriptEngineAgent.scriptUnload": ('int',),
-    "PySide2.QtScript.QScriptEngineAgent.supportsExtension": ('PySide2.QtScript.QScriptEngineAgent.Extension',),
-# class PySide2.QtScript.QScriptExtensionInterface:
-    "PySide2.QtScript.QScriptExtensionInterface.__init__": (),
-    "PySide2.QtScript.QScriptExtensionInterface.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptExtensionPlugin:
-    "PySide2.QtScript.QScriptExtensionPlugin.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScript.QScriptExtensionPlugin.initialize": ('str', 'PySide2.QtScript.QScriptEngine'),
-    "PySide2.QtScript.QScriptExtensionPlugin.keys": (),
-    "PySide2.QtScript.QScriptExtensionPlugin.setupPackage": ('str', 'PySide2.QtScript.QScriptEngine'),
-# class PySide2.QtScript.QScriptProgram:
-    "PySide2.QtScript.QScriptProgram.__init__": [(), ('PySide2.QtScript.QScriptProgram',), ('str', 'str', 'int')],
-    "PySide2.QtScript.QScriptProgram.__copy__": (),
-    "PySide2.QtScript.QScriptProgram.fileName": (),
-    "PySide2.QtScript.QScriptProgram.firstLineNumber": (),
-    "PySide2.QtScript.QScriptProgram.isNull": (),
-    "PySide2.QtScript.QScriptProgram.sourceCode": (),
-# class PySide2.QtScript.QScriptString:
-    "PySide2.QtScript.QScriptString.__init__": [(), ('PySide2.QtScript.QScriptString',)],
-    "PySide2.QtScript.QScriptString.__copy__": (),
-    "PySide2.QtScript.QScriptString.isValid": (),
-    "PySide2.QtScript.QScriptString.toArrayIndex": (),
-    "PySide2.QtScript.QScriptString.toString": (),
-# class PySide2.QtScript.QScriptValue:
-# class PySide2.QtScript.QScriptValue.PropertyFlag:
-# class PySide2.QtScript.QScriptValue.PropertyFlags:
-# class PySide2.QtScript.QScriptValue.ResolveFlag:
-# class PySide2.QtScript.QScriptValue.ResolveFlags:
-# class PySide2.QtScript.QScriptValue.SpecialValue:
-    "PySide2.QtScript.QScriptValue.__init__": [(), ('PySide2.QtScript.QScriptEngine', 'PySide2.QtScript.QScriptValue.SpecialValue'), ('PySide2.QtScript.QScriptEngine', 'bool'), ('PySide2.QtScript.QScriptEngine', 'float'), ('PySide2.QtScript.QScriptEngine', 'int'), ('PySide2.QtScript.QScriptEngine', 'str'), ('PySide2.QtScript.QScriptValue',), ('PySide2.QtScript.QScriptValue.SpecialValue',), ('bool',), ('float',), ('int',), ('str',)],
-    "PySide2.QtScript.QScriptValue.__copy__": (),
-    "PySide2.QtScript.QScriptValue.__iter__": (),
-    "PySide2.QtScript.QScriptValue.__repr__": (),
-    "PySide2.QtScript.QScriptValue.call": [('PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue'), ('PySide2.QtScript.QScriptValue', 'typing.Sequence[PySide2.QtScript.QScriptValue]')],
-    "PySide2.QtScript.QScriptValue.construct": [('PySide2.QtScript.QScriptValue',), ('typing.Sequence[PySide2.QtScript.QScriptValue]',)],
-    "PySide2.QtScript.QScriptValue.data": (),
-    "PySide2.QtScript.QScriptValue.engine": (),
-    "PySide2.QtScript.QScriptValue.equals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.instanceOf": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.isArray": (),
-    "PySide2.QtScript.QScriptValue.isBool": (),
-    "PySide2.QtScript.QScriptValue.isBoolean": (),
-    "PySide2.QtScript.QScriptValue.isDate": (),
-    "PySide2.QtScript.QScriptValue.isError": (),
-    "PySide2.QtScript.QScriptValue.isFunction": (),
-    "PySide2.QtScript.QScriptValue.isNull": (),
-    "PySide2.QtScript.QScriptValue.isNumber": (),
-    "PySide2.QtScript.QScriptValue.isObject": (),
-    "PySide2.QtScript.QScriptValue.isQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.isQObject": (),
-    "PySide2.QtScript.QScriptValue.isRegExp": (),
-    "PySide2.QtScript.QScriptValue.isString": (),
-    "PySide2.QtScript.QScriptValue.isUndefined": (),
-    "PySide2.QtScript.QScriptValue.isValid": (),
-    "PySide2.QtScript.QScriptValue.isVariant": (),
-    "PySide2.QtScript.QScriptValue.lessThan": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.objectId": (),
-    "PySide2.QtScript.QScriptValue.property": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('int', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.propertyFlags": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue.ResolveFlags'), ('str', 'PySide2.QtScript.QScriptValue.ResolveFlags')],
-    "PySide2.QtScript.QScriptValue.prototype": (),
-    "PySide2.QtScript.QScriptValue.scope": (),
-    "PySide2.QtScript.QScriptValue.scriptClass": (),
-    "PySide2.QtScript.QScriptValue.setData": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setProperty": [('PySide2.QtScript.QScriptString', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('int', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags'), ('str', 'PySide2.QtScript.QScriptValue', 'PySide2.QtScript.QScriptValue.PropertyFlags')],
-    "PySide2.QtScript.QScriptValue.setPrototype": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScope": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.setScriptClass": ('PySide2.QtScript.QScriptClass',),
-    "PySide2.QtScript.QScriptValue.strictlyEquals": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValue.toBool": (),
-    "PySide2.QtScript.QScriptValue.toBoolean": (),
-    "PySide2.QtScript.QScriptValue.toDateTime": (),
-    "PySide2.QtScript.QScriptValue.toInt32": (),
-    "PySide2.QtScript.QScriptValue.toInteger": (),
-    "PySide2.QtScript.QScriptValue.toNumber": (),
-    "PySide2.QtScript.QScriptValue.toObject": (),
-    "PySide2.QtScript.QScriptValue.toQMetaObject": (),
-    "PySide2.QtScript.QScriptValue.toQObject": (),
-    "PySide2.QtScript.QScriptValue.toRegExp": (),
-    "PySide2.QtScript.QScriptValue.toString": (),
-    "PySide2.QtScript.QScriptValue.toUInt16": (),
-    "PySide2.QtScript.QScriptValue.toUInt32": (),
-    "PySide2.QtScript.QScriptValue.toVariant": (),
-# class PySide2.QtScript.QScriptValueIterator:
-    "PySide2.QtScript.QScriptValueIterator.__init__": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.__iter__": (),
-    "PySide2.QtScript.QScriptValueIterator.flags": (),
-    "PySide2.QtScript.QScriptValueIterator.hasNext": (),
-    "PySide2.QtScript.QScriptValueIterator.hasPrevious": (),
-    "PySide2.QtScript.QScriptValueIterator.name": (),
-    "PySide2.QtScript.QScriptValueIterator.previous": (),
-    "PySide2.QtScript.QScriptValueIterator.remove": (),
-    "PySide2.QtScript.QScriptValueIterator.scriptName": (),
-    "PySide2.QtScript.QScriptValueIterator.setValue": ('PySide2.QtScript.QScriptValue',),
-    "PySide2.QtScript.QScriptValueIterator.toBack": (),
-    "PySide2.QtScript.QScriptValueIterator.toFront": (),
-    "PySide2.QtScript.QScriptValueIterator.value": (),
-# class PySide2.QtScript.QScriptable:
-    "PySide2.QtScript.QScriptable.__init__": (),
-    "PySide2.QtScript.QScriptable.argument": ('int',),
-    "PySide2.QtScript.QScriptable.argumentCount": (),
-    "PySide2.QtScript.QScriptable.context": (),
-    "PySide2.QtScript.QScriptable.engine": (),
-    "PySide2.QtScript.QScriptable.thisObject": (),
-    }) if "PySide2.QtScript" in sys.modules else None
-# Module PySide2.QtScriptTools
-sig_dict.update({
-# class PySide2.QtScriptTools.QScriptEngineDebugger:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerState:
-# class PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget:
-    "PySide2.QtScriptTools.QScriptEngineDebugger.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.action": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerAction',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.attachTo": ('PySide2.QtScript.QScriptEngine',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.autoShowStandardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardMenu": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.createStandardToolBar": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.setAutoShowStandardWindow": ('bool',),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.standardWindow": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.state": (),
-    "PySide2.QtScriptTools.QScriptEngineDebugger.widget": ('PySide2.QtScriptTools.QScriptEngineDebugger.DebuggerWidget',),
-    }) if "PySide2.QtScriptTools" in sys.modules else None
-# Module PySide2.QtSensors
-sig_dict.update({
-# class PySide2.QtSensors.QAccelerometer:
-# class PySide2.QtSensors.QAccelerometer.AccelerationMode:
-    "PySide2.QtSensors.QAccelerometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometer.accelerationMode": (),
-    "PySide2.QtSensors.QAccelerometer.reading": (),
-    "PySide2.QtSensors.QAccelerometer.setAccelerationMode": ('PySide2.QtSensors.QAccelerometer.AccelerationMode',),
-# class PySide2.QtSensors.QAccelerometerFilter:
-    "PySide2.QtSensors.QAccelerometerFilter.__init__": (),
-    "PySide2.QtSensors.QAccelerometerFilter.filter": [('PySide2.QtSensors.QAccelerometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAccelerometerReading:
-    "PySide2.QtSensors.QAccelerometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAccelerometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAccelerometerReading.setX": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setY": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QAccelerometerReading.x": (),
-    "PySide2.QtSensors.QAccelerometerReading.y": (),
-    "PySide2.QtSensors.QAccelerometerReading.z": (),
-# class PySide2.QtSensors.QAltimeter:
-    "PySide2.QtSensors.QAltimeter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeter.reading": (),
-# class PySide2.QtSensors.QAltimeterFilter:
-    "PySide2.QtSensors.QAltimeterFilter.__init__": (),
-    "PySide2.QtSensors.QAltimeterFilter.filter": [('PySide2.QtSensors.QAltimeterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAltimeterReading:
-    "PySide2.QtSensors.QAltimeterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAltimeterReading.altitude": (),
-    "PySide2.QtSensors.QAltimeterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAltimeterReading.setAltitude": ('float',),
-# class PySide2.QtSensors.QAmbientLightFilter:
-    "PySide2.QtSensors.QAmbientLightFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientLightFilter.filter": [('PySide2.QtSensors.QAmbientLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientLightReading:
-# class PySide2.QtSensors.QAmbientLightReading.LightLevel:
-    "PySide2.QtSensors.QAmbientLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientLightReading.lightLevel": (),
-    "PySide2.QtSensors.QAmbientLightReading.setLightLevel": ('PySide2.QtSensors.QAmbientLightReading.LightLevel',),
-# class PySide2.QtSensors.QAmbientLightSensor:
-    "PySide2.QtSensors.QAmbientLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientLightSensor.reading": (),
-# class PySide2.QtSensors.QAmbientTemperatureFilter:
-    "PySide2.QtSensors.QAmbientTemperatureFilter.__init__": (),
-    "PySide2.QtSensors.QAmbientTemperatureFilter.filter": [('PySide2.QtSensors.QAmbientTemperatureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QAmbientTemperatureReading:
-    "PySide2.QtSensors.QAmbientTemperatureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QAmbientTemperatureReading.temperature": (),
-# class PySide2.QtSensors.QAmbientTemperatureSensor:
-    "PySide2.QtSensors.QAmbientTemperatureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QAmbientTemperatureSensor.reading": (),
-# class PySide2.QtSensors.QCompass:
-    "PySide2.QtSensors.QCompass.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompass.reading": (),
-# class PySide2.QtSensors.QCompassFilter:
-    "PySide2.QtSensors.QCompassFilter.__init__": (),
-    "PySide2.QtSensors.QCompassFilter.filter": [('PySide2.QtSensors.QCompassReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QCompassReading:
-    "PySide2.QtSensors.QCompassReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QCompassReading.azimuth": (),
-    "PySide2.QtSensors.QCompassReading.calibrationLevel": (),
-    "PySide2.QtSensors.QCompassReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QCompassReading.setAzimuth": ('float',),
-    "PySide2.QtSensors.QCompassReading.setCalibrationLevel": ('float',),
-# class PySide2.QtSensors.QDistanceFilter:
-    "PySide2.QtSensors.QDistanceFilter.__init__": (),
-    "PySide2.QtSensors.QDistanceFilter.filter": [('PySide2.QtSensors.QDistanceReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QDistanceReading:
-    "PySide2.QtSensors.QDistanceReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QDistanceReading.distance": (),
-    "PySide2.QtSensors.QDistanceReading.setDistance": ('float',),
-# class PySide2.QtSensors.QDistanceSensor:
-    "PySide2.QtSensors.QDistanceSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QDistanceSensor.reading": (),
-# class PySide2.QtSensors.QGyroscope:
-    "PySide2.QtSensors.QGyroscope.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscope.reading": (),
-# class PySide2.QtSensors.QGyroscopeFilter:
-    "PySide2.QtSensors.QGyroscopeFilter.__init__": (),
-    "PySide2.QtSensors.QGyroscopeFilter.filter": [('PySide2.QtSensors.QGyroscopeReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QGyroscopeReading:
-    "PySide2.QtSensors.QGyroscopeReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QGyroscopeReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QGyroscopeReading.setX": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setY": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.setZ": ('float',),
-    "PySide2.QtSensors.QGyroscopeReading.x": (),
-    "PySide2.QtSensors.QGyroscopeReading.y": (),
-    "PySide2.QtSensors.QGyroscopeReading.z": (),
-# class PySide2.QtSensors.QHolsterFilter:
-    "PySide2.QtSensors.QHolsterFilter.__init__": (),
-    "PySide2.QtSensors.QHolsterFilter.filter": [('PySide2.QtSensors.QHolsterReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHolsterReading:
-    "PySide2.QtSensors.QHolsterReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHolsterReading.holstered": (),
-    "PySide2.QtSensors.QHolsterReading.setHolstered": ('bool',),
-# class PySide2.QtSensors.QHolsterSensor:
-    "PySide2.QtSensors.QHolsterSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHolsterSensor.reading": (),
-# class PySide2.QtSensors.QHumidityFilter:
-    "PySide2.QtSensors.QHumidityFilter.__init__": (),
-    "PySide2.QtSensors.QHumidityFilter.filter": [('PySide2.QtSensors.QHumidityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QHumidityReading:
-    "PySide2.QtSensors.QHumidityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumidityReading.absoluteHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QHumidityReading.relativeHumidity": (),
-    "PySide2.QtSensors.QHumidityReading.setAbsoluteHumidity": ('float',),
-    "PySide2.QtSensors.QHumidityReading.setRelativeHumidity": ('float',),
-# class PySide2.QtSensors.QHumiditySensor:
-    "PySide2.QtSensors.QHumiditySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QHumiditySensor.reading": (),
-# class PySide2.QtSensors.QIRProximityFilter:
-    "PySide2.QtSensors.QIRProximityFilter.__init__": (),
-    "PySide2.QtSensors.QIRProximityFilter.filter": [('PySide2.QtSensors.QIRProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QIRProximityReading:
-    "PySide2.QtSensors.QIRProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QIRProximityReading.reflectance": (),
-    "PySide2.QtSensors.QIRProximityReading.setReflectance": ('float',),
-# class PySide2.QtSensors.QIRProximitySensor:
-    "PySide2.QtSensors.QIRProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QIRProximitySensor.reading": (),
-# class PySide2.QtSensors.QLidFilter:
-    "PySide2.QtSensors.QLidFilter.__init__": (),
-    "PySide2.QtSensors.QLidFilter.filter": [('PySide2.QtSensors.QLidReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLidReading:
-    "PySide2.QtSensors.QLidReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidReading.backLidClosed": (),
-    "PySide2.QtSensors.QLidReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLidReading.frontLidClosed": (),
-    "PySide2.QtSensors.QLidReading.setBackLidClosed": ('bool',),
-    "PySide2.QtSensors.QLidReading.setFrontLidClosed": ('bool',),
-# class PySide2.QtSensors.QLidSensor:
-    "PySide2.QtSensors.QLidSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLidSensor.reading": (),
-# class PySide2.QtSensors.QLightFilter:
-    "PySide2.QtSensors.QLightFilter.__init__": (),
-    "PySide2.QtSensors.QLightFilter.filter": [('PySide2.QtSensors.QLightReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QLightReading:
-    "PySide2.QtSensors.QLightReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QLightReading.lux": (),
-    "PySide2.QtSensors.QLightReading.setLux": ('float',),
-# class PySide2.QtSensors.QLightSensor:
-    "PySide2.QtSensors.QLightSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QLightSensor.fieldOfView": (),
-    "PySide2.QtSensors.QLightSensor.reading": (),
-    "PySide2.QtSensors.QLightSensor.setFieldOfView": ('float',),
-# class PySide2.QtSensors.QMagnetometer:
-    "PySide2.QtSensors.QMagnetometer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometer.reading": (),
-    "PySide2.QtSensors.QMagnetometer.returnGeoValues": (),
-    "PySide2.QtSensors.QMagnetometer.setReturnGeoValues": ('bool',),
-# class PySide2.QtSensors.QMagnetometerFilter:
-    "PySide2.QtSensors.QMagnetometerFilter.__init__": (),
-    "PySide2.QtSensors.QMagnetometerFilter.filter": [('PySide2.QtSensors.QMagnetometerReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QMagnetometerReading:
-    "PySide2.QtSensors.QMagnetometerReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QMagnetometerReading.calibrationLevel": (),
-    "PySide2.QtSensors.QMagnetometerReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QMagnetometerReading.setCalibrationLevel": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setX": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setY": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.setZ": ('float',),
-    "PySide2.QtSensors.QMagnetometerReading.x": (),
-    "PySide2.QtSensors.QMagnetometerReading.y": (),
-    "PySide2.QtSensors.QMagnetometerReading.z": (),
-# class PySide2.QtSensors.QOrientationFilter:
-    "PySide2.QtSensors.QOrientationFilter.__init__": (),
-    "PySide2.QtSensors.QOrientationFilter.filter": [('PySide2.QtSensors.QOrientationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QOrientationReading:
-# class PySide2.QtSensors.QOrientationReading.Orientation:
-    "PySide2.QtSensors.QOrientationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QOrientationReading.orientation": (),
-    "PySide2.QtSensors.QOrientationReading.setOrientation": ('PySide2.QtSensors.QOrientationReading.Orientation',),
-# class PySide2.QtSensors.QOrientationSensor:
-    "PySide2.QtSensors.QOrientationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QOrientationSensor.reading": (),
-# class PySide2.QtSensors.QPressureFilter:
-    "PySide2.QtSensors.QPressureFilter.__init__": (),
-    "PySide2.QtSensors.QPressureFilter.filter": [('PySide2.QtSensors.QPressureReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QPressureReading:
-    "PySide2.QtSensors.QPressureReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QPressureReading.pressure": (),
-    "PySide2.QtSensors.QPressureReading.setPressure": ('float',),
-    "PySide2.QtSensors.QPressureReading.setTemperature": ('float',),
-    "PySide2.QtSensors.QPressureReading.temperature": (),
-# class PySide2.QtSensors.QPressureSensor:
-    "PySide2.QtSensors.QPressureSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QPressureSensor.reading": (),
-# class PySide2.QtSensors.QProximityFilter:
-    "PySide2.QtSensors.QProximityFilter.__init__": (),
-    "PySide2.QtSensors.QProximityFilter.filter": [('PySide2.QtSensors.QProximityReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QProximityReading:
-    "PySide2.QtSensors.QProximityReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximityReading.close": (),
-    "PySide2.QtSensors.QProximityReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QProximityReading.setClose": ('bool',),
-# class PySide2.QtSensors.QProximitySensor:
-    "PySide2.QtSensors.QProximitySensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QProximitySensor.reading": (),
-# class PySide2.QtSensors.QRotationFilter:
-    "PySide2.QtSensors.QRotationFilter.__init__": (),
-    "PySide2.QtSensors.QRotationFilter.filter": [('PySide2.QtSensors.QRotationReading',), ('PySide2.QtSensors.QSensorReading',)],
-# class PySide2.QtSensors.QRotationReading:
-    "PySide2.QtSensors.QRotationReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QRotationReading.setFromEuler": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QRotationReading.x": (),
-    "PySide2.QtSensors.QRotationReading.y": (),
-    "PySide2.QtSensors.QRotationReading.z": (),
-# class PySide2.QtSensors.QRotationSensor:
-    "PySide2.QtSensors.QRotationSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QRotationSensor.hasZ": (),
-    "PySide2.QtSensors.QRotationSensor.reading": (),
-    "PySide2.QtSensors.QRotationSensor.setHasZ": ('bool',),
-# class PySide2.QtSensors.QSensor:
-# class PySide2.QtSensors.QSensor.AxesOrientationMode:
-# class PySide2.QtSensors.QSensor.Feature:
-    "PySide2.QtSensors.QSensor.__init__": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensor.addFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.availableDataRates": (),
-    "PySide2.QtSensors.QSensor.axesOrientationMode": (),
-    "PySide2.QtSensors.QSensor.backend": (),
-    "PySide2.QtSensors.QSensor.bufferSize": (),
-    "PySide2.QtSensors.QSensor.connectToBackend": (),
-    "PySide2.QtSensors.QSensor.currentOrientation": (),
-    "PySide2.QtSensors.QSensor.dataRate": (),
-    "PySide2.QtSensors.QSensor.defaultSensorForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.description": (),
-    "PySide2.QtSensors.QSensor.efficientBufferSize": (),
-    "PySide2.QtSensors.QSensor.error": (),
-    "PySide2.QtSensors.QSensor.filters": (),
-    "PySide2.QtSensors.QSensor.identifier": (),
-    "PySide2.QtSensors.QSensor.isActive": (),
-    "PySide2.QtSensors.QSensor.isAlwaysOn": (),
-    "PySide2.QtSensors.QSensor.isBusy": (),
-    "PySide2.QtSensors.QSensor.isConnectedToBackend": (),
-    "PySide2.QtSensors.QSensor.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensor.maxBufferSize": (),
-    "PySide2.QtSensors.QSensor.outputRange": (),
-    "PySide2.QtSensors.QSensor.outputRanges": (),
-    "PySide2.QtSensors.QSensor.reading": (),
-    "PySide2.QtSensors.QSensor.removeFilter": ('PySide2.QtSensors.QSensorFilter',),
-    "PySide2.QtSensors.QSensor.sensorTypes": (),
-    "PySide2.QtSensors.QSensor.sensorsForType": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setActive": ('bool',),
-    "PySide2.QtSensors.QSensor.setAlwaysOn": ('bool',),
-    "PySide2.QtSensors.QSensor.setAxesOrientationMode": ('PySide2.QtSensors.QSensor.AxesOrientationMode',),
-    "PySide2.QtSensors.QSensor.setBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setCurrentOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.setDataRate": ('int',),
-    "PySide2.QtSensors.QSensor.setEfficientBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setIdentifier": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtSensors.QSensor.setMaxBufferSize": ('int',),
-    "PySide2.QtSensors.QSensor.setOutputRange": ('int',),
-    "PySide2.QtSensors.QSensor.setSkipDuplicates": ('bool',),
-    "PySide2.QtSensors.QSensor.setUserOrientation": ('int',),
-    "PySide2.QtSensors.QSensor.skipDuplicates": (),
-    "PySide2.QtSensors.QSensor.start": (),
-    "PySide2.QtSensors.QSensor.stop": (),
-    "PySide2.QtSensors.QSensor.type": (),
-    "PySide2.QtSensors.QSensor.userOrientation": (),
-# class PySide2.QtSensors.QSensorBackend:
-    "PySide2.QtSensors.QSensorBackend.__init__": ('PySide2.QtSensors.QSensor', 'PySide2.QtCore.QObject'),
-    "PySide2.QtSensors.QSensorBackend.addDataRate": ('float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.addOutputRange": ('float', 'float', 'float'),
-    "PySide2.QtSensors.QSensorBackend.isFeatureSupported": ('PySide2.QtSensors.QSensor.Feature',),
-    "PySide2.QtSensors.QSensorBackend.newReadingAvailable": (),
-    "PySide2.QtSensors.QSensorBackend.reading": (),
-    "PySide2.QtSensors.QSensorBackend.sensor": (),
-    "PySide2.QtSensors.QSensorBackend.sensorBusy": (),
-    "PySide2.QtSensors.QSensorBackend.sensorError": ('int',),
-    "PySide2.QtSensors.QSensorBackend.sensorStopped": (),
-    "PySide2.QtSensors.QSensorBackend.setDataRates": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorBackend.setDescription": ('str',),
-    "PySide2.QtSensors.QSensorBackend.start": (),
-    "PySide2.QtSensors.QSensorBackend.stop": (),
-# class PySide2.QtSensors.QSensorBackendFactory:
-    "PySide2.QtSensors.QSensorBackendFactory.__init__": (),
-    "PySide2.QtSensors.QSensorBackendFactory.createBackend": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorChangesInterface:
-    "PySide2.QtSensors.QSensorChangesInterface.__init__": (),
-    "PySide2.QtSensors.QSensorChangesInterface.sensorsChanged": (),
-# class PySide2.QtSensors.QSensorFilter:
-    "PySide2.QtSensors.QSensorFilter.__init__": (),
-    "PySide2.QtSensors.QSensorFilter.filter": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorFilter.setSensor": ('PySide2.QtSensors.QSensor',),
-# class PySide2.QtSensors.QSensorGestureManager:
-    "PySide2.QtSensors.QSensorGestureManager.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureManager.gestureIds": (),
-    "PySide2.QtSensors.QSensorGestureManager.recognizerSignals": ('str',),
-    "PySide2.QtSensors.QSensorGestureManager.registerSensorGestureRecognizer": ('PySide2.QtSensors.QSensorGestureRecognizer',),
-    "PySide2.QtSensors.QSensorGestureManager.sensorGestureRecognizer": ('str',),
-# class PySide2.QtSensors.QSensorGesturePluginInterface:
-    "PySide2.QtSensors.QSensorGesturePluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.createRecognizers": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.name": (),
-    "PySide2.QtSensors.QSensorGesturePluginInterface.supportedIds": (),
-# class PySide2.QtSensors.QSensorGestureRecognizer:
-    "PySide2.QtSensors.QSensorGestureRecognizer.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QSensorGestureRecognizer.create": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.createBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.gestureSignals": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.id": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.isActive": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.start": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.startBackend": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stop": (),
-    "PySide2.QtSensors.QSensorGestureRecognizer.stopBackend": (),
-# class PySide2.QtSensors.QSensorManager:
-    "PySide2.QtSensors.QSensorManager.__init__": (),
-    "PySide2.QtSensors.QSensorManager.createBackend": ('PySide2.QtSensors.QSensor',),
-    "PySide2.QtSensors.QSensorManager.isBackendRegistered": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.registerBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray', 'PySide2.QtSensors.QSensorBackendFactory'),
-    "PySide2.QtSensors.QSensorManager.setDefaultBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtSensors.QSensorManager.unregisterBackend": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtSensors.QSensorPluginInterface:
-    "PySide2.QtSensors.QSensorPluginInterface.__init__": (),
-    "PySide2.QtSensors.QSensorPluginInterface.registerSensors": (),
-# class PySide2.QtSensors.QSensorReading:
-    "PySide2.QtSensors.QSensorReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QSensorReading.setTimestamp": ('int',),
-    "PySide2.QtSensors.QSensorReading.timestamp": (),
-    "PySide2.QtSensors.QSensorReading.value": ('int',),
-    "PySide2.QtSensors.QSensorReading.valueCount": (),
-# class PySide2.QtSensors.QTapFilter:
-    "PySide2.QtSensors.QTapFilter.__init__": (),
-    "PySide2.QtSensors.QTapFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTapReading',)],
-# class PySide2.QtSensors.QTapReading:
-# class PySide2.QtSensors.QTapReading.TapDirection:
-    "PySide2.QtSensors.QTapReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTapReading.isDoubleTap": (),
-    "PySide2.QtSensors.QTapReading.setDoubleTap": ('bool',),
-    "PySide2.QtSensors.QTapReading.setTapDirection": ('PySide2.QtSensors.QTapReading.TapDirection',),
-    "PySide2.QtSensors.QTapReading.tapDirection": (),
-# class PySide2.QtSensors.QTapSensor:
-    "PySide2.QtSensors.QTapSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTapSensor.reading": (),
-    "PySide2.QtSensors.QTapSensor.returnDoubleTapEvents": (),
-    "PySide2.QtSensors.QTapSensor.setReturnDoubleTapEvents": ('bool',),
-# class PySide2.QtSensors.QTiltFilter:
-    "PySide2.QtSensors.QTiltFilter.__init__": (),
-    "PySide2.QtSensors.QTiltFilter.filter": [('PySide2.QtSensors.QSensorReading',), ('PySide2.QtSensors.QTiltReading',)],
-# class PySide2.QtSensors.QTiltReading:
-    "PySide2.QtSensors.QTiltReading.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltReading.copyValuesFrom": ('PySide2.QtSensors.QSensorReading',),
-    "PySide2.QtSensors.QTiltReading.setXRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.setYRotation": ('float',),
-    "PySide2.QtSensors.QTiltReading.xRotation": (),
-    "PySide2.QtSensors.QTiltReading.yRotation": (),
-# class PySide2.QtSensors.QTiltSensor:
-    "PySide2.QtSensors.QTiltSensor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtSensors.QTiltSensor.calibrate": (),
-    "PySide2.QtSensors.QTiltSensor.reading": (),
-# class PySide2.QtSensors.qoutputrange:
-    "PySide2.QtSensors.qoutputrange.__init__": [(), ('PySide2.QtSensors.qoutputrange',)],
-    "PySide2.QtSensors.qoutputrange.__copy__": (),
-    }) if "PySide2.QtSensors" in sys.modules else None
-# Module PySide2.QtTextToSpeech
-sig_dict.update({
-# class PySide2.QtTextToSpeech.QTextToSpeech:
-# class PySide2.QtTextToSpeech.QTextToSpeech.State:
-    "PySide2.QtTextToSpeech.QTextToSpeech.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableEngines": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeech.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeech.volume": (),
-# class PySide2.QtTextToSpeech.QTextToSpeechEngine:
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableLocales": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.availableVoices": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.createVoice": ('str', 'PySide2.QtTextToSpeech.QVoice.Gender', 'PySide2.QtTextToSpeech.QVoice.Age', 'typing.Any'),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.locale": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pause": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.pitch": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.rate": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.resume": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.say": ('str',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setPitch": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setRate": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVoice": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.setVolume": ('float',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.state": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.stop": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voice": (),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.voiceData": ('PySide2.QtTextToSpeech.QVoice',),
-    "PySide2.QtTextToSpeech.QTextToSpeechEngine.volume": (),
-# class PySide2.QtTextToSpeech.QVoice:
-# class PySide2.QtTextToSpeech.QVoice.Age:
-# class PySide2.QtTextToSpeech.QVoice.Gender:
-    "PySide2.QtTextToSpeech.QVoice.__init__": [(), ('PySide2.QtTextToSpeech.QVoice',)],
-    "PySide2.QtTextToSpeech.QVoice.__copy__": (),
-    "PySide2.QtTextToSpeech.QVoice.age": (),
-    "PySide2.QtTextToSpeech.QVoice.ageName": ('PySide2.QtTextToSpeech.QVoice.Age',),
-    "PySide2.QtTextToSpeech.QVoice.gender": (),
-    "PySide2.QtTextToSpeech.QVoice.genderName": ('PySide2.QtTextToSpeech.QVoice.Gender',),
-    "PySide2.QtTextToSpeech.QVoice.name": (),
-    }) if "PySide2.QtTextToSpeech" in sys.modules else None
-# Module PySide2.QtCharts
-sig_dict.update({
-# class PySide2.QtCharts.QtCharts:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis:
-# class PySide2.QtCharts.QtCharts.QAbstractAxis.AxisType:
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.alignment": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.gridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isMinorGridLineVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isReverse": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isTitleVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsEditable": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.labelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.linePenColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLineColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.minorGridLinePen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.orientation": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsAngle": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsEditable": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLinePenColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMax": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMin": ('typing.Any',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLinePen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setMinorGridLineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setRange": ('typing.Any', 'typing.Any'),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setReverse": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setShadesVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleText": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setTitleVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBorderColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesColor": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesPen": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.shadesVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.titleText": (),
-    "PySide2.QtCharts.QtCharts.QAbstractAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition:
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.append": [('PySide2.QtCharts.QtCharts.QBarSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBarSet]',)],
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barSets": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.barWidth": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBarSet'),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.isLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsAngle": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.labelsPrecision": (),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.remove": ('PySide2.QtCharts.QtCharts.QBarSet',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setBarWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries.LabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsPrecision": ('int',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractBarSeries.take": ('PySide2.QtCharts.QtCharts.QBarSet',),
-# class PySide2.QtCharts.QtCharts.QAbstractSeries:
-# class PySide2.QtCharts.QtCharts.QAbstractSeries.SeriesType:
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.attachedAxes": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.chart": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.detachAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.hide": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.name": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.opacity": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setName": ('str',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setOpacity": ('float',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setUseOpenGL": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.show": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAbstractSeries.useOpenGL": (),
-# class PySide2.QtCharts.QtCharts.QAreaLegendMarker:
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAreaSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QAreaLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QAreaSeries:
-    "PySide2.QtCharts.QtCharts.QAreaSeries.__init__": [('PySide2.QtCharts.QtCharts.QLineSeries', 'PySide2.QtCharts.QtCharts.QLineSeries'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtCharts.QtCharts.QAreaSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.lowerSeries": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setLowerSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setPointsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.setUpperSeries": ('PySide2.QtCharts.QtCharts.QLineSeries',),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QAreaSeries.upperSeries": (),
-# class PySide2.QtCharts.QtCharts.QBarCategoryAxis:
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.append": [('str',), ('typing.Sequence[str]',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.categories": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.clear": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.insert": ('int', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.replace": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setCategories": ('typing.Sequence[str]',),
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMax": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setMin": [('str',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.setRange": [('str', 'str'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QBarCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QBarLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries', 'PySide2.QtCharts.QtCharts.QBarSet', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.barset": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBarLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.firstBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.lastBarSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setFirstBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setLastBarSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QBarSeries:
-    "PySide2.QtCharts.QtCharts.QBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBarSet:
-    "PySide2.QtCharts.QtCharts.QBarSet.__init__": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBarSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBarSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBarSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBarSet.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.color": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.insert": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBarSet.remove": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QBarSet.replace": ('int', 'float'),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QBarSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBarSet.sum": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker:
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.firstBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.lastBoxSetSection": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setFirstBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setLastBoxSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QBoxPlotSeries:
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.append": [('PySide2.QtCharts.QtCharts.QBoxSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QBoxSet]',)],
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxSets": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.boxWidth": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QBoxSet'),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.remove": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBoxWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.take": ('PySide2.QtCharts.QtCharts.QBoxSet',),
-    "PySide2.QtCharts.QtCharts.QBoxPlotSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QBoxSet:
-# class PySide2.QtCharts.QtCharts.QBoxSet.ValuePositions:
-    "PySide2.QtCharts.QtCharts.QBoxSet.__init__": [('float', 'float', 'float', 'float', 'float', 'str', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QBoxSet.__lshift__": ('float',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.append": [('float',), ('typing.Sequence[float]',)],
-    "PySide2.QtCharts.QtCharts.QBoxSet.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.clear": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.count": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.label": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QBoxSet.setValue": ('int', 'float'),
-# class PySide2.QtCharts.QtCharts.QCandlestickLegendMarker:
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QCandlestickSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.firstSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.lastSetSection": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setClose": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setFirstSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setHigh": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLastSetSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setLow": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setOpen": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QCandlestickSeries',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.setTimestamp": ('int',),
-    "PySide2.QtCharts.QtCharts.QCandlestickModelMapper.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSeries:
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.append": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyOutlineVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.bodyWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsVisible": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.capsWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.decreasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.increasingColor": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QCandlestickSet'),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.maximumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.minimumColumnWidth": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.remove": [('PySide2.QtCharts.QtCharts.QCandlestickSet',), ('typing.Sequence[PySide2.QtCharts.QtCharts.QCandlestickSet]',)],
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyOutlineVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBodyWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setCapsWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setDecreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setIncreasingColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMaximumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setMinimumColumnWidth": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.sets": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.take": ('PySide2.QtCharts.QtCharts.QCandlestickSet',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QCandlestickSet:
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.__init__": [('float', 'PySide2.QtCore.QObject'), ('float', 'float', 'float', 'float', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.brush": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.close": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.high": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.low": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.open": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.pen": (),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setClose": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setHigh": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setLow": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setOpen": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.setTimestamp": ('float',),
-    "PySide2.QtCharts.QtCharts.QCandlestickSet.timestamp": (),
-# class PySide2.QtCharts.QtCharts.QCategoryAxis:
-# class PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition:
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.append": ('str', 'float'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.categoriesLabels": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.count": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.endValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.labelsPosition": (),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.remove": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.replaceLabel": ('str', 'str'),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QCategoryAxis.AxisLabelsPosition',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.setStartValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.startValue": ('str',),
-    "PySide2.QtCharts.QtCharts.QCategoryAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QChart:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOption:
-# class PySide2.QtCharts.QtCharts.QChart.AnimationOptions:
-# class PySide2.QtCharts.QtCharts.QChart.ChartTheme:
-# class PySide2.QtCharts.QtCharts.QChart.ChartType:
-    "PySide2.QtCharts.QtCharts.QChart.__init__": [('PySide2.QtCharts.QtCharts.QChart.ChartType', 'PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'), ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags')],
-    "PySide2.QtCharts.QtCharts.QChart.addAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment'),
-    "PySide2.QtCharts.QtCharts.QChart.addSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.animationDuration": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationEasingCurve": (),
-    "PySide2.QtCharts.QtCharts.QChart.animationOptions": (),
-    "PySide2.QtCharts.QtCharts.QChart.axes": ('PySide2.QtCore.Qt.Orientations', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.axisX": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.axisY": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.backgroundRoundness": (),
-    "PySide2.QtCharts.QtCharts.QChart.chartType": (),
-    "PySide2.QtCharts.QtCharts.QChart.createDefaultAxes": (),
-    "PySide2.QtCharts.QtCharts.QChart.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isDropShadowEnabled": (),
-    "PySide2.QtCharts.QtCharts.QChart.isPlotAreaBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QChart.isZoomed": (),
-    "PySide2.QtCharts.QtCharts.QChart.legend": (),
-    "PySide2.QtCharts.QtCharts.QChart.locale": (),
-    "PySide2.QtCharts.QtCharts.QChart.localizeNumbers": (),
-    "PySide2.QtCharts.QtCharts.QChart.mapToPosition": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.mapToValue": ('PySide2.QtCore.QPointF', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.margins": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotArea": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.plotAreaBackgroundPen": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAllSeries": (),
-    "PySide2.QtCharts.QtCharts.QChart.removeAxis": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-    "PySide2.QtCharts.QtCharts.QChart.removeSeries": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QChart.scroll": ('float', 'float'),
-    "PySide2.QtCharts.QtCharts.QChart.series": (),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationDuration": ('int',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationEasingCurve": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.QtCharts.QtCharts.QChart.setAnimationOptions": ('PySide2.QtCharts.QtCharts.QChart.AnimationOptions',),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisX": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setAxisY": ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QAbstractSeries'),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundRoundness": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setDropShadowEnabled": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtCharts.QtCharts.QChart.setLocalizeNumbers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setMargins": ('PySide2.QtCore.QMargins',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotArea": ('PySide2.QtCore.QRectF',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QChart.setPlotAreaBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QChart.setTheme": ('PySide2.QtCharts.QtCharts.QChart.ChartTheme',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitle": ('str',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QChart.setTitleFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QChart.theme": (),
-    "PySide2.QtCharts.QtCharts.QChart.title": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleBrush": (),
-    "PySide2.QtCharts.QtCharts.QChart.titleFont": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoom": ('float',),
-    "PySide2.QtCharts.QtCharts.QChart.zoomIn": [(), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtCharts.QtCharts.QChart.zoomOut": (),
-    "PySide2.QtCharts.QtCharts.QChart.zoomReset": (),
-# class PySide2.QtCharts.QtCharts.QChartView:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBand:
-# class PySide2.QtCharts.QtCharts.QChartView.RubberBands:
-    "PySide2.QtCharts.QtCharts.QChartView.__init__": [('PySide2.QtCharts.QtCharts.QChart', 'PySide2.QtWidgets.QWidget'), ('PySide2.QtWidgets.QWidget',)],
-    "PySide2.QtCharts.QtCharts.QChartView.chart": (),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtCharts.QtCharts.QChartView.rubberBand": (),
-    "PySide2.QtCharts.QtCharts.QChartView.setChart": ('PySide2.QtCharts.QtCharts.QChart',),
-    "PySide2.QtCharts.QtCharts.QChartView.setRubberBand": ('PySide2.QtCharts.QtCharts.QChartView.RubberBands',),
-# class PySide2.QtCharts.QtCharts.QDateTimeAxis:
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.format": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMax": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setMin": [('PySide2.QtCore.QDateTime',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setRange": [('PySide2.QtCore.QDateTime', 'PySide2.QtCore.QDateTime'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QDateTimeAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QHBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.lastBarSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setLastBarSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.lastBoxSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setLastBoxSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QHCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.closeColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.firstSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.highColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lastSetRow": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.lowColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.openColumn": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setCloseColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setFirstSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setHighColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLastSetRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setLowColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setOpenColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.setTimestampColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHCandlestickModelMapper.timestampColumn": (),
-# class PySide2.QtCharts.QtCharts.QHPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.labelsRow": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setLabelsRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.setValuesRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHPieModelMapper.valuesRow": (),
-# class PySide2.QtCharts.QtCharts.QHXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.columnCount": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.firstColumn": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setColumnCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setFirstColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setXRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.setYRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.xRow": (),
-    "PySide2.QtCharts.QtCharts.QHXYModelMapper.yRow": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QHorizontalStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLegend:
-# class PySide2.QtCharts.QtCharts.QLegend.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QLegend.alignment": (),
-    "PySide2.QtCharts.QtCharts.QLegend.attachToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.color": (),
-    "PySide2.QtCharts.QtCharts.QLegend.detachFromChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.font": (),
-    "PySide2.QtCharts.QtCharts.QLegend.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.isAttachedToChart": (),
-    "PySide2.QtCharts.QtCharts.QLegend.isBackgroundVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegend.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QLegend.markers": ('PySide2.QtCharts.QtCharts.QAbstractSeries',),
-    "PySide2.QtCharts.QtCharts.QLegend.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtCharts.QtCharts.QLegend.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegend.reverseMarkers": (),
-    "PySide2.QtCharts.QtCharts.QLegend.setAlignment": ('PySide2.QtCore.Qt.Alignment',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBackgroundVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegend.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QLegend.setMarkerShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegend.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegend.setReverseMarkers": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.setShowToolTips": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegend.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtCharts.QtCharts.QLegend.showToolTips": (),
-# class PySide2.QtCharts.QtCharts.QLegendMarker:
-# class PySide2.QtCharts.QtCharts.QLegendMarker.LegendMarkerType:
-    "PySide2.QtCharts.QtCharts.QLegendMarker.brush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.font": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.isVisible": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.label": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.pen": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setShape": ('PySide2.QtCharts.QtCharts.QLegend.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.setVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.shape": (),
-    "PySide2.QtCharts.QtCharts.QLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QLineSeries:
-    "PySide2.QtCharts.QtCharts.QLineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QLogValueAxis:
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.base": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setBase": ('float',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QLogValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QPercentBarSeries:
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPercentBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QPieLegendMarker:
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QPieSeries', 'PySide2.QtCharts.QtCharts.QPieSlice', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.slice": (),
-    "PySide2.QtCharts.QtCharts.QPieLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.labelsSection": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setLabelsSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.setValuesSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieModelMapper.valuesSection": (),
-# class PySide2.QtCharts.QtCharts.QPieSeries:
-    "PySide2.QtCharts.QtCharts.QPieSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.__lshift__": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.append": [('PySide2.QtCharts.QtCharts.QPieSlice',), ('str', 'float'), ('typing.Sequence[PySide2.QtCharts.QtCharts.QPieSlice]',)],
-    "PySide2.QtCharts.QtCharts.QPieSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.holeSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.horizontalPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.insert": ('int', 'PySide2.QtCharts.QtCharts.QPieSlice'),
-    "PySide2.QtCharts.QtCharts.QPieSeries.isEmpty": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieEndAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieSize": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.pieStartAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.remove": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHoleSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setHorizontalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieEndAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setPieStartAngle": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.setVerticalPosition": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.slices": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.sum": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.take": ('PySide2.QtCharts.QtCharts.QPieSlice',),
-    "PySide2.QtCharts.QtCharts.QPieSeries.type": (),
-    "PySide2.QtCharts.QtCharts.QPieSeries.verticalPosition": (),
-# class PySide2.QtCharts.QtCharts.QPieSlice:
-# class PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition:
-    "PySide2.QtCharts.QtCharts.QPieSlice.__init__": [('PySide2.QtCore.QObject',), ('str', 'float', 'PySide2.QtCore.QObject')],
-    "PySide2.QtCharts.QtCharts.QPieSlice.angleSpan": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.borderWidth": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.brush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.color": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.explodeDistanceFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isExploded": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.isLabelVisible": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.label": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelArmLengthFactor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelBrush": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelColor": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelFont": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.labelPosition": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.pen": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.percentage": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.series": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBorderWidth": ('int',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExplodeDistanceFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setExploded": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabel": ('str',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelArmLengthFactor": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelPosition": ('PySide2.QtCharts.QtCharts.QPieSlice.LabelPosition',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setLabelVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.setValue": ('float',),
-    "PySide2.QtCharts.QtCharts.QPieSlice.startAngle": (),
-    "PySide2.QtCharts.QtCharts.QPieSlice.value": (),
-# class PySide2.QtCharts.QtCharts.QPolarChart:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation:
-# class PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientations:
-    "PySide2.QtCharts.QtCharts.QPolarChart.__init__": ('PySide2.QtWidgets.QGraphicsItem', 'PySide2.QtCore.Qt.WindowFlags'),
-    "PySide2.QtCharts.QtCharts.QPolarChart.addAxis": [('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCharts.QtCharts.QPolarChart.PolarOrientation'), ('PySide2.QtCharts.QtCharts.QAbstractAxis', 'PySide2.QtCore.Qt.Alignment')],
-    "PySide2.QtCharts.QtCharts.QPolarChart.axisPolarOrientation": ('PySide2.QtCharts.QtCharts.QAbstractAxis',),
-# class PySide2.QtCharts.QtCharts.QScatterSeries:
-# class PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape:
-    "PySide2.QtCharts.QtCharts.QScatterSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.borderColor": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerShape": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.markerSize": (),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBorderColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerShape": ('PySide2.QtCharts.QtCharts.QScatterSeries.MarkerShape',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setMarkerSize": ('float',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QScatterSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QSplineSeries:
-    "PySide2.QtCharts.QtCharts.QSplineSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QSplineSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QStackedBarSeries:
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QStackedBarSeries.type": (),
-# class PySide2.QtCharts.QtCharts.QVBarModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.lastBarSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setLastBarSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBarModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QAbstractBarSeries',),
-# class PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper:
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.lastBoxSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setLastBoxSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVBoxPlotModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QBoxPlotSeries',),
-# class PySide2.QtCharts.QtCharts.QVCandlestickModelMapper:
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.closeRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.firstSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.highRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lastSetColumn": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.lowRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.openRow": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setCloseRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setFirstSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setHighRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLastSetColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setLowRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setOpenRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.setTimestampRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVCandlestickModelMapper.timestampRow": (),
-# class PySide2.QtCharts.QtCharts.QVPieModelMapper:
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.labelsColumn": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setLabelsColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QPieSeries',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.setValuesColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVPieModelMapper.valuesColumn": (),
-# class PySide2.QtCharts.QtCharts.QVXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.firstRow": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.rowCount": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setFirstRow": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setRowCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setXColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.setYColumn": ('int',),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.xColumn": (),
-    "PySide2.QtCharts.QtCharts.QVXYModelMapper.yColumn": (),
-# class PySide2.QtCharts.QtCharts.QValueAxis:
-    "PySide2.QtCharts.QtCharts.QValueAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.applyNiceNumbers": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.labelFormat": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.max": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.min": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.minorTickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setLabelFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMax": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMin": [('float',), ('typing.Any',)],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setMinorTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setRange": [('float', 'float'), ('typing.Any', 'typing.Any')],
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickAnchor": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.setTickInterval": ('float',),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickAnchor": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickCount": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.tickInterval": (),
-    "PySide2.QtCharts.QtCharts.QValueAxis.type": (),
-# class PySide2.QtCharts.QtCharts.QXYLegendMarker:
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.__init__": ('PySide2.QtCharts.QtCharts.QXYSeries', 'PySide2.QtCharts.QtCharts.QLegend', 'PySide2.QtCore.QObject'),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.series": (),
-    "PySide2.QtCharts.QtCharts.QXYLegendMarker.type": (),
-# class PySide2.QtCharts.QtCharts.QXYModelMapper:
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.count": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.first": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.model": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.orientation": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.series": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setCount": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setFirst": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setOrientation": ('PySide2.QtCore.Qt.Orientation',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setSeries": ('PySide2.QtCharts.QtCharts.QXYSeries',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setXSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.setYSection": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.xSection": (),
-    "PySide2.QtCharts.QtCharts.QXYModelMapper.ySection": (),
-# class PySide2.QtCharts.QtCharts.QXYSeries:
-    "PySide2.QtCharts.QtCharts.QXYSeries.__lshift__": [('PySide2.QtCore.QPointF',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.append": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.at": ('int',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.brush": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.clear": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.color": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.count": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.insert": ('int', 'PySide2.QtCore.QPointF'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pen": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsClipping": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsColor": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFont": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsFormat": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointLabelsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.points": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVector": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.pointsVisible": (),
-    "PySide2.QtCharts.QtCharts.QXYSeries.remove": [('PySide2.QtCore.QPointF',), ('float', 'float'), ('int',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.removePoints": ('int', 'int'),
-    "PySide2.QtCharts.QtCharts.QXYSeries.replace": [('PySide2.QtCore.QPointF', 'PySide2.QtCore.QPointF'), ('float', 'float', 'float', 'float'), ('int', 'PySide2.QtCore.QPointF'), ('int', 'float', 'float'), ('typing.List[PySide2.QtCore.QPointF]',), ('typing.Sequence[PySide2.QtCore.QPointF]',)],
-    "PySide2.QtCharts.QtCharts.QXYSeries.setBrush": ('PySide2.QtGui.QBrush',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPen": ('PySide2.QtGui.QPen',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsClipping": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsFormat": ('str',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointLabelsVisible": ('bool',),
-    "PySide2.QtCharts.QtCharts.QXYSeries.setPointsVisible": ('bool',),
-    }) if "PySide2.QtCharts" in sys.modules else None
-# Module PySide2.QtSvg
-sig_dict.update({
-# class PySide2.QtSvg.QGraphicsSvgItem:
-    "PySide2.QtSvg.QGraphicsSvgItem.__init__": [('PySide2.QtWidgets.QGraphicsItem',), ('str', 'PySide2.QtWidgets.QGraphicsItem')],
-    "PySide2.QtSvg.QGraphicsSvgItem.boundingRect": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.elementId": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.isCachingEnabled": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.maximumCacheSize": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.paint": ('PySide2.QtGui.QPainter', 'PySide2.QtWidgets.QStyleOptionGraphicsItem', 'PySide2.QtWidgets.QWidget'),
-    "PySide2.QtSvg.QGraphicsSvgItem.renderer": (),
-    "PySide2.QtSvg.QGraphicsSvgItem.setCachingEnabled": ('bool',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setElementId": ('str',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setMaximumCacheSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QGraphicsSvgItem.setSharedRenderer": ('PySide2.QtSvg.QSvgRenderer',),
-    "PySide2.QtSvg.QGraphicsSvgItem.type": (),
-# class PySide2.QtSvg.QSvgGenerator:
-    "PySide2.QtSvg.QSvgGenerator.__init__": (),
-    "PySide2.QtSvg.QSvgGenerator.description": (),
-    "PySide2.QtSvg.QSvgGenerator.fileName": (),
-    "PySide2.QtSvg.QSvgGenerator.metric": ('PySide2.QtGui.QPaintDevice.PaintDeviceMetric',),
-    "PySide2.QtSvg.QSvgGenerator.outputDevice": (),
-    "PySide2.QtSvg.QSvgGenerator.paintEngine": (),
-    "PySide2.QtSvg.QSvgGenerator.resolution": (),
-    "PySide2.QtSvg.QSvgGenerator.setDescription": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setFileName": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setOutputDevice": ('PySide2.QtCore.QIODevice',),
-    "PySide2.QtSvg.QSvgGenerator.setResolution": ('int',),
-    "PySide2.QtSvg.QSvgGenerator.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.QtSvg.QSvgGenerator.setTitle": ('str',),
-    "PySide2.QtSvg.QSvgGenerator.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgGenerator.size": (),
-    "PySide2.QtSvg.QSvgGenerator.title": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBox": (),
-    "PySide2.QtSvg.QSvgGenerator.viewBoxF": (),
-# class PySide2.QtSvg.QSvgRenderer:
-    "PySide2.QtSvg.QSvgRenderer.__init__": [('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',), ('PySide2.QtCore.QXmlStreamReader', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtSvg.QSvgRenderer.animated": (),
-    "PySide2.QtSvg.QSvgRenderer.animationDuration": (),
-    "PySide2.QtSvg.QSvgRenderer.boundsOnElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.currentFrame": (),
-    "PySide2.QtSvg.QSvgRenderer.defaultSize": (),
-    "PySide2.QtSvg.QSvgRenderer.elementExists": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.framesPerSecond": (),
-    "PySide2.QtSvg.QSvgRenderer.isValid": (),
-    "PySide2.QtSvg.QSvgRenderer.load": [('PySide2.QtCore.QByteArray',), ('PySide2.QtCore.QXmlStreamReader',), ('str',)],
-    "PySide2.QtSvg.QSvgRenderer.matrixForElement": ('str',),
-    "PySide2.QtSvg.QSvgRenderer.render": [('PySide2.QtGui.QPainter',), ('PySide2.QtGui.QPainter', 'PySide2.QtCore.QRectF'), ('PySide2.QtGui.QPainter', 'str', 'PySide2.QtCore.QRectF')],
-    "PySide2.QtSvg.QSvgRenderer.setCurrentFrame": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setFramesPerSecond": ('int',),
-    "PySide2.QtSvg.QSvgRenderer.setViewBox": [('PySide2.QtCore.QRect',), ('PySide2.QtCore.QRectF',)],
-    "PySide2.QtSvg.QSvgRenderer.viewBox": (),
-    "PySide2.QtSvg.QSvgRenderer.viewBoxF": (),
-# class PySide2.QtSvg.QSvgWidget:
-    "PySide2.QtSvg.QSvgWidget.__init__": [('PySide2.QtWidgets.QWidget',), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtSvg.QSvgWidget.load": [('PySide2.QtCore.QByteArray',), ('str',)],
-    "PySide2.QtSvg.QSvgWidget.paintEvent": ('PySide2.QtGui.QPaintEvent',),
-    "PySide2.QtSvg.QSvgWidget.renderer": (),
-    "PySide2.QtSvg.QSvgWidget.sizeHint": (),
-    }) if "PySide2.QtSvg" in sys.modules else None
-# Module PySide2.QtDataVisualization
-sig_dict.update({
-# class PySide2.QtDataVisualization.QtDataVisualization:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DBars:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barSpacing": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.barThickness": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.columnAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.floorLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.insertSeries": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isBarSpacingRelative": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.isMultiSeriesUniform": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.primarySeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.rowAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacing": ('PySide2.QtCore.QSizeF',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarSpacingRelative": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setBarThickness": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setColumnAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setFloorLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setMultiSeriesUniform": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setPrimarySeries": ('PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setRowAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.setValueAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DBars.valueAxis": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.cameraPreset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.maxZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.minZoomLevel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPosition": ('float', 'float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setCameraPreset": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.CameraPreset',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMaxZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setMinZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setTarget": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapXRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setWrapYRotation": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setXRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setYRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.setZoomLevel": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.target": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapXRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.wrapYRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.xRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.yRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera.zoomLevel": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isRotationEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isSelectionEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomAtTargetEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.isZoomEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setRotationEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setSelectionEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomAtTargetEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.setZoomEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DLight:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.isAutoPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DLight.setAutoPosition": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DObject:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.copyValuesFrom": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.isDirty": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.parentScene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DObject.setPosition": ('PySide2.QtGui.QVector3D',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScatter.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DScene:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.activeLight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.devicePixelRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.graphPositionQuery": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.invalidSelectionPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInPrimarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isPointInSecondarySubView": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSecondarySubviewOnTop": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.isSlicingActive": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.primarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.secondarySubViewport": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.selectionQueryPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveCamera": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DCamera',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setActiveLight": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DLight',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setDevicePixelRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setGraphPositionQuery": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setPrimarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubViewport": ('PySide2.QtCore.QRect',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSecondarySubviewOnTop": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSelectionQueryPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.setSlicingActive": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DScene.viewport": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.__init__": ('PySide2.QtGui.QSurfaceFormat', 'PySide2.QtGui.QWindow'),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.addSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.axisZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.flipHorizontalGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.releaseAxis": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.removeSeries": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.selectedSeries": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.seriesList": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisX": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisY": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setAxisZ": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DSurface.setFlipHorizontalGrid": ('bool',),
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle:
-# class PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme:
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ambientLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseColors": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.baseGradients": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.gridLineColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.highlightLightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isGridEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.isLabelBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelBackgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.labelTextColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.lightStrength": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setAmbientLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseColors": ('typing.Sequence[PySide2.QtGui.QColor]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setBaseGradients": ('typing.Sequence[PySide2.QtGui.QLinearGradient]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setGridLineColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setHighlightLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLabelTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setLightStrength": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setType": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.Theme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.setWindowColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.windowColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisOrientation:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.AxisType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isAutoAdjustRange": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleFixed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.isTitleVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labelAutoRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.max": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.min": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.orientation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setAutoAdjustRange": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabelAutoRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMax": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setMin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setRange": ('float', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitle": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleFixed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.setTitleVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.title": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DAxis.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ElementType:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHint:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeInputHandler": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.activeTheme": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.addTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.aspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.clearSelection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.currentFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.customItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.exposeEvent": ('PySide2.QtGui.QExposeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.hasContext": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.horizontalAspectRatio": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.inputHandlers": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isOrthoProjection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isPolar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.isReflection": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.margin": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.measureFps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mousePressEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.optimizationHints": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.queriedGraphPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.radialLabelOffset": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.reflectivity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.releaseTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItem": ('PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItemAt": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.removeCustomItems": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.renderToImage": ('int', 'PySide2.QtCore.QSize'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedAxis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedCustomItemIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedElement": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectedLabelIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.selectionMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveInputHandler": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setActiveTheme": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setHorizontalAspectRatio": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMargin": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setMeasureFps": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOptimizationHints": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.OptimizationHints',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setOrthoProjection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setPolar": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setRadialLabelOffset": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflection": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setReflectivity": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setSelectionMode": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.SelectionFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.setShadowQuality": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.ShadowQuality',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowQuality": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.shadowsSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.themes": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DGraph.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.inputView": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseDoubleClickEvent": ('PySide2.QtGui.QMouseEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseMoveEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mousePressEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.mouseReleaseEvent": ('PySide2.QtGui.QMouseEvent', 'PySide2.QtCore.QPoint'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.prevDistance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.previousInputPos": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.scene": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setInputView": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.InputView',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPrevDistance": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setPreviousInputPos": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.setScene": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DScene',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DInputHandler.wheelEvent": ('PySide2.QtGui.QWheelEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.SeriesType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.baseGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.colorStyle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isItemLabelVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isMeshSmooth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.itemLabelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.mesh": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.meshRotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.multiHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.name": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setBaseGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setColorStyle": ('PySide2.QtDataVisualization.QtDataVisualization.Q3DTheme.ColorStyle',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setItemLabelVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMesh": ('PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.Mesh',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMeshSmooth": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setMultiHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setName": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setSingleHighlightGradient": ('PySide2.QtGui.QLinearGradient',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setUserDefinedMesh": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.singleHighlightGradient": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.type": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstract3DSeries.userDefinedMesh": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.DataType:
-    "PySide2.QtDataVisualization.QtDataVisualization.QAbstractDataProxy.type": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.meshAngle": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.selectedBar": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setMeshAngle": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBar3DSeries.setSelectedBar": ('PySide2.QtCore.QPoint',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem',), ('float',), ('float', 'float')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setRotation": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.setValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem.value": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRow": [('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]',), ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.addRows": [('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.columnLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.insertRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.removeRows": ('int', 'int', 'bool'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.resetArray": [(), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]',), ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]', 'typing.Sequence[str]')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.rowLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setColumnLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRow": [('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]'), ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRowLabels": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QBarDataProxy.setRows": [('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]'), ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QBarDataItem]]', 'typing.Sequence[str]')],
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QBarDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.labels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCategory3DAxis.setLabels": ('typing.Sequence[str]',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtGui.QImage', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isPositionAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isScalingAbsolute": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isShadowCasting": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.isVisible": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.meshFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.scaling": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setMeshFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setPositionAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setRotationAxisAndAngle": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScaling": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setScalingAbsolute": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setShadowCasting": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setTextureImage": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.setVisible": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DItem.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtGui.QFont', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.backgroundColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.font": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBackgroundEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isBorderEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.isFacingCamera": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBackgroundEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setBorderEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFacingCamera": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setText": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.setTextColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.text": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DLabel.textColor": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume:
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion', 'int', 'int', 'int', 'typing.List[int]', 'PySide2.QtGui.QImage.Format', 'typing.List[int]', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.alphaMultiplier": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.colorTable": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.createTextureData": ('typing.List[PySide2.QtGui.QImage]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSliceFrames": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.drawSlices": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.preserveOpacity": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.renderSlice": ('PySide2.QtCore.Qt.Axis', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setAlphaMultiplier": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setColorTable": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSliceFrames": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setDrawSlices": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setPreserveOpacity": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameGaps": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameThicknesses": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceFrameWidths": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexX": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexY": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndexZ": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSliceIndices": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setSubTextureData": [('PySide2.QtCore.Qt.Axis', 'int', 'PySide2.QtGui.QImage'), ('PySide2.QtCore.Qt.Axis', 'int', 'str')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureData": ('typing.List[int]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDepth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureDimensions": ('int', 'int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureFormat": ('PySide2.QtGui.QImage.Format',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureHeight": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setTextureWidth": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.setUseHighDefShader": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameColor": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameGaps": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameThicknesses": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceFrameWidths": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexX": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexY": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.sliceIndexZ": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDataWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureDepth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureHeight": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.textureWidth": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QCustom3DVolume.useHighDefShader": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtGui.QImage', 'PySide2.QtCore.QObject'), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMap": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.heightMapFile": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.maxZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minXValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.minZValue": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMap": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setHeightMapFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMaxZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinXValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setMinZValue": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QHeightMapSurfaceDataProxy.setValueRanges": ('float', 'float', 'float', 'float'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.remap": ('str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.setValueRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelBarDataProxy.valueRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.remap": ('str', 'str', 'str', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.rotationRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setRotationRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelScatterDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy:
-# class PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior:
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.__init__": [('PySide2.QtCore.QAbstractItemModel', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QAbstractItemModel', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoColumnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.autoRowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.columnRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.itemModel": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.multiMatchBehavior": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.remap": ('str', 'str', 'str', 'str', 'str', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowCategoryIndex": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.rowRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoColumnCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setAutoRowCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setColumnRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setItemModel": ('PySide2.QtCore.QAbstractItemModel',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setMultiMatchBehavior": ('PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.MultiMatchBehavior',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowCategories": ('typing.Sequence[str]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setRowRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setUseModelCategories": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setXPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setYPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRole": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRolePattern": ('PySide2.QtCore.QRegExp',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.setZPosRoleReplace": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.useModelCategories": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.xPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.yPosRoleReplace": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRole": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRolePattern": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QItemModelSurfaceDataProxy.zPosRoleReplace": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.autoSubGrid": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.base": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setAutoSubGrid": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setBase": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.setShowEdgeLabels": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.showEdgeLabels": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QLogValue3DAxisFormatter.valueAt": ('float',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.invalidSelectionIndex": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.itemSize": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.selectedItem": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setItemSize": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatter3DSeries.setSelectedItem": ('int',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',), ('PySide2.QtGui.QVector3D',), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QQuaternion')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.rotation": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItem": ('PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.addItems": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.insertItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemAt": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.itemCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.removeItems": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.resetArray": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItem": ('int', 'PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QScatterDataProxy.setItems": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QScatterDataItem]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlag:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy', 'PySide2.QtCore.QObject')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.dataProxy": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.drawMode": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.invalidSelectionPosition": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingEnabled": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.isFlatShadingSupported": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.selectedPoint": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDataProxy": ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setDrawMode": ('PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.DrawFlags',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setFlatShadingEnabled": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setSelectedPoint": ('PySide2.QtCore.QPoint',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTexture": ('PySide2.QtGui.QImage',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.setTextureFile": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.texture": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurface3DSeries.textureFile": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataArray._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__init__": [(), ('PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem',), ('PySide2.QtGui.QVector3D',)],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.__copy__": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.createExtraData": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.position": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setX": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setY": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.setZ": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.x": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.y": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem.z": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy:
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRow": ('typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.addRows": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.array": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.columnCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.insertRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.itemAt": [('PySide2.QtCore.QPoint',), ('int', 'int')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.removeRows": ('int', 'int'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.resetArray": ('typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.rowCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.series": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setItem": [('PySide2.QtCore.QPoint', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem'), ('int', 'int', 'PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem')],
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRow": ('int', 'typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataProxy.setRows": ('int', 'typing.List[typing.List[PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataItem]]'),
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow.__origin__.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__extra__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QSurfaceDataRow._gorg.__next_in_mro__:
-# class PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler:
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QTouch3DInputHandler.touchEvent": ('PySide2.QtGui.QTouchEvent',),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.formatter": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.labelFormat": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.reversed": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.segmentCount": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setFormatter": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setLabelFormat": ('str',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setReversed": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.setSubSegmentCount": ('int',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxis.subSegmentCount": (),
-# class PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter:
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowNegatives": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.allowZero": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.axis": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.createNewInstance": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.gridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.labelStrings": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.locale": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.markDirty": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.populateCopy": ('PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.positionAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.recalculate": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowNegatives": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setAllowZero": ('bool',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.setLocale": ('PySide2.QtCore.QLocale',),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.stringForValue": ('float', 'str'),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.subGridPositions": (),
-    "PySide2.QtDataVisualization.QtDataVisualization.QValue3DAxisFormatter.valueAt": ('float',),
-    "PySide2.QtDataVisualization.QtDataVisualization.qDefaultSurfaceFormat": ('bool',),
-    }) if "PySide2.QtDataVisualization" in sys.modules else None
-# Module PySide2.QtUiTools
-sig_dict.update({
-# class PySide2.QtUiTools.QUiLoader:
-    "PySide2.QtUiTools.QUiLoader.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtUiTools.QUiLoader.addPluginPath": ('str',),
-    "PySide2.QtUiTools.QUiLoader.availableLayouts": (),
-    "PySide2.QtUiTools.QUiLoader.availableWidgets": (),
-    "PySide2.QtUiTools.QUiLoader.clearPluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.createAction": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createActionGroup": ('PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createLayout": ('str', 'PySide2.QtCore.QObject', 'str'),
-    "PySide2.QtUiTools.QUiLoader.createWidget": ('str', 'PySide2.QtWidgets.QWidget', 'str'),
-    "PySide2.QtUiTools.QUiLoader.errorString": (),
-    "PySide2.QtUiTools.QUiLoader.isLanguageChangeEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.isTranslationEnabled": (),
-    "PySide2.QtUiTools.QUiLoader.load": [('PySide2.QtCore.QIODevice', 'PySide2.QtWidgets.QWidget'), ('str', 'PySide2.QtWidgets.QWidget')],
-    "PySide2.QtUiTools.QUiLoader.pluginPaths": (),
-    "PySide2.QtUiTools.QUiLoader.registerCustomWidget": ('object',),
-    "PySide2.QtUiTools.QUiLoader.setLanguageChangeEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setTranslationEnabled": ('bool',),
-    "PySide2.QtUiTools.QUiLoader.setWorkingDirectory": ('PySide2.QtCore.QDir',),
-    "PySide2.QtUiTools.QUiLoader.workingDirectory": (),
-    }) if "PySide2.QtUiTools" in sys.modules else None
-# Module PySide2.QtWebChannel
-sig_dict.update({
-# class PySide2.QtWebChannel.QWebChannel:
-    "PySide2.QtWebChannel.QWebChannel.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.blockUpdates": (),
-    "PySide2.QtWebChannel.QWebChannel.connectTo": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.deregisterObject": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannel.disconnectFrom": ('PySide2.QtWebChannel.QWebChannelAbstractTransport',),
-    "PySide2.QtWebChannel.QWebChannel.registerObject": ('str', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebChannel.QWebChannel.registerObjects": ('typing.Dict[str, PySide2.QtCore.QObject]',),
-    "PySide2.QtWebChannel.QWebChannel.registeredObjects": (),
-    "PySide2.QtWebChannel.QWebChannel.setBlockUpdates": ('bool',),
-# class PySide2.QtWebChannel.QWebChannelAbstractTransport:
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebChannel.QWebChannelAbstractTransport.sendMessage": ('typing.Dict[str, PySide2.QtCore.QJsonValue]',),
-    }) if "PySide2.QtWebChannel" in sys.modules else None
-# Module PySide2.QtWebEngineCore
-sig_dict.update({
-# class PySide2.QtWebEngineCore.QWebEngineCookieStore:
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteAllCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.deleteSessionCookies": (),
-    "PySide2.QtWebEngineCore.QWebEngineCookieStore.loadAllCookies": (),
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest:
-# class PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method:
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.__init__": [('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method'), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.hasHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.header": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.headers": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.method": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postData": (),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.postRequest": ('PySide2.QtCore.QUrl', 'typing.Dict[str, str]'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setMethod": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest.Method',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setPostData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.swap": ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.unsetHeader": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineHttpRequest.url": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.NavigationType:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.ResourceType:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.block": ('bool',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.changed": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.firstPartyUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.navigationType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.requestUrl": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.resourceType": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo.setHttpHeader": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QByteArray'),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor.interceptRequest": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInfo',),
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob:
-# class PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error:
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.fail": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.Error',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.initiator": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.redirect": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.reply": ('PySide2.QtCore.QByteArray', 'PySide2.QtCore.QIODevice'),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestHeaders": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestMethod": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlRequestJob.requestUrl": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flag:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.SpecialPort:
-# class PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax:
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__init__": [(), ('PySide2.QtCore.QByteArray',), ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',)],
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.__copy__": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.defaultPort": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.flags": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.name": (),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.registerScheme": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.schemeByName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setDefaultPort": ('int',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setFlags": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Flags',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.setSyntax": ('PySide2.QtWebEngineCore.QWebEngineUrlScheme.Syntax',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlScheme.syntax": (),
-# class PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler:
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler.requestStarted": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestJob',),
-    }) if "PySide2.QtWebEngineCore" in sys.modules else None
-# Module PySide2.QtWebEngine
-sig_dict.update({
-# class PySide2.QtWebEngine.QtWebEngine:
-    "PySide2.QtWebEngine.QtWebEngine.initialize": (),
-    }) if "PySide2.QtWebEngine" in sys.modules else None
-# Module PySide2.QtWebEngineWidgets
-sig_dict.update({
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError:
-# class PySide2.QtWebEngineWidgets.QWebEngineCertificateError.Error:
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.__init__": [('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',), ('int', 'PySide2.QtCore.QUrl', 'bool', 'str')],
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.answered": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.certificateChain": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.defer": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.deferred": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.error": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.errorDescription": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.ignoreCertificateError": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.isOverridable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.rejectCertificate": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineCertificateError.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.EditFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlag:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaFlags:
-# class PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.MediaType:
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineContextMenuData',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.editFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isContentEditable": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.linkUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaFlags": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.mediaUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.misspelledWord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.position": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineContextMenuData.spellCheckerSuggestions": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadInterruptReason:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadState:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.DownloadType:
-# class PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat:
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.cancel": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadDirectory": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.downloadFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.id": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReason": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.interruptReasonString": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isFinished": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isPaused": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.isSavePageDownload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.mimeType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.path": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.pause": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.receivedBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.resume": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.savePageFormat": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadDirectory": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setDownloadFileName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.setSavePageFormat": ('PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat',),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.state": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.suggestedFileName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.totalBytes": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.type": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest:
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.accept": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.origin": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.reject": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineFullScreenRequest.toggleOn": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistory:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__lshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.__rshift__": ('PySide2.QtCore.QDataStream',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.backItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoBack": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.canGoForward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.currentItemIndex": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItem": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.forwardItems": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.goToItem": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.itemAt": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistory.items": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineHistoryItem:
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__init__": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.isValid": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.lastVisited": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.originalUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.swap": ('PySide2.QtWebEngineWidgets.QWebEngineHistoryItem',),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineHistoryItem.url": (),
-# class PySide2.QtWebEngineWidgets.QWebEnginePage:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.Feature:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlag:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.RenderProcessTerminationStatus:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction:
-# class PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType:
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.__init__": [('PySide2.QtCore.QObject',), ('PySide2.QtWebEngineWidgets.QWebEngineProfile', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.acceptNavigationRequest": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.NavigationType', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.action": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.backgroundColor": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.certificateError": ('PySide2.QtWebEngineWidgets.QWebEngineCertificateError',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.chooseFiles": ('PySide2.QtWebEngineWidgets.QWebEnginePage.FileSelectionMode', 'typing.Sequence[str]', 'typing.Sequence[str]'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contentsSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.contextMenuData": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createStandardContextMenu": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.devToolsPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.download": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.inspectedPage": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isAudioMuted": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.isVisible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptAlert": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConfirm": ('PySide2.QtCore.QUrl', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptConsoleMessage": ('PySide2.QtWebEngineWidgets.QWebEnginePage.JavaScriptConsoleMessageLevel', 'str', 'int', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.javaScriptPrompt": ('PySide2.QtCore.QUrl', 'str', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.printToPdf": [('object', 'PySide2.QtGui.QPageLayout'), ('str', 'PySide2.QtGui.QPageLayout')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.profile": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.recentlyAudible": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.replaceMisspelledWord": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.requestedUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.runJavaScript": [('str',), ('str', 'int'), ('str', 'int', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.save": ('str', 'PySide2.QtWebEngineWidgets.QWebEngineDownloadItem.SavePageFormat'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.scrollPosition": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setAudioMuted": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setBackgroundColor": ('PySide2.QtGui.QColor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setDevToolsPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setFeaturePermission": ('PySide2.QtCore.QUrl', 'PySide2.QtWebEngineWidgets.QWebEnginePage.Feature', 'PySide2.QtWebEngineWidgets.QWebEnginePage.PermissionPolicy'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setInspectedPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setView": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setVisible": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setWebChannel": [('PySide2.QtWebChannel.QWebChannel',), ('PySide2.QtWebChannel.QWebChannel', 'int')],
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toHtml": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.toPlainText": ('object',),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.triggerAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.view": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.webChannel": (),
-    "PySide2.QtWebEngineWidgets.QWebEnginePage.zoomFactor": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType:
-# class PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy:
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.__init__": [('PySide2.QtCore.QObject',), ('str', 'PySide2.QtCore.QObject')],
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cachePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearAllVisitedLinks": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearHttpCache": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.clearVisitedLinks": ('typing.Sequence[PySide2.QtCore.QUrl]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.cookieStore": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.defaultProfile": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.downloadPath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpAcceptLanguage": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheMaximumSize": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpCacheType": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.httpUserAgent": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.installUrlSchemeHandler": ('PySide2.QtCore.QByteArray', 'PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler'),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isOffTheRecord": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isSpellCheckEnabled": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.isUsedForGlobalCertificateVerification": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentCookiesPolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.persistentStoragePath": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeAllUrlSchemeHandlers": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlScheme": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.removeUrlSchemeHandler": ('PySide2.QtWebEngineCore.QWebEngineUrlSchemeHandler',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.scripts": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setCachePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setDownloadPath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpAcceptLanguage": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheMaximumSize": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpCacheType": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.HttpCacheType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setHttpUserAgent": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentCookiesPolicy": ('PySide2.QtWebEngineWidgets.QWebEngineProfile.PersistentCookiesPolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setPersistentStoragePath": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckEnabled": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setSpellCheckLanguages": ('typing.Sequence[str]',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUrlRequestInterceptor": ('PySide2.QtWebEngineCore.QWebEngineUrlRequestInterceptor',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.setUseForGlobalCertificateVerification": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.spellCheckLanguages": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.storageName": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.urlSchemeHandler": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebEngineWidgets.QWebEngineProfile.visitedLinksContainsUrl": ('PySide2.QtCore.QUrl',),
-# class PySide2.QtWebEngineWidgets.QWebEngineScript:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint:
-# class PySide2.QtWebEngineWidgets.QWebEngineScript.ScriptWorldId:
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__init__": [(), ('PySide2.QtWebEngineWidgets.QWebEngineScript',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.__copy__": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.injectionPoint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.isNull": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.name": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.runsOnSubFrames": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setInjectionPoint": ('PySide2.QtWebEngineWidgets.QWebEngineScript.InjectionPoint',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setName": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setRunsOnSubFrames": ('bool',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setSourceCode": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.setWorldId": ('int',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.sourceCode": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.swap": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScript.worldId": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineScriptCollection:
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.clear": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.contains": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.count": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScript": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.findScripts": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.insert": [('PySide2.QtWebEngineWidgets.QWebEngineScript',), ('typing.Sequence[PySide2.QtWebEngineWidgets.QWebEngineScript]',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.isEmpty": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.remove": ('PySide2.QtWebEngineWidgets.QWebEngineScript',),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.size": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineScriptCollection.toList": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy:
-# class PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute:
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.defaultTextEncoding": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.fontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.globalSettings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.resetUnknownUrlSchemePolicy": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setDefaultTextEncoding": ('str',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontFamily": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontFamily', 'str'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setFontSize": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.FontSize', 'int'),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.setUnknownUrlSchemePolicy": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.UnknownUrlSchemePolicy',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.testAttribute": ('PySide2.QtWebEngineWidgets.QWebEngineSettings.WebAttribute',),
-    "PySide2.QtWebEngineWidgets.QWebEngineSettings.unknownUrlSchemePolicy": (),
-# class PySide2.QtWebEngineWidgets.QWebEngineView:
-    "PySide2.QtWebEngineWidgets.QWebEngineView.__init__": ('PySide2.QtWidgets.QWidget',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.back": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.closeEvent": ('PySide2.QtGui.QCloseEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.contextMenuEvent": ('PySide2.QtGui.QContextMenuEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.createWindow": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebWindowType',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragEnterEvent": ('PySide2.QtGui.QDragEnterEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragLeaveEvent": ('PySide2.QtGui.QDragLeaveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dragMoveEvent": ('PySide2.QtGui.QDragMoveEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.dropEvent": ('PySide2.QtGui.QDropEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.findText": [('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags'), ('str', 'PySide2.QtWebEngineWidgets.QWebEnginePage.FindFlags', 'object')],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.forward": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hasSelection": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.hideEvent": ('PySide2.QtGui.QHideEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.history": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.icon": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.iconUrl": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.load": [('PySide2.QtCore.QUrl',), ('PySide2.QtWebEngineCore.QWebEngineHttpRequest',)],
-    "PySide2.QtWebEngineWidgets.QWebEngineView.page": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.pageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.reload": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.selectedText": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setContent": ('PySide2.QtCore.QByteArray', 'str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setHtml": ('str', 'PySide2.QtCore.QUrl'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setPage": ('PySide2.QtWebEngineWidgets.QWebEnginePage',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setUrl": ('PySide2.QtCore.QUrl',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.setZoomFactor": ('float',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.settings": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.showEvent": ('PySide2.QtGui.QShowEvent',),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.sizeHint": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.stop": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.title": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.triggerPageAction": ('PySide2.QtWebEngineWidgets.QWebEnginePage.WebAction', 'bool'),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.url": (),
-    "PySide2.QtWebEngineWidgets.QWebEngineView.zoomFactor": (),
-    }) if "PySide2.QtWebEngineWidgets" in sys.modules else None
-# Module PySide2.QtWebSockets
-sig_dict.update({
-# class PySide2.QtWebSockets.QMaskGenerator:
-    "PySide2.QtWebSockets.QMaskGenerator.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.QtWebSockets.QMaskGenerator.nextMask": (),
-    "PySide2.QtWebSockets.QMaskGenerator.seed": (),
-# class PySide2.QtWebSockets.QWebSocket:
-    "PySide2.QtWebSockets.QWebSocket.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketProtocol.Version', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocket.abort": (),
-    "PySide2.QtWebSockets.QWebSocket.bytesToWrite": (),
-    "PySide2.QtWebSockets.QWebSocket.close": ('PySide2.QtWebSockets.QWebSocketProtocol.CloseCode', 'str'),
-    "PySide2.QtWebSockets.QWebSocket.closeCode": (),
-    "PySide2.QtWebSockets.QWebSocket.closeReason": (),
-    "PySide2.QtWebSockets.QWebSocket.error": (),
-    "PySide2.QtWebSockets.QWebSocket.errorString": (),
-    "PySide2.QtWebSockets.QWebSocket.flush": (),
-    "PySide2.QtWebSockets.QWebSocket.isValid": (),
-    "PySide2.QtWebSockets.QWebSocket.localAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.localPort": (),
-    "PySide2.QtWebSockets.QWebSocket.maskGenerator": (),
-    "PySide2.QtWebSockets.QWebSocket.open": [('PySide2.QtCore.QUrl',), ('PySide2.QtNetwork.QNetworkRequest',)],
-    "PySide2.QtWebSockets.QWebSocket.origin": (),
-    "PySide2.QtWebSockets.QWebSocket.pauseMode": (),
-    "PySide2.QtWebSockets.QWebSocket.peerAddress": (),
-    "PySide2.QtWebSockets.QWebSocket.peerName": (),
-    "PySide2.QtWebSockets.QWebSocket.peerPort": (),
-    "PySide2.QtWebSockets.QWebSocket.ping": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.proxy": (),
-    "PySide2.QtWebSockets.QWebSocket.readBufferSize": (),
-    "PySide2.QtWebSockets.QWebSocket.request": (),
-    "PySide2.QtWebSockets.QWebSocket.requestUrl": (),
-    "PySide2.QtWebSockets.QWebSocket.resourceName": (),
-    "PySide2.QtWebSockets.QWebSocket.resume": (),
-    "PySide2.QtWebSockets.QWebSocket.sendBinaryMessage": ('PySide2.QtCore.QByteArray',),
-    "PySide2.QtWebSockets.QWebSocket.sendTextMessage": ('str',),
-    "PySide2.QtWebSockets.QWebSocket.setMaskGenerator": ('PySide2.QtWebSockets.QMaskGenerator',),
-    "PySide2.QtWebSockets.QWebSocket.setPauseMode": ('PySide2.QtNetwork.QAbstractSocket.PauseModes',),
-    "PySide2.QtWebSockets.QWebSocket.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocket.setReadBufferSize": ('int',),
-    "PySide2.QtWebSockets.QWebSocket.state": (),
-    "PySide2.QtWebSockets.QWebSocket.version": (),
-# class PySide2.QtWebSockets.QWebSocketCorsAuthenticator:
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.__init__": [('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',), ('str',)],
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.allowed": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.origin": (),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.setAllowed": ('bool',),
-    "PySide2.QtWebSockets.QWebSocketCorsAuthenticator.swap": ('PySide2.QtWebSockets.QWebSocketCorsAuthenticator',),
-# class PySide2.QtWebSockets.QWebSocketProtocol:
-# class PySide2.QtWebSockets.QWebSocketProtocol.CloseCode:
-# class PySide2.QtWebSockets.QWebSocketProtocol.Version:
-# class PySide2.QtWebSockets.QWebSocketServer:
-# class PySide2.QtWebSockets.QWebSocketServer.SslMode:
-    "PySide2.QtWebSockets.QWebSocketServer.__init__": ('str', 'PySide2.QtWebSockets.QWebSocketServer.SslMode', 'PySide2.QtCore.QObject'),
-    "PySide2.QtWebSockets.QWebSocketServer.close": (),
-    "PySide2.QtWebSockets.QWebSocketServer.error": (),
-    "PySide2.QtWebSockets.QWebSocketServer.errorString": (),
-    "PySide2.QtWebSockets.QWebSocketServer.handleConnection": ('PySide2.QtNetwork.QTcpSocket',),
-    "PySide2.QtWebSockets.QWebSocketServer.handshakeTimeoutMS": (),
-    "PySide2.QtWebSockets.QWebSocketServer.hasPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.isListening": (),
-    "PySide2.QtWebSockets.QWebSocketServer.listen": ('PySide2.QtNetwork.QHostAddress', 'int'),
-    "PySide2.QtWebSockets.QWebSocketServer.maxPendingConnections": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nativeDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.nextPendingConnection": (),
-    "PySide2.QtWebSockets.QWebSocketServer.pauseAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.proxy": (),
-    "PySide2.QtWebSockets.QWebSocketServer.resumeAccepting": (),
-    "PySide2.QtWebSockets.QWebSocketServer.secureMode": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverAddress": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverName": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverPort": (),
-    "PySide2.QtWebSockets.QWebSocketServer.serverUrl": (),
-    "PySide2.QtWebSockets.QWebSocketServer.setHandshakeTimeout": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setMaxPendingConnections": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setNativeDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.setProxy": ('PySide2.QtNetwork.QNetworkProxy',),
-    "PySide2.QtWebSockets.QWebSocketServer.setServerName": ('str',),
-    "PySide2.QtWebSockets.QWebSocketServer.setSocketDescriptor": ('int',),
-    "PySide2.QtWebSockets.QWebSocketServer.socketDescriptor": (),
-    "PySide2.QtWebSockets.QWebSocketServer.supportedVersions": (),
-    }) if "PySide2.QtWebSockets" in sys.modules else None
-# Module PySide2.Qt3DCore
-sig_dict.update({
-# class PySide2.Qt3DCore.Qt3DCore:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlag:
-# class PySide2.Qt3DCore.Qt3DCore.ChangeFlags:
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractAspect:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.rootEntityId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractAspect.unregisterBackendType": ('PySide2.QtCore.QMetaObject',),
-# class PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton.jointCount": (),
-# class PySide2.Qt3DCore.Qt3DCore.QArmature:
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DCore.Qt3DCore.QArmature.skeleton": (),
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine:
-# class PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.aspects": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.executeCommand": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.processFrame": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.runMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.setRunMode": ('PySide2.Qt3DCore.Qt3DCore.QAspectEngine.RunMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectEngine.unregisterAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-# class PySide2.Qt3DCore.Qt3DCore.QAspectJob:
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.__init__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QAspectJob.run": (),
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode:
-# class PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode:
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QBackendNode.Mode',),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.mode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.peerId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QBackendNode.setEnabled": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponent:
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.entities": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.isShareable": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponent.setShareable": ('bool',),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentAddedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.__init__": [('PySide2.Qt3DCore.Qt3DCore.QComponent', 'PySide2.Qt3DCore.Qt3DCore.QEntity'), ('PySide2.Qt3DCore.Qt3DCore.QEntity', 'PySide2.Qt3DCore.Qt3DCore.QComponent')],
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.componentMetaObject": (),
-    "PySide2.Qt3DCore.Qt3DCore.QComponentRemovedChange.entityId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setPropertyName": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QDynamicPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QEntity:
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.addComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.components": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.parentEntity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QEntity.removeComponent": ('PySide2.Qt3DCore.Qt3DCore.QComponent',),
-# class PySide2.Qt3DCore.Qt3DCore.QJoint:
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.addChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.childJoints": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.inverseBindMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.removeChildJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setInverseBindMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setScale": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setToIdentity": (),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QJoint.translation": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNode:
-# class PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode:
-    "PySide2.Qt3DCore.Qt3DCore.QNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.blockNotifications": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.childNodes": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.clearPropertyTrackings": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.defaultPropertyTrackingMode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.isEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.notificationsBlocked": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.parentNode": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.propertyTracking": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setDefaultPropertyTrackingMode": ('PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setParent": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QObject',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNode.setPropertyTracking": ('str', 'PySide2.Qt3DCore.Qt3DCore.QNode.PropertyTrackingMode'),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCommand:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.commandId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.data": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.inReplyTo": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.name": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setData": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setName": ('str',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCommand.setReplyToCommandId": ('int',),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.isNodeEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeCreatedChangeBase.parentId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode', 'typing.List[PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair]'),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeDestroyedChange.subtreeIdsAndTypes": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeId:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.__copy__": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.createId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.id": (),
-    "PySide2.Qt3DCore.Qt3DCore.QNodeId.isNull": (),
-# class PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair:
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__init__": [(), ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.QtCore.QMetaObject'), ('PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair',)],
-    "PySide2.Qt3DCore.Qt3DCore.QNodeIdTypePair.__copy__": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeAddedChange.addedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNode'),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyNodeRemovedChange.removedNodeId": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.setValue": ('typing.Any',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChange.value": (),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.addedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChange.setAddedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.removedValue": (),
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChange.setRemovedValue": ('typing.Any',),
-# class PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlag:
-# class PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags:
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.__init__": ('PySide2.Qt3DCore.Qt3DCore.ChangeFlag', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.deliveryFlags": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.setDeliveryFlags": ('PySide2.Qt3DCore.Qt3DCore.QSceneChange.DeliveryFlags',),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.subjectId": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSceneChange.type": (),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeleton:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeleton.setRootJoint": ('PySide2.Qt3DCore.Qt3DCore.QJoint',),
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader:
-# class PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.Status:
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.isCreateJointsEnabled": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.rootJoint": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setCreateJointsEnabled": ('bool',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.source": (),
-    "PySide2.Qt3DCore.Qt3DCore.QSkeletonLoader.status": (),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyUpdatedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueAddedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase:
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.propertyName": (),
-    "PySide2.Qt3DCore.Qt3DCore.QStaticPropertyValueRemovedChangeBase.setPropertyName": ('str',),
-# class PySide2.Qt3DCore.Qt3DCore.QTransform:
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxesAndAngles": [('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromAxisAndAngle": [('PySide2.QtGui.QVector3D', 'float'), ('float', 'float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.fromEulerAngles": [('PySide2.QtGui.QVector3D',), ('float', 'float', 'float')],
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.matrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateAround": ('PySide2.QtGui.QVector3D', 'float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotateFromAxes": ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationX": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationY": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.rotationZ": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.scale3D": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotation": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationX": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationY": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setRotationZ": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale": ('float',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setScale3D": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.setTranslation": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.translation": (),
-    "PySide2.Qt3DCore.Qt3DCore.QTransform.worldMatrix": (),
-    "PySide2.Qt3DCore.Qt3DCore.qHash": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'int'),
-    "PySide2.Qt3DCore.Qt3DCore.qIdForNode": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    }) if "PySide2.Qt3DCore" in sys.modules else None
-# Module PySide2.Qt3DRender
-sig_dict.update({
-# class PySide2.Qt3DRender.Qt3DRender:
-# class PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface:
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.PropertyReaderInterface.readProperty": ('typing.Any',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractFunctor.id": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractLight.Type:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.color": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.intensity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.setIntensity": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractLight.type": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.hits": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.runMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.FilterMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.setRunMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractRayCaster.RunMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target:
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.addTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.generateMipMaps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.removeTextureImage": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.samples": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setGenerateMipMaps": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSamples": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setSize": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.setWrapMode": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.textureImages": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.wrapMode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.notifyDataGeneratorChanged": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAbstractTextureImage.setMipLevel": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaCoverage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest:
-# class PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.alphaFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setAlphaFunction": ('PySide2.Qt3DRender.Qt3DRender.QAlphaTest.AlphaFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QAlphaTest.setReferenceValue": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType:
-# class PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType:
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('PySide2.Qt3DRender.Qt3DRender.QBuffer', 'str', 'PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType', 'int', 'int', 'int', 'int', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.attributeType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.buffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.byteStride": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.count": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultColorAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointIndicesAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultJointWeightsAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultNormalAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultPositionAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTangentAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate1AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinate2AttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.defaultTextureCoordinateAttributeName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.divisor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setAttributeType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.AttributeType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setBuffer": ('PySide2.Qt3DRender.Qt3DRender.QBuffer',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setByteStride": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDataType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setDivisor": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexBaseType": ('PySide2.Qt3DRender.Qt3DRender.QAttribute.VertexBaseType',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.setVertexSize": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexBaseType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QAttribute.vertexSize": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.blendFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquation.setBlendFunction": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending:
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.bufferIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.destinationRgb": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setBufferIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setDestinationRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceAlpha": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgb": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.setSourceRgba": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceAlpha": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.sourceRgb": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod:
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destination": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.destinationRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.interpolationMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestination": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setDestinationRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setInterpolationMethod": ('PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.InterpolationMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSource": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.setSourceRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceAttachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBlitFramebuffer.sourceRect": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType:
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.accessType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.data": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.isSyncData": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setAccessType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.AccessType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setData": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setSyncData": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setType": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.setUsage": ('PySide2.Qt3DRender.Qt3DRender.QBuffer.UsageType',),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.updateData": ('int', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QBuffer.usage": (),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator:
-    "PySide2.Qt3DRender.Qt3DRender.QBufferDataGenerator.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCamera:
-# class PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption:
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.lens": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.pan": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panAboutViewCenter": [('float',), ('float', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.panRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.roll": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rollRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotate": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotateAboutViewCenter": ('PySide2.QtGui.QQuaternion',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.rotation": ('float', 'PySide2.QtGui.QVector3D'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setPosition": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setUpVector": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.setViewCenter": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tilt": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltAboutViewCenter": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.tiltRotation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.transform": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translate": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.translateWorld": ('PySide2.QtGui.QVector3D', 'PySide2.Qt3DRender.Qt3DRender.QCamera.CameraTranslationOption'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.upVector": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewCenter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCamera.viewVector": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens:
-# class PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.aspectRatio": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.exposure": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.farPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.fieldOfView": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.nearPlane": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionMatrix": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.projectionType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.right": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setAspectRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setBottom": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setExposure": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFarPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFieldOfView": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setFrustumProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setLeft": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setNearPlane": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setOrthographicProjection": ('float', 'float', 'float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setPerspectiveProjection": ('float', 'float', 'float', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionMatrix": ('PySide2.QtGui.QMatrix4x4',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setProjectionType": ('PySide2.Qt3DRender.Qt3DRender.QCameraLens.ProjectionType',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setRight": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.setTop": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.top": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewAll": ('PySide2.Qt3DCore.Qt3DCore.QNodeId',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraLens.viewEntity": ('PySide2.Qt3DCore.Qt3DCore.QNodeId', 'PySide2.Qt3DCore.Qt3DCore.QNodeId'),
-# class PySide2.Qt3DRender.Qt3DRender.QCameraSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCameraSelector.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType:
-# class PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferTypeFlags:
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.buffers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearColor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearDepthValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.clearStencilValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.colorBuffer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setBuffers": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearDepthValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setClearStencilValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QClearBuffers.setColorBuffer": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QClipPlane:
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.normal": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.planeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setDistance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setNormal": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QClipPlane.setPlaneIndex": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QColorMask:
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isAlphaMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isBlueMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isGreenMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.isRedMasked": (),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setAlphaMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setBlueMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setGreenMasked": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QColorMask.setRedMasked": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand:
-# class PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType:
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.runType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setRunType": ('PySide2.Qt3DRender.Qt3DRender.QComputeCommand.RunType',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.trigger": [('int',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QComputeCommand.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace:
-# class PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode:
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.mode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QCullFace.setMode": ('PySide2.Qt3DRender.Qt3DRender.QCullFace.CullingMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest:
-# class PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.depthFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDepthTest.setDepthFunction": ('PySide2.Qt3DRender.Qt3DRender.QDepthTest.DepthFunction',),
-# class PySide2.Qt3DRender.Qt3DRender.QDirectionalLight:
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.setWorldDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QDirectionalLight.worldDirection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDispatchCompute:
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupX": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupY": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.setWorkGroupZ": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QDispatchCompute.workGroupZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QDithering:
-    "PySide2.Qt3DRender.Qt3DRender.QDithering.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QEffect:
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.addTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.removeTechnique": ('PySide2.Qt3DRender.Qt3DRender.QTechnique',),
-    "PySide2.Qt3DRender.Qt3DRender.QEffect.techniques": (),
-# class PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight:
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.irradiance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setIrradiance": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QEnvironmentLight.specular": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFilterKey:
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QFilterKey.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode.parentFrameGraphNode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase:
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.__init__": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrameGraphNodeCreatedChangeBase.parentFrameGraphNodeId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace:
-# class PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection:
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QFrontFace.setDirection": ('PySide2.Qt3DRender.Qt3DRender.QFrontFace.WindingDirection',),
-# class PySide2.Qt3DRender.Qt3DRender.QFrustumCulling:
-    "PySide2.Qt3DRender.Qt3DRender.QFrustumCulling.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometry:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.attributes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.boundingVolumePositionAttribute": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.maxExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.minExtent": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometry.setBoundingVolumePositionAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryFactory:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryFactory.__init__": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer:
-# class PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType:
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstInstance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.firstVertex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.geometry": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexBufferByteOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.indexOffset": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.instanceCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveRestartEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.primitiveType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.restartIndexValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstInstance": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setFirstVertex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexBufferByteOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setIndexOffset": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setInstanceCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVertexCount": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.setVerticesPerPatch": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.vertexCount": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.verticesPerPatch": (),
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api:
-# class PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile:
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.api": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.extensions": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.majorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.minorVersion": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.profile": (),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setApi": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.Api',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setExtensions": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMajorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setMinorVersion": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setProfile": ('PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.OpenGLProfile',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.setVendor": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QGraphicsApiFilter.vendor": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLayer:
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.recursive": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayer.setRecursive": ('bool',),
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter:
-# class PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode:
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.addLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.filterMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.removeLayer": ('PySide2.Qt3DRender.Qt3DRender.QLayer',),
-    "PySide2.Qt3DRender.Qt3DRender.QLayerFilter.setFilterMode": ('PySide2.Qt3DRender.Qt3DRender.QLayerFilter.FilterMode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail:
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.camera": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.createBoundingSphere": ('PySide2.QtGui.QVector3D', 'float'),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.currentIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setCurrentIndex": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholdType": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.ThresholdType',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setThresholds": ('typing.List[float]',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.setVolumeOverride": ('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholdType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.thresholds": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetail.volumeOverride": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.__init__": [('PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere',), ('PySide2.QtGui.QVector3D', 'float')],
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.center": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.isEmpty": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailBoundingSphere.radius": (),
-# class PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch:
-    "PySide2.Qt3DRender.Qt3DRender.QLevelOfDetailSwitch.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QLineWidth:
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setSmooth": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.smooth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QLineWidth.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMaterial:
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.effect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QMaterial.setEffect": ('PySide2.Qt3DRender.Qt3DRender.QEffect',),
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operation:
-# class PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations:
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.setWaitOperations": ('PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.Operations',),
-    "PySide2.Qt3DRender.Qt3DRender.QMemoryBarrier.waitOperations": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMesh:
-# class PySide2.Qt3DRender.Qt3DRender.QMesh.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.meshName": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setMeshName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QMesh.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing:
-    "PySide2.Qt3DRender.Qt3DRender.QMultiSampleAntiAliasing.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDepthMask:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDepthMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoDraw:
-    "PySide2.Qt3DRender.Qt3DRender.QNoDraw.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QNoPicking:
-    "PySide2.Qt3DRender.Qt3DRender.QNoPicking.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QObjectPicker:
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.containsMouse": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isDragEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isHoverEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.isPressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.priority": (),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setDragEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setHoverEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QObjectPicker.setPriority": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage:
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.paint": ('PySide2.QtGui.QPainter',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.size": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.update": ('PySide2.QtCore.QRect',),
-    "PySide2.Qt3DRender.Qt3DRender.QPaintedTextureImage.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QParameter:
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('str', 'PySide2.Qt3DRender.Qt3DRender.QAbstractTexture', 'PySide2.Qt3DCore.Qt3DCore.QNode'), ('str', 'typing.Any', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.name": (),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setName": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.setValue": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QParameter.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons:
-# class PySide2.Qt3DRender.Qt3DRender.QPickEvent.Modifiers:
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.button": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.buttons": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.isAccepted": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.modifiers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.viewport": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickEvent.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickLineEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.edgeIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickLineEvent.vertex2Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickPointEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickPointEvent.pointIndex": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent:
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.__init__": [(), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int'), ('PySide2.QtCore.QPointF', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float', 'int', 'int', 'int', 'int', 'PySide2.Qt3DRender.Qt3DRender.QPickEvent.Buttons', 'int', 'int', 'PySide2.QtGui.QVector3D')],
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.triangleIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.uvw": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickTriangleEvent.vertex3Index": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod:
-# class PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.faceOrientationPickingMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickMethod": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.pickResultMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setFaceOrientationPickingMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.FaceOrientationPickingMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickMethod": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickMethod',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setPickResultMode": ('PySide2.Qt3DRender.Qt3DRender.QPickingSettings.PickResultMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.setWorldSpaceTolerance": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPickingSettings.worldSpaceTolerance": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPointLight:
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize:
-# class PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode:
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setSizeMode": ('PySide2.Qt3DRender.Qt3DRender.QPointSize.SizeMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.setValue": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.sizeMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPointSize.value": (),
-# class PySide2.Qt3DRender.Qt3DRender.QPolygonOffset:
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.depthSteps": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.scaleFactor": (),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setDepthSteps": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QPolygonOffset.setScaleFactor": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QProximityFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.distanceThreshold": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setDistanceThreshold": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QProximityFilter.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-# class PySide2.Qt3DRender.Qt3DRender.QRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.direction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.length": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.origin": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setLength": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.setOrigin": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCaster.trigger": [(), ('PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'float')],
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit:
-# class PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType:
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__init__": [(), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit',), ('PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.HitType', 'PySide2.Qt3DCore.Qt3DCore.QNodeId', 'float', 'PySide2.QtGui.QVector3D', 'PySide2.QtGui.QVector3D', 'int', 'int', 'int', 'int')],
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.__copy__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.distance": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entity": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.entityId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.localIntersection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.primitiveIndex": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.type": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex1Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex2Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.vertex3Index": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRayCasterHit.worldIntersection": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderAspect.__init__": [('PySide2.Qt3DRender.Qt3DRender.QRenderAspect.RenderType', 'PySide2.QtCore.QObject'), ('PySide2.QtCore.QObject',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCapture:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCapture.requestCapture": [(), ('PySide2.QtCore.QRect',), ('int',)],
-# class PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.captureId": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.image": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.isComplete": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveImage": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderCaptureReply.saveToFile": ('str',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPass:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.renderStates": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPass.shaderProgram": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.matchAny": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderPassFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.activeFrameGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.pickingSettings": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.renderPolicy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSettings.setRenderPolicy": ('PySide2.Qt3DRender.Qt3DRender.QRenderSettings.RenderPolicy',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderState:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderStateSet:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.addRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.removeRenderState": ('PySide2.Qt3DRender.Qt3DRender.QRenderState',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderStateSet.renderStates": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.externalRenderTargetSize": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.setSurfacePixelRatio": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surface": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderSurfaceSelector.surfacePixelRatio": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTarget:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.addOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTarget.removeOutput": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput',),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput:
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.attachmentPoint": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.face": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setAttachmentPoint": ('PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setFace": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.CubeMapFace',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector:
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.outputs": (),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setOutputs": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QRenderTargetOutput.AttachmentPoint]',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QRenderTarget',),
-    "PySide2.Qt3DRender.Qt3DRender.QRenderTargetSelector.target": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType:
-# class PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.component": ('str', 'PySide2.Qt3DRender.Qt3DRender.QSceneLoader.ComponentType'),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entity": ('str',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.entityNames": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QSceneLoader.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSceneLoader.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScissorTest:
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.bottom": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.left": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setBottom": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setLeft": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QScissorTest.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster:
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.position": (),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.setPosition": ('PySide2.QtCore.QPoint',),
-    "PySide2.Qt3DRender.Qt3DRender.QScreenRayCaster.trigger": [(), ('PySide2.QtCore.QPoint',)],
-# class PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap:
-    "PySide2.Qt3DRender.Qt3DRender.QSeamlessCubemap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence:
-# class PySide2.Qt3DRender.Qt3DRender.QSetFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSetFence.handleType": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderData:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderData.event": ('PySide2.QtCore.QEvent',),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.access": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layer": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.layered": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.mipLevel": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setAccess": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.Access',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QShaderImage.ImageFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayer": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setLayered": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setMipLevel": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderImage.texture": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType:
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgram.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.loadSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.log": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setComputeShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setFragmentShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setGeometryShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setShaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType', 'PySide2.QtCore.QByteArray'),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationControlShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setTessellationEvaluationShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.setVertexShaderCode": ('PySide2.QtCore.QByteArray',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.shaderCode": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram.ShaderType',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.status": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgram.vertexShaderCode": (),
-# class PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder:
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.computeShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.enabledLayers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.fragmentShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.geometryShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setComputeShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setEnabledLayers": ('typing.Sequence[str]',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setFragmentShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setGeometryShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setShaderProgram": ('PySide2.Qt3DRender.Qt3DRender.QShaderProgram',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationControlShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setTessellationEvaluationShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.setVertexShaderGraph": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.shaderProgram": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationControlShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.tessellationEvaluationShaderGraph": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderCode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QShaderProgramBuilder.vertexShaderGraph": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture:
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.setTextureId": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QSharedGLTexture.textureId": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy:
-# class PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType:
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.setSortTypes": [('typing.List[PySide2.Qt3DRender.Qt3DRender.QSortPolicy.SortType]',), ('typing.List[int]',)],
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypes": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSortPolicy.sortTypesInt": (),
-# class PySide2.Qt3DRender.Qt3DRender.QSpotLight:
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.constantAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.cutOffAngle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.linearAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.localDirection": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.quadraticAttenuation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setConstantAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setCutOffAngle": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLinearAttenuation": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setLocalDirection": ('PySide2.QtGui.QVector3D',),
-    "PySide2.Qt3DRender.Qt3DRender.QSpotLight.setQuadraticAttenuation": ('float',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilMask:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.backOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.frontOutputMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setBackOutputMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilMask.setFrontOutputMask": ('int',),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperation.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.FaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.allTestsPassOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.depthTestFailureOperation": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setAllTestsPassOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setDepthTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.setStencilTestFailureOperation": ('PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.Operation',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilOperationArguments.stencilTestFailureOperation": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTest:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.back": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTest.front": (),
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFaceMode:
-# class PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction:
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.comparisonMask": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.faceMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.referenceValue": (),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setComparisonMask": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setReferenceValue": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.setStencilFunction": ('PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.StencilFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QStencilTestArguments.stencilFunction": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechnique:
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.addRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.filterKeys": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.graphicsApiFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeFilterKey": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.removeRenderPass": ('PySide2.Qt3DRender.Qt3DRender.QRenderPass',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechnique.renderPasses": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter:
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.addParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.matchAll": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.parameters": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeMatch": ('PySide2.Qt3DRender.Qt3DRender.QFilterKey',),
-    "PySide2.Qt3DRender.Qt3DRender.QTechniqueFilter.removeParameter": ('PySide2.Qt3DRender.Qt3DRender.QParameter',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture1DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture1DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisample.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture2DMultisampleArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTexture3D:
-    "PySide2.Qt3DRender.Qt3DRender.QTexture3D.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureBuffer:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureBuffer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMap.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureCubeMapArray.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonFunction": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.comparisonMode": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.isAutoMipMapGenerationEnabled": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.magnificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.maximumAnisotropy": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.minificationFilter": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setAutoMipMapGenerationEnabled": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonFunction": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonFunction',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setComparisonMode": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.ComparisonMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setFormat": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMagnificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMaximumAnisotropy": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setMinificationFilter": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Filter',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.setWrapModeZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.width": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeX": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeY": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureData.wrapModeZ": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.setStatus": ('PySide2.Qt3DRender.Qt3DRender.QTextureImage.Status',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.source": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImage.status": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageData:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.__init__": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.cleanup": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.data": ('int', 'int', 'int'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.depth": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.faces": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.format": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.height": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.isCompressed": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.layers": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.mipLevels": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelFormat": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.pixelType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setData": ('PySide2.QtCore.QByteArray', 'int', 'bool'),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setDepth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFaces": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setFormat": ('PySide2.QtGui.QOpenGLTexture.TextureFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setHeight": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setImage": ('PySide2.QtGui.QImage',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setLayers": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setMipLevels": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelFormat": ('PySide2.QtGui.QOpenGLTexture.PixelFormat',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setPixelType": ('PySide2.QtGui.QOpenGLTexture.PixelType',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setTarget": ('PySide2.QtGui.QOpenGLTexture.Target',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.setWidth": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.target": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureImageData.width": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureImageDataGenerator:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureLoader:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.isMirrored": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setMirrored": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureLoader.source": (),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureRectangle:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureRectangle.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode:
-# class PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode:
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.__init__": [('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject'), ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode', 'PySide2.QtCore.QObject')],
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setX": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setY": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.setZ": ('PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.WrapMode',),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.x": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.y": (),
-    "PySide2.Qt3DRender.Qt3DRender.QTextureWrapMode.z": (),
-# class PySide2.Qt3DRender.Qt3DRender.QViewport:
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.gamma": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.normalizedRect": (),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setGamma": ('float',),
-    "PySide2.Qt3DRender.Qt3DRender.QViewport.setNormalizedRect": ('PySide2.QtCore.QRectF',),
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence:
-# class PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType:
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handle": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.handleType": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandle": ('typing.Any',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setHandleType": ('PySide2.Qt3DRender.Qt3DRender.QWaitFence.HandleType',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setTimeout": ('int',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.setWaitOnCPU": ('bool',),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.timeout": (),
-    "PySide2.Qt3DRender.Qt3DRender.QWaitFence.waitOnCPU": (),
-    }) if "PySide2.Qt3DRender" in sys.modules else None
-# Module PySide2.Qt3DInput
-sig_dict.update({
-# class PySide2.Qt3DInput.Qt3DInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput:
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.addAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.axisSettings": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice.removeAxisSetting": ('PySide2.Qt3DInput.Qt3DInput.QAxisSetting',),
-# class PySide2.Qt3DInput.Qt3DInput.QAction:
-    "PySide2.Qt3DInput.Qt3DInput.QAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.isActive": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAction.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-# class PySide2.Qt3DInput.Qt3DInput.QActionInput:
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QAbstractPhysicalDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QActionInput.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.axis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAnalogAxisInput.setAxis": ('int',),
-# class PySide2.Qt3DInput.Qt3DInput.QAxis:
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.addInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.inputs": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.removeInput": ('PySide2.Qt3DInput.Qt3DInput.QAbstractAxisInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxis.value": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator:
-# class PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setScale": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.setSourceAxisType": ('PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.SourceAxisType',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxis": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.sourceAxisType": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.value": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisAccumulator.velocity": (),
-# class PySide2.Qt3DInput.Qt3DInput.QAxisSetting:
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.deadZoneRadius": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.isSmoothEnabled": (),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setAxes": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setDeadZoneRadius": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QAxisSetting.setSmoothEnabled": ('bool',),
-# class PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput:
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.acceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.deceleration": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.scale": (),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setAcceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setButtons": ('typing.List[int]',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setDeceleration": ('float',),
-    "PySide2.Qt3DInput.Qt3DInput.QButtonAxisInput.setScale": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputAspect:
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.availablePhysicalDevices": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputAspect.createPhysicalDevice": ('str',),
-# class PySide2.Qt3DInput.Qt3DInput.QInputChord:
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.addChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.chords": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.removeChord": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputChord.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSequence:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.addSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.buttonInterval": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.removeSequence": ('PySide2.Qt3DInput.Qt3DInput.QAbstractActionInput',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.sequences": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setButtonInterval": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.setTimeout": ('int',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSequence.timeout": (),
-# class PySide2.Qt3DInput.Qt3DInput.QInputSettings:
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.eventSource": (),
-    "PySide2.Qt3DInput.Qt3DInput.QInputSettings.setEventSource": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyEvent:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.__init__": ('PySide2.QtCore.QEvent.Type', 'int', 'PySide2.QtCore.Qt.KeyboardModifiers', 'str', 'bool', 'int'),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.count": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.isAutoRepeat": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.key": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.matches": ('PySide2.QtGui.QKeySequence.StandardKey',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.nativeScanCode": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.text": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyEvent.type": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.activeInput": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice.buttonNames": (),
-# class PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.focus": (),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setFocus": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QKeyboardDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QKeyboardHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QLogicalDevice:
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.actions": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.addAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.axes": (),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAction": ('PySide2.Qt3DInput.Qt3DInput.QAction',),
-    "PySide2.Qt3DInput.Qt3DInput.QLogicalDevice.removeAxis": ('PySide2.Qt3DInput.Qt3DInput.QAxis',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseDevice.Axis:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.axisNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonCount": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonIdentifier": ('str',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.buttonNames": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.sensitivity": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseDevice.setSensitivity": ('float',),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QMouseEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.button": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.wasHeld": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseEvent.y": (),
-# class PySide2.Qt3DInput.Qt3DInput.QMouseHandler:
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.containsMouse": (),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setContainsMouse": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.setSourceDevice": ('PySide2.Qt3DInput.Qt3DInput.QMouseDevice',),
-    "PySide2.Qt3DInput.Qt3DInput.QMouseHandler.sourceDevice": (),
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Buttons:
-# class PySide2.Qt3DInput.Qt3DInput.QWheelEvent.Modifiers:
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.angleDelta": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.buttons": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.isAccepted": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.modifiers": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.setAccepted": ('bool',),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.type": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.x": (),
-    "PySide2.Qt3DInput.Qt3DInput.QWheelEvent.y": (),
-    }) if "PySide2.Qt3DInput" in sys.modules else None
-# Module PySide2.Qt3DLogic
-sig_dict.update({
-# class PySide2.Qt3DLogic.Qt3DLogic:
-# class PySide2.Qt3DLogic.Qt3DLogic.QFrameAction:
-    "PySide2.Qt3DLogic.Qt3DLogic.QFrameAction.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect:
-    "PySide2.Qt3DLogic.Qt3DLogic.QLogicAspect.__init__": ('PySide2.QtCore.QObject',),
-    }) if "PySide2.Qt3DLogic" in sys.modules else None
-# Module PySide2.Qt3DAnimation
-sig_dict.update({
-# class PySide2.Qt3DAnimation.Qt3DAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.AnimationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.animationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setAnimationName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setDuration": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip.duration": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractChannelMapping:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.Loops:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.clock": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.isRunning": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.loopCount": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.normalizedTime": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setClock": ('PySide2.Qt3DAnimation.Qt3DAnimation.QClock',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setLoopCount": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setNormalizedTime": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.setRunning": ('bool',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.start": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipAnimator.stop": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.additiveFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.baseClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setAdditiveFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAdditiveClipBlend.setBaseClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationAspect.__init__": ('PySide2.QtCore.QObject',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.Flag:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.__init__": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationCallback.valueChanged": ('typing.Any',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClip.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.Status:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.__init__": [('PySide2.Qt3DCore.Qt3DCore.QNode',), ('PySide2.QtCore.QUrl', 'PySide2.Qt3DCore.Qt3DCore.QNode')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.setSource": ('PySide2.QtCore.QUrl',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.source": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationClipLoader.status": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.activeAnimationGroup": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.addAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.animationGroupList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.entity": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getAnimationIndex": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.getGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionOffset": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.positionScale": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.recursive": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.removeAnimationGroup": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setActiveAnimationGroup": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setAnimationGroups": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPosition": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionOffset": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setPositionScale": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationController.setRecursive": ('bool',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.addAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.animationList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.duration": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.name": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.position": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.removeAnimation": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setAnimations": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimation]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QAnimationGroup.setPosition": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.blendTree": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QBlendedClipAnimator.setBlendTree": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.clip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClipAnimator.setClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractAnimationClip',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QClock:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.playbackRate": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QClock.setPlaybackRate": ('float',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.__init__": [(), ('PySide2.QtGui.QVector2D',), ('PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D', 'PySide2.QtGui.QVector2D')],
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.coordinates": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.interpolationType": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.leftControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.rightControlPoint": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setCoordinates": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setInterpolationType": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.InterpolationType',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setLeftControlPoint": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyFrame.setRightControlPoint": ('PySide2.QtGui.QVector2D',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.addKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.endMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.framePositions": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.keyframeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.removeKeyframe": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setEndMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setFramePositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setKeyframes": ('typing.List[PySide2.Qt3DCore.Qt3DCore.QTransform]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setStartMode": ('PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.RepeatMode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTarget": ('PySide2.Qt3DCore.Qt3DCore.QTransform',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.startMode": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QKeyframeAnimation.targetName": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.blendFactor": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.endClip": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setBlendFactor": ('float',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setEndClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.setStartClip": ('PySide2.Qt3DAnimation.Qt3DAnimation.QAbstractClipBlendNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QLerpClipBlend.startClip": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.addAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.attributeNames": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.fromGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry', 'typing.Sequence[str]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.removeAttribute": ('PySide2.Qt3DRender.Qt3DRender.QAttribute',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget.setAttributes": ('typing.List[PySide2.Qt3DRender.Qt3DRender.QAttribute]',),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation:
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.easing": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.getWeights": ('int',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.method": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setEasing": ('PySide2.QtCore.QEasingCurve',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMethod": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.Method',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.setWeights": ('int', 'typing.List[float]'),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QMorphingAnimation.targetPositions": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.setSkeleton": ('PySide2.Qt3DCore.Qt3DCore.QAbstractSkeleton',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QSkeletonMapping.skeleton": (),
-# class PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation:
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.__init__": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.addMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.interpolator": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.morphTargetList": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.removeMorphTarget": ('PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setMorphTargets": ('typing.List[PySide2.Qt3DAnimation.Qt3DAnimation.QMorphTarget]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTarget": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetName": ('str',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.setTargetPositions": ('typing.List[float]',),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.target": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetName": (),
-    "PySide2.Qt3DAnimation.Qt3DAnimation.QVertexBlendAnimation.targetPositions": (),
-    }) if "PySide2.Qt3DAnimation" in sys.modules else None
-# Module PySide2.Qt3DExtras
-sig_dict.update({
-# class PySide2.Qt3DExtras.Qt3DExtras:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController:
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__init__": [(), ('PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.InputState.__copy__": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.acceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.deceleration": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.linearSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.lookSpeed": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setAcceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setCamera": ('PySide2.Qt3DRender.Qt3DRender.QCamera',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setDeceleration": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLinearSpeed": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractCameraController.setLookSpeed": ('float',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.currentIndex": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setCurrentIndex": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QAbstractSpriteSheet.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.topRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QConeMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.bottomRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasBottomEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.hasTopEndcap": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setBottomRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasBottomEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setHasTopEndcap": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setTopRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QConeMesh.topRadius": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidGeometry.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXYMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setXZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setYZMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.setZExtent": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xyMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.xzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yExtent": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.yzMeshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCuboidMesh.zExtent": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.length": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setLength": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QCylinderMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setDiffuse": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setSpecular": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QDiffuseSpecularMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.extrusionLength": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextGeometry.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.depth": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setDepth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QExtrudedTextMesh.text": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QFirstPersonCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer:
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.buffersToClear": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.clearColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.externalRenderTargetSize": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.gamma": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.isFrustumCullingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setBuffersToClear": ('PySide2.Qt3DRender.Qt3DRender.QClearBuffers.BufferType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setCamera": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setClearColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setExternalRenderTargetSize": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setFrustumCullingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setGamma": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setSurface": ('PySide2.QtCore.QObject',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.setViewportRect": ('PySide2.QtCore.QRectF',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.surface": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QForwardRenderer.viewportRect": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.beta": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.cool": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setBeta": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setCool": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.setWarm": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QGoochMaterial.warm": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.ambientOcclusion": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.baseColor": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.metalness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.roughness": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setAmbientOcclusion": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setBaseColor": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setMetalness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setNormal": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setRoughness": ('typing.Any',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMetalRoughMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.interpolator": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setInterpolator": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QMorphPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.normal": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setDiffuse": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setNormal": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setSpecular": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.setTextureScale": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.specular": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QNormalDiffuseSpecularMapMaterial.textureScale": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController:
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.setZoomInLimit": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QOrbitCameraController.zoomInLimit": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPerVertexColorMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.alpha": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.blendFunctionArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.destinationRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAlpha": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setBlendFunctionArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquation.BlendFunction',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDestinationRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceAlphaArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSourceRgbArg": ('PySide2.Qt3DRender.Qt3DRender.QBlendEquationArguments.Blending',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceAlphaArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.sourceRgbArg": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongAlphaMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.ambient": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.diffuse": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setAmbient": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setDiffuse": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setShininess": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.setSpecular": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.shininess": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPhongMaterial.specular": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.resolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.updateVertices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneGeometry.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.meshResolution": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.mirrored": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMeshResolution": ('PySide2.QtCore.QSize',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setMirrored": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QPlaneMesh.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.baseName": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.extension": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.isGammaCorrectEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setBaseName": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setExtension": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSkyboxEntity.setGammaCorrectEnabled": ('bool',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.tangentAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.generateTangents": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGenerateTangents": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSphereMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.columns": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.rows": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setColumns": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteGrid.setRows": ('int',),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.addSprite": [('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',), ('int', 'int', 'int', 'int')],
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.removeSprite": ('PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.setSprites": ('typing.List[PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem]',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheet.sprites": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem:
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setHeight": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setWidth": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setX": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.setY": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.width": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.x": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QSpriteSheetItem.y": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity:
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.color": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.font": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.height": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setColor": ('PySide2.QtGui.QColor',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setFont": ('PySide2.QtGui.QFont',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setHeight": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setText": ('str',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.setWidth": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.text": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QText2DEntity.width": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.isAlphaBlendingEnabled": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setAlphaBlendingEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTexture": ('PySide2.Qt3DRender.Qt3DRender.QAbstractTexture',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureOffset": ('PySide2.QtGui.QVector2D',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.setTextureTransform": ('PySide2.QtGui.QMatrix3x3',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.texture": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureOffset": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTextureMaterial.textureTransform": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.indexAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.normalAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.positionAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.slices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.texCoordAttribute": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateIndices": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusGeometry.updateVertices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh:
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.__init__": ('PySide2.Qt3DCore.Qt3DCore.QNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.minorRadius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.radius": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.rings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setFirstInstance": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setGeometry": ('PySide2.Qt3DRender.Qt3DRender.QGeometry',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setIndexOffset": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setInstanceCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setMinorRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveRestartEnabled": ('bool',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setPrimitiveType": ('PySide2.Qt3DRender.Qt3DRender.QGeometryRenderer.PrimitiveType',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRadius": ('float',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRestartIndexValue": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setRings": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setSlices": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.setVertexCount": ('int',),
-    "PySide2.Qt3DExtras.Qt3DExtras.QTorusMesh.slices": (),
-# class PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow:
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.__init__": ('PySide2.QtGui.QScreen',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.activeFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.camera": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.defaultFrameGraph": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.event": ('PySide2.QtCore.QEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.registerAspect": [('PySide2.Qt3DCore.Qt3DCore.QAbstractAspect',), ('str',)],
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.renderSettings": (),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.resizeEvent": ('PySide2.QtGui.QResizeEvent',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setActiveFrameGraph": ('PySide2.Qt3DRender.Qt3DRender.QFrameGraphNode',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.setRootEntity": ('PySide2.Qt3DCore.Qt3DCore.QEntity',),
-    "PySide2.Qt3DExtras.Qt3DExtras.Qt3DWindow.showEvent": ('PySide2.QtGui.QShowEvent',),
-    }) if "PySide2.Qt3DExtras" in sys.modules else None
-# Module testbinding
-sig_dict.update({
-# class testbinding.Enum1:
-# class testbinding.IntValue:
-    "testbinding.IntValue.__init__": [(), ('int',), ('testbinding.IntValue',)],
-    "testbinding.IntValue.__copy__": (),
-# class testbinding.PySideCPP:
-# class testbinding.PySideCPP.TestObject2WithNamespace:
-    "testbinding.PySideCPP.TestObject2WithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObject2WithNamespace.__repr__": (),
-    "testbinding.PySideCPP.TestObject2WithNamespace.name": (),
-# class testbinding.PySideCPP.TestObjectWithNamespace:
-    "testbinding.PySideCPP.TestObjectWithNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignal": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithNamespace": ('testbinding.PySideCPP.TestObjectWithNamespace',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.PySideCPP.TestObjectWithNamespace.name": (),
-# class testbinding.TestObject:
-    "testbinding.TestObject.__init__": ('int', 'PySide2.QtCore.QObject'),
-    "testbinding.TestObject.addChild": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObject.checkType": ('typing.Any',),
-    "testbinding.TestObject.createApp": (),
-    "testbinding.TestObject.emitIdValueSignal": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_bool": (),
-    "testbinding.TestObject.emitSignalWithDefaultValue_void": (),
-    "testbinding.TestObject.emitSignalWithTypedefValue": ('int',),
-    "testbinding.TestObject.emitStaticMethodDoubleSignal": (),
-    "testbinding.TestObject.idValue": (),
-    "testbinding.TestObject.staticMethodDouble": ('int',),
-# class testbinding.TestObjectWithoutNamespace:
-# class testbinding.TestObjectWithoutNamespace.Enum2:
-    "testbinding.TestObjectWithoutNamespace.__init__": ('PySide2.QtCore.QObject',),
-    "testbinding.TestObjectWithoutNamespace.callSignal": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithNamespace": ('testbinding.PySideCPP2.TestObjectWithoutNamespace',),
-    "testbinding.TestObjectWithoutNamespace.callSignalWithTypedef": ('int',),
-    "testbinding.TestObjectWithoutNamespace.name": (),
-# class testbinding.TestView:
-    "testbinding.TestView.__init__": ('PySide2.QtCore.QAbstractListModel', 'PySide2.QtCore.QObject'),
-    "testbinding.TestView.getData": (),
-    "testbinding.TestView.getEditorWidgetFromItemDelegate": (),
-    "testbinding.TestView.model": (),
-    "testbinding.TestView.setItemDelegate": ('PySide2.QtWidgets.QAbstractItemDelegate',),
-    "testbinding.TestView.getHiddenObject": (),
-    }) if "testbinding" in sys.modules else None
-# Module Shiboken
-sig_dict.update({
-# class Shiboken.VoidPtr:
-    }) if "Shiboken" in sys.modules else None
-# Module minimal
-sig_dict.update({
-# class minimal.ListUser:
-    "minimal.ListUser.__init__": [(), ('minimal.ListUser',)],
-    "minimal.ListUser.__copy__": (),
-    "minimal.ListUser.callCreateIntList": ('int',),
-    "minimal.ListUser.callCreateListOfIntLists": ('int',),
-    "minimal.ListUser.callCreateMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.callCreateObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.callCreateValList": ('int',),
-    "minimal.ListUser.callOredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.callSumIntList": ('typing.List[int]',),
-    "minimal.ListUser.callSumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.callSumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.callSumValList": ('typing.List[minimal.Val]',),
-    "minimal.ListUser.createIntList": ('int',),
-    "minimal.ListUser.createListOfIntLists": ('int',),
-    "minimal.ListUser.createMinBoolList": ('bool', 'bool'),
-    "minimal.ListUser.createObjList": ('minimal.Obj', 'minimal.Obj'),
-    "minimal.ListUser.createValList": ('int',),
-    "minimal.ListUser.oredMinBoolList": ('typing.List[bool]',),
-    "minimal.ListUser.sumIntList": ('typing.List[int]',),
-    "minimal.ListUser.sumListOfIntLists": ('typing.List[typing.List]',),
-    "minimal.ListUser.sumObjList": ('typing.List[minimal.Obj]',),
-    "minimal.ListUser.sumValList": ('typing.List[minimal.Val]',),
-# class minimal.MinBoolUser:
-    "minimal.MinBoolUser.__init__": [(), ('minimal.MinBoolUser',)],
-    "minimal.MinBoolUser.__copy__": (),
-    "minimal.MinBoolUser.callInvertedMinBool": (),
-    "minimal.MinBoolUser.invertedMinBool": (),
-    "minimal.MinBoolUser.minBool": (),
-    "minimal.MinBoolUser.setMinBool": ('bool',),
-# class minimal.Obj:
-    "minimal.Obj.__init__": ('int',),
-    "minimal.Obj.callPassObjectType": ('minimal.Obj',),
-    "minimal.Obj.callPassObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.callVirtualMethod": ('int',),
-    "minimal.Obj.objId": (),
-    "minimal.Obj.passObjectType": ('minimal.Obj',),
-    "minimal.Obj.passObjectTypeReference": ('minimal.Obj',),
-    "minimal.Obj.setObjId": ('int',),
-    "minimal.Obj.virtualMethod": ('int',),
-# class minimal.Val:
-# class minimal.Val.ValEnum:
-    "minimal.Val.__init__": [('int',), ('minimal.Val',)],
-    "minimal.Val.__copy__": (),
-    "minimal.Val.callPassValueType": ('minimal.Val',),
-    "minimal.Val.callPassValueTypePointer": ('minimal.Val',),
-    "minimal.Val.callPassValueTypeReference": ('minimal.Val',),
-    "minimal.Val.oneOrTheOtherEnumValue": ('minimal.Val.ValEnum',),
-    "minimal.Val.passValueType": ('minimal.Val',),
-    "minimal.Val.passValueTypePointer": ('minimal.Val',),
-    "minimal.Val.passValueTypeReference": ('minimal.Val',),
-    "minimal.Val.setValId": ('int',),
-    "minimal.Val.valId": (),
-    "minimal.Val.arrayFunc": ('typing.List[int]',),
-    "minimal.Val.arrayFuncInt": ('typing.List[int]',),
-    "minimal.Val.arrayFuncIntReturn": ('int',),
-    "minimal.Val.arrayFuncIntReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncIntTypedef": ('typing.List[int]',),
-    "minimal.Val.arrayFuncReturn": ('int',),
-    "minimal.Val.arrayFuncReturnTypedef": ('int',),
-    "minimal.Val.arrayFuncTypedef": ('typing.List[int]',),
-    }) if "minimal" in sys.modules else None
-# Module sample
-sig_dict.update({
-# class sample.Abstract:
-# class sample.Abstract.PrintFormat:
-# class sample.Abstract.Type:
-    "sample.Abstract.__init__": ('int',),
-    "sample.Abstract.callPureVirtual": (),
-    "sample.Abstract.callUnpureVirtual": (),
-    "sample.Abstract.callVirtualGettingEnum": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.className": (),
-    "sample.Abstract.createObject": (),
-    "sample.Abstract.getObjectId": ('sample.Abstract',),
-    "sample.Abstract.id_": (),
-    "sample.Abstract.pureVirtual": (),
-    "sample.Abstract.pureVirtualReturningVoidPtr": (),
-    "sample.Abstract.returnAnEnum": (),
-    "sample.Abstract.show": ('sample.Abstract.PrintFormat',),
-    "sample.Abstract.type": (),
-    "sample.Abstract.unpureVirtual": (),
-    "sample.Abstract.virtualGettingAEnum": ('sample.Abstract.PrintFormat',),
-# class sample.AbstractModifications:
-    "sample.AbstractModifications.__init__": (),
-    "sample.AbstractModifications.invert": ('bool',),
-    "sample.AbstractModifications.pointlessPureVirtualMethod": (),
-# class sample.ArrayModifyTest:
-    "sample.ArrayModifyTest.__init__": [(), ('sample.ArrayModifyTest',)],
-    "sample.ArrayModifyTest.__copy__": (),
-    "sample.ArrayModifyTest.sumIntArray": ('int', 'typing.Sequence[int]'),
-# class sample.Base1:
-    "sample.Base1.__init__": (),
-    "sample.Base1.base1Method": (),
-    "sample.Base1.publicMethod": (),
-# class sample.Base2:
-    "sample.Base2.__init__": (),
-    "sample.Base2.base2Method": (),
-# class sample.Base3:
-    "sample.Base3.__init__": ('int',),
-    "sample.Base3.base3Method": (),
-# class sample.Base4:
-    "sample.Base4.__init__": (),
-    "sample.Base4.base4Method": (),
-# class sample.Base5:
-    "sample.Base5.__init__": (),
-    "sample.Base5.base5Method": (),
-# class sample.Base6:
-    "sample.Base6.__init__": (),
-    "sample.Base6.base6Method": (),
-# class sample.BlackBox:
-    "sample.BlackBox.__init__": [(), ('sample.BlackBox',)],
-    "sample.BlackBox.__copy__": (),
-    "sample.BlackBox.disposeObjectType": ('int',),
-    "sample.BlackBox.disposePoint": ('int',),
-    "sample.BlackBox.keepObjectType": ('object',),
-    "sample.BlackBox.keepPoint": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.objects": (),
-    "sample.BlackBox.points": (),
-    "sample.BlackBox.referenceToObjectPointer": ('object',),
-    "sample.BlackBox.referenceToValuePointer": ('typing.Tuple[float, float]',),
-    "sample.BlackBox.retrieveObjectType": ('int',),
-    "sample.BlackBox.retrievePoint": ('int',),
-# class sample.Bucket:
-    "sample.Bucket.__init__": (),
-    "sample.Bucket.callVirtualBlockerMethodButYouDontKnowThis": (),
-    "sample.Bucket.empty": (),
-    "sample.Bucket.lock": (),
-    "sample.Bucket.locked": (),
-    "sample.Bucket.pop": (),
-    "sample.Bucket.push": ('int',),
-    "sample.Bucket.unlock": (),
-    "sample.Bucket.virtualBlockerMethod": (),
-# class sample.ByteArray:
-    "sample.ByteArray.__init__": [(), ('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__add__": [('int',), ('sample.ByteArray',), ('str',), ('unicode',)],
-    "sample.ByteArray.__copy__": (),
-    "sample.ByteArray.__iadd__": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.__repr__": (),
-    "sample.ByteArray.__str__": (),
-    "sample.ByteArray.append": [('int',), ('sample.ByteArray',)],
-    "sample.ByteArray.at": ('int',),
-    "sample.ByteArray.data": (),
-    "sample.ByteArray.size": (),
-# class sample.CVListUser:
-    "sample.CVListUser.__init__": [(), ('sample.CVListUser',)],
-    "sample.CVListUser.__copy__": (),
-    "sample.CVListUser.consume": ('typing.List[sample.CVValueType]',),
-    "sample.CVListUser.produce": (),
-# class sample.CVValueType:
-    "sample.CVValueType.__copy__": (),
-# class sample.ClassWithFunctionPointer:
-    "sample.ClassWithFunctionPointer.__init__": [(), ('sample.ClassWithFunctionPointer',)],
-    "sample.ClassWithFunctionPointer.__copy__": (),
-    "sample.ClassWithFunctionPointer.doNothing": ('int',),
-# class sample.Collector:
-    "sample.Collector.__init__": (),
-    "sample.Collector.__lshift__": [('Missing("sample.ObjectType.Identifier")',), ('object',), ('sample.IntWrapper',)],
-    "sample.Collector.clear": (),
-    "sample.Collector.items": (),
-    "sample.Collector.size": (),
-# class sample.Color:
-    "sample.Color.__init__": [(), ('int',), ('sample.Color',), ('sample.SampleNamespace.InValue',)],
-    "sample.Color.__copy__": (),
-    "sample.Color.isNull": (),
-# class sample.CtorConvRule:
-    "sample.CtorConvRule.__init__": [('int',), ('sample.CtorConvRule',)],
-    "sample.CtorConvRule.__copy__": (),
-    "sample.CtorConvRule.dummyVirtualMethod": (),
-    "sample.CtorConvRule.value": (),
-# class sample.Data:
-# class sample.Data.Field:
-    "sample.Data.__init__": [('sample.Data',), ('sample.Data.Field', 'str')],
-    "sample.Data.__and__": ('sample.Union',),
-    "sample.Data.__copy__": (),
-    "sample.Data.field": (),
-    "sample.Data.value": (),
-# class sample.Derived:
-# class sample.Derived.OtherOverloadedFuncEnum:
-# class sample.Derived.SomeInnerClass:
-    "sample.Derived.SomeInnerClass.__init__": [(), ('sample.Derived.SomeInnerClass',)],
-    "sample.Derived.SomeInnerClass.__add__": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.SomeInnerClass.__copy__": (),
-    "sample.Derived.SomeInnerClass.uselessMethod": (),
-    "sample.Derived.__init__": ('int',),
-    "sample.Derived.className": (),
-    "sample.Derived.createObject": (),
-    "sample.Derived.defaultValue": ('int',),
-    "sample.Derived.getClassName": (),
-    "sample.Derived.otherOverloaded": [('int', 'float'), ('int', 'int', 'bool', 'float')],
-    "sample.Derived.overloaded": [('float',), ('int', 'int')],
-    "sample.Derived.pureVirtual": (),
-    "sample.Derived.pureVirtualReturningVoidPtr": (),
-    "sample.Derived.returnAnEnum": (),
-    "sample.Derived.returnMyParameter": ('sample.Derived.SomeInnerClass',),
-    "sample.Derived.singleArgument": ('bool',),
-    "sample.Derived.triggerAnotherImpossibleTypeDiscovery": (),
-    "sample.Derived.triggerImpossibleTypeDiscovery": (),
-    "sample.Derived.type": (),
-    "sample.Derived.unpureVirtual": (),
-# class sample.Echo:
-    "sample.Echo.__init__": [(), ('sample.Echo',)],
-    "sample.Echo.__call__": ('sample.Str', 'int'),
-    "sample.Echo.__copy__": (),
-    "sample.Echo.__lshift__": [('int',), ('object',), ('sample.Str',)],
-    "sample.Echo.doNothingWithConstBool": ('bool',),
-    "sample.Echo.echo": ('str',),
-    "sample.Echo.methodWithNamedArg": ('sample.Str',),
-# class sample.EnumOnNamespace:
-# class sample.Event:
-# class sample.Event.EventType:
-# class sample.Event.EventTypeClass:
-    "sample.Event.__init__": [('sample.Event',), ('sample.Event.EventType',)],
-    "sample.Event.__copy__": (),
-    "sample.Event.eventType": (),
-    "sample.Event.setEventType": ('sample.Event.EventType',),
-    "sample.Event.setEventTypeByConstRef": ('sample.Event.EventType',),
-# class sample.ExceptionTest:
-    "sample.ExceptionTest.__init__": (),
-    "sample.ExceptionTest.intThrowInt": ('bool',),
-    "sample.ExceptionTest.intThrowStdException": ('bool',),
-    "sample.ExceptionTest.voidThrowInt": ('bool',),
-    "sample.ExceptionTest.voidThrowStdException": ('bool',),
-# class sample.Expression:
-    "sample.Expression.__init__": [('int',), ('sample.Expression',)],
-    "sample.Expression.__add__": ('sample.Expression',),
-    "sample.Expression.__copy__": (),
-    "sample.Expression.__sub__": ('sample.Expression',),
-    "sample.Expression.toString": (),
-# class sample.Filter:
-    "sample.Filter.__init__": [(), ('sample.Filter',)],
-    "sample.Filter.__copy__": (),
-# class sample.FriendOfOnlyCopy:
-    "sample.FriendOfOnlyCopy.__init__": [(), ('sample.FriendOfOnlyCopy',)],
-    "sample.FriendOfOnlyCopy.__copy__": (),
-    "sample.FriendOfOnlyCopy.createListOfOnlyCopy": ('int',),
-    "sample.FriendOfOnlyCopy.createOnlyCopy": ('int',),
-# class sample.GlobalEnum:
-# class sample.GlobalOverloadFuncEnum:
-# class sample.HandleHolder:
-    "sample.HandleHolder.__init__": ('int',),
-    "sample.HandleHolder.compare": ('sample.HandleHolder',),
-    "sample.HandleHolder.compare2": ('sample.HandleHolder',),
-    "sample.HandleHolder.createHandle": (),
-    "sample.HandleHolder.handle": (),
-    "sample.HandleHolder.handle2": (),
-    "sample.HandleHolder.set": ('int',),
-# class sample.ImplicitBase:
-    "sample.ImplicitBase.__init__": [(), ('sample.ImplicitBase',), ('sample.ImplicitTarget',)],
-    "sample.ImplicitBase.__copy__": (),
-# class sample.ImplicitConv:
-# class sample.ImplicitConv.CtorEnum:
-# class sample.ImplicitConv.ICOverloadedFuncEnum:
-    "sample.ImplicitConv.__init__": [(), ('None',), ('float', 'bool'), ('int',), ('object',), ('sample.ImplicitConv',), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.__copy__": (),
-    "sample.ImplicitConv.ctorEnum": (),
-    "sample.ImplicitConv.implicitConvCommon": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvDefault": ('sample.ImplicitConv',),
-    "sample.ImplicitConv.implicitConvOverloading": [('int',), ('sample.ImplicitConv', 'bool'), ('sample.ImplicitConv', 'int'), ('sample.ImplicitConv.CtorEnum',)],
-    "sample.ImplicitConv.objId": (),
-    "sample.ImplicitConv.value": (),
-# class sample.ImplicitTarget:
-    "sample.ImplicitTarget.__init__": [(), ('sample.ImplicitTarget',)],
-    "sample.ImplicitTarget.__copy__": (),
-# class sample.InjectCode:
-    "sample.InjectCode.__init__": [(), ('sample.InjectCode',)],
-    "sample.InjectCode.__copy__": (),
-    "sample.InjectCode.arrayMethod": ('int',),
-    "sample.InjectCode.callArrayMethod": ('int',),
-    "sample.InjectCode.overloadedMethod": [('int', 'bool'), ('int', 'float'), ('int', 'typing.List[str]')],
-    "sample.InjectCode.simpleMethod1": ('int', 'int'),
-    "sample.InjectCode.simpleMethod2": (),
-    "sample.InjectCode.simpleMethod3": ('int', 'typing.List[str]'),
-    "sample.InjectCode.sumArrayAndLength": (),
-    "sample.InjectCode.virtualMethod": ('int',),
-# class sample.IntArray2:
-    "sample.IntArray2.__init__": [('int',), ('sample.IntArray2',), ('typing.Sequence[int]',)],
-    "sample.IntArray2.__copy__": (),
-    "sample.IntArray2.sum": (),
-# class sample.IntArray3:
-    "sample.IntArray3.__init__": [('int',), ('sample.IntArray3',), ('typing.Sequence[int]',)],
-    "sample.IntArray3.__copy__": (),
-    "sample.IntArray3.sum": (),
-# class sample.IntList:
-# class sample.IntList.CtorEnum:
-    "sample.IntList.__init__": [(), ('int',), ('sample.IntList',), ('typing.Sequence[int]',)],
-    "sample.IntList.__copy__": (),
-    "sample.IntList.append": ('int',),
-    "sample.IntList.constructorUsed": (),
-# class sample.IntWrapper:
-    "sample.IntWrapper.__init__": [('int',), ('sample.IntWrapper',)],
-    "sample.IntWrapper.__copy__": (),
-# class sample.Intersection:
-    "sample.Intersection.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Intersection.__and__": ('sample.Intersection',),
-    "sample.Intersection.__copy__": (),
-    "sample.Intersection.addFilter": ('sample.Filter',),
-    "sample.Intersection.filters": (),
-# class sample.ListUser:
-# class sample.ListUser.ListOfSomething:
-    "sample.ListUser.__init__": [(), ('sample.ListUser',)],
-    "sample.ListUser.__copy__": (),
-    "sample.ListUser.callCreateList": (),
-    "sample.ListUser.createComplexList": ('complex', 'complex'),
-    "sample.ListUser.createList": (),
-    "sample.ListUser.getList": (),
-    "sample.ListUser.listOfPoints": [('typing.List[sample.PointF]',), ('typing.List[typing.Tuple]',)],
-    "sample.ListUser.multiplyPointList": ('typing.List[typing.Tuple]', 'float'),
-    "sample.ListUser.setList": ('typing.List[int]',),
-    "sample.ListUser.sumList": [('typing.List[float]',), ('typing.List[int]',)],
-# class sample.MDerived1:
-    "sample.MDerived1.__init__": (),
-    "sample.MDerived1.base1Method": (),
-    "sample.MDerived1.base2Method": (),
-    "sample.MDerived1.castToBase1": (),
-    "sample.MDerived1.castToBase2": (),
-    "sample.MDerived1.mderived1Method": (),
-    "sample.MDerived1.publicMethod": (),
-    "sample.MDerived1.transformFromBase1": ('sample.Base1',),
-    "sample.MDerived1.transformFromBase2": ('sample.Base2',),
-# class sample.MDerived2:
-    "sample.MDerived2.__init__": (),
-    "sample.MDerived2.base4Method": (),
-    "sample.MDerived2.castToBase3": (),
-    "sample.MDerived2.castToBase4": (),
-    "sample.MDerived2.castToBase5": (),
-    "sample.MDerived2.castToBase6": (),
-    "sample.MDerived2.mderived2Method": (),
-# class sample.MDerived3:
-    "sample.MDerived3.__init__": (),
-    "sample.MDerived3.castToBase3": (),
-    "sample.MDerived3.castToMDerived1": (),
-    "sample.MDerived3.castToMDerived2": (),
-    "sample.MDerived3.mderived3Method": (),
-# class sample.MDerived4:
-    "sample.MDerived4.__init__": (),
-    "sample.MDerived4.castToBase3": (),
-    "sample.MDerived4.castToBase4": (),
-    "sample.MDerived4.justDummyMethod": (),
-    "sample.MDerived4.mderived4Method": (),
-# class sample.MDerived5:
-    "sample.MDerived5.__init__": (),
-    "sample.MDerived5.castToBase3": (),
-    "sample.MDerived5.castToBase4": (),
-    "sample.MDerived5.mderived5Method": (),
-# class sample.MapUser:
-    "sample.MapUser.__init__": [(), ('sample.MapUser',)],
-    "sample.MapUser.__copy__": (),
-    "sample.MapUser.callCreateMap": (),
-    "sample.MapUser.createMap": (),
-    "sample.MapUser.foo": (),
-    "sample.MapUser.getMap": (),
-    "sample.MapUser.passMapIntValueType": ('typing.Dict[int, sample.ByteArray]',),
-    "sample.MapUser.pointerToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.referenceToMap": ('typing.Dict[str, str]',),
-    "sample.MapUser.setMap": ('typing.Dict[str, typing.List]',),
-    "sample.MapUser.showMap": ('typing.Dict[str, int]',),
-# class sample.ModelIndex:
-    "sample.ModelIndex.__init__": [(), ('sample.ModelIndex',)],
-    "sample.ModelIndex.__copy__": (),
-    "sample.ModelIndex.getValue": ('sample.ModelIndex',),
-    "sample.ModelIndex.setValue": ('int',),
-    "sample.ModelIndex.value": (),
-# class sample.Modifications:
-# class sample.Modifications.OverloadedModFunc:
-# class sample.Modifications.TestEnum:
-    "sample.Modifications.__init__": (),
-    "sample.Modifications.argRemoval0": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'int')],
-    "sample.Modifications.argRemoval1": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.argRemoval2": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval3": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval4": ('int', 'typing.Tuple[float, float]', 'bool', 'typing.Tuple[float, float]', 'int'),
-    "sample.Modifications.argRemoval5": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'int')],
-    "sample.Modifications.calculateArea": ('int', 'int'),
-    "sample.Modifications.callDifferenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.defaultEnumValue": (),
-    "sample.Modifications.differenceOfPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.doublePlus": ('int', 'int'),
-    "sample.Modifications.enumValue": (),
-    "sample.Modifications.getObject": (),
-    "sample.Modifications.getSize": ('int', 'int'),
-    "sample.Modifications.increment": ('int',),
-    "sample.Modifications.invertBoolean": ('bool',),
-    "sample.Modifications.multiplyPointCoordsPlusValue": ('typing.Tuple[float, float]', 'float'),
-    "sample.Modifications.name": (),
-    "sample.Modifications.nonConversionRuleForArgumentWithDefaultValue": ('object',),
-    "sample.Modifications.over": ('int', 'bool', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Modifications.overloaded": [('int', 'bool', 'int', 'bool'), ('int', 'bool', 'int', 'float'), ('int', 'bool', 'int', 'int'), ('int', 'bool', 'int', 'typing.Tuple[float, float]')],
-    "sample.Modifications.pointToPair": ('typing.Tuple[float, float]',),
-    "sample.Modifications.power": ('int', 'int'),
-    "sample.Modifications.setEnumValue": ('sample.Modifications.TestEnum',),
-    "sample.Modifications.sumPointArray": ('int', 'typing.Sequence[typing.Tuple]'),
-    "sample.Modifications.sumPointCoordinates": ('typing.Tuple[float, float]',),
-    "sample.Modifications.timesTen": ('int',),
-# class sample.ModifiedConstructor:
-    "sample.ModifiedConstructor.__init__": ('int',),
-    "sample.ModifiedConstructor.retrieveValue": (),
-# class sample.NoImplicitConversion:
-    "sample.NoImplicitConversion.__init__": [('int',), ('sample.NoImplicitConversion',)],
-    "sample.NoImplicitConversion.__copy__": (),
-    "sample.NoImplicitConversion.objId": (),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByPointer": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByReference": ('sample.NoImplicitConversion',),
-    "sample.NoImplicitConversion.receivesNoImplicitConversionByValue": ('sample.NoImplicitConversion',),
-# class sample.NonDefaultCtor:
-    "sample.NonDefaultCtor.__init__": [('int',), ('sample.NonDefaultCtor',)],
-    "sample.NonDefaultCtor.__copy__": (),
-    "sample.NonDefaultCtor.callReturnMyselfVirtual": (),
-    "sample.NonDefaultCtor.returnMyself": [(), ('int',), ('int', 'sample.NonDefaultCtor')],
-    "sample.NonDefaultCtor.returnMyselfVirtual": (),
-    "sample.NonDefaultCtor.value": (),
-# class sample.ObjTypeReference:
-    "sample.ObjTypeReference.__init__": [(), ('sample.ObjTypeReference',)],
-    "sample.ObjTypeReference.justAPureVirtualFunc": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMyFirstArg": ('sample.ObjTypeReference',),
-    "sample.ObjTypeReference.returnMySecondArg": ('int', 'sample.ObjTypeReference'),
-# class sample.ObjectModel:
-# class sample.ObjectModel.MethodCalled:
-    "sample.ObjectModel.__init__": ('object',),
-    "sample.ObjectModel.data": (),
-    "sample.ObjectModel.receivesObjectTypeFamily": [('object',), ('sample.ObjectModel',)],
-    "sample.ObjectModel.setData": ('object',),
-# class sample.ObjectType:
-    "sample.ObjectType.__init__": ('object',),
-    "sample.ObjectType.callId": (),
-    "sample.ObjectType.callInvalidateEvent": ('sample.Event',),
-    "sample.ObjectType.callVirtualCreateChild": (),
-    "sample.ObjectType.callWithEnum": [('sample.Str', 'int'), ('sample.Str', 'sample.Event.EventType', 'int')],
-    "sample.ObjectType.causeEvent": ('sample.Event.EventType',),
-    "sample.ObjectType.children": (),
-    "sample.ObjectType.create": (),
-    "sample.ObjectType.createChild": ('object',),
-    "sample.ObjectType.createObjectType": (),
-    "sample.ObjectType.createWithChild": (),
-    "sample.ObjectType.deprecatedFunction": (),
-    "sample.ObjectType.destroyCppParent": (),
-    "sample.ObjectType.event": ('sample.Event',),
-    "sample.ObjectType.findChild": ('sample.Str',),
-    "sample.ObjectType.getCppParent": (),
-    "sample.ObjectType.identifier": (),
-    "sample.ObjectType.invalidateEvent": ('sample.Event',),
-    "sample.ObjectType.isLayoutType": (),
-    "sample.ObjectType.isPython": (),
-    "sample.ObjectType.killChild": ('sample.Str',),
-    "sample.ObjectType.layout": (),
-    "sample.ObjectType.nextInFocusChain": (),
-    "sample.ObjectType.objectName": (),
-    "sample.ObjectType.parent": (),
-    "sample.ObjectType.processEvent": ('typing.List[object]', 'sample.Event'),
-    "sample.ObjectType.removeChild": ('object',),
-    "sample.ObjectType.setLayout": ('sample.ObjectTypeLayout',),
-    "sample.ObjectType.setNullObject": ('None',),
-    "sample.ObjectType.setObject": ('object',),
-    "sample.ObjectType.setObjectName": ('sample.Str',),
-    "sample.ObjectType.setObjectNameWithSize": [('sample.Str', 'int'), ('str', 'int', 'sample.Str')],
-    "sample.ObjectType.setObjectSplittedName": ('str', 'sample.Str', 'sample.Str'),
-    "sample.ObjectType.setParent": ('object',),
-    "sample.ObjectType.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeByValue:
-    "sample.ObjectTypeByValue.__init__": (),
-    "sample.ObjectTypeByValue.acceptKindOfMeAsValue": ('sample.ObjectTypeByValue',),
-    "sample.ObjectTypeByValue.acceptListOfObjectTypeByValue": ('typing.List[sample.ObjectTypeByValue]',),
-    "sample.ObjectTypeByValue.returnSomeKindOfMe": (),
-# class sample.ObjectTypeDerived:
-    "sample.ObjectTypeDerived.__init__": (),
-    "sample.ObjectTypeDerived.event": ('sample.Event',),
-# class sample.ObjectTypeHolder:
-    "sample.ObjectTypeHolder.__init__": [('sample.ObjectTypeHolder',), ('str',)],
-    "sample.ObjectTypeHolder.__copy__": (),
-    "sample.ObjectTypeHolder.callPassObjectTypeAsReference": (),
-    "sample.ObjectTypeHolder.getObjecType": (),
-    "sample.ObjectTypeHolder.passObjectTypeAsReference": ('object',),
-# class sample.ObjectTypeLayout:
-    "sample.ObjectTypeLayout.__init__": (),
-    "sample.ObjectTypeLayout.addObject": ('object',),
-    "sample.ObjectTypeLayout.create": (),
-    "sample.ObjectTypeLayout.isLayoutType": (),
-    "sample.ObjectTypeLayout.objects": (),
-    "sample.ObjectTypeLayout.takeChild": [('object',), ('sample.Str',)],
-# class sample.ObjectTypeOperators:
-    "sample.ObjectTypeOperators.__init__": ('str',),
-    "sample.ObjectTypeOperators.__add__": ('str',),
-    "sample.ObjectTypeOperators.key": (),
-# class sample.ObjectTypePtrList:
-# class sample.ObjectTypePtrList.CtorEnum:
-    "sample.ObjectTypePtrList.__init__": [(), ('object',), ('sample.ObjectTypePtrList',), ('typing.Sequence[object]',)],
-    "sample.ObjectTypePtrList.__copy__": (),
-    "sample.ObjectTypePtrList.append": ('object',),
-    "sample.ObjectTypePtrList.constructorUsed": (),
-# class sample.ObjectView:
-    "sample.ObjectView.__init__": ('sample.ObjectModel', 'object'),
-    "sample.ObjectView.displayModelData": (),
-    "sample.ObjectView.getRawModelData": (),
-    "sample.ObjectView.model": (),
-    "sample.ObjectView.modifyModelData": ('sample.Str',),
-    "sample.ObjectView.setModel": ('sample.ObjectModel',),
-# class sample.OddBoolUser:
-    "sample.OddBoolUser.__init__": [(), ('bool',), ('sample.OddBoolUser',)],
-    "sample.OddBoolUser.__copy__": (),
-    "sample.OddBoolUser.callInvertedOddBool": (),
-    "sample.OddBoolUser.getOddBool": ('sample.OddBoolUser',),
-    "sample.OddBoolUser.invertedOddBool": (),
-    "sample.OddBoolUser.oddBool": (),
-    "sample.OddBoolUser.setOddBool": ('bool',),
-# class sample.OnlyCopy:
-    "sample.OnlyCopy.__init__": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.__copy__": (),
-    "sample.OnlyCopy.getValue": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.getValueFromReference": ('sample.OnlyCopy',),
-    "sample.OnlyCopy.value": (),
-# class sample.OtherBase:
-    "sample.OtherBase.__init__": (),
-# class sample.Overload:
-# class sample.Overload.FunctionEnum:
-# class sample.Overload.ParamEnum:
-    "sample.Overload.__init__": (),
-    "sample.Overload.acceptSequence": [(), ('int',), ('int', 'int'), ('sample.Size',), ('sample.Str', 'sample.Overload.ParamEnum'), ('typing.Sequence[str]',)],
-    "sample.Overload.differentReturnTypes": [('sample.Overload.ParamEnum',), ('sample.Overload.ParamEnum', 'int')],
-    "sample.Overload.drawText": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText2": [('int', 'int', 'int', 'int', 'int', 'sample.Str'), ('int', 'int', 'sample.Str'), ('sample.PointF', 'sample.Str'), ('sample.Rect', 'int', 'sample.Str'), ('sample.RectF', 'int', 'sample.Str'), ('sample.RectF', 'sample.Str', 'sample.Echo'), ('typing.Tuple[float, float]', 'sample.Str')],
-    "sample.Overload.drawText3": [('int', 'int', 'int', 'int', 'int'), ('sample.Str', 'sample.Str', 'sample.Str')],
-    "sample.Overload.drawText4": [('int', 'int', 'int'), ('int', 'int', 'int', 'int', 'int')],
-    "sample.Overload.intDoubleOverloads": [('float', 'float'), ('int', 'int')],
-    "sample.Overload.intOverloads": [('int', 'int'), ('int', 'int', 'float'), ('typing.Tuple[float, float]', 'float')],
-    "sample.Overload.overloaded": [(), ('sample.Size',), ('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'sample.Overload.ParamEnum')],
-    "sample.Overload.singleOverload": [(), ('typing.Tuple[float, float]',)],
-    "sample.Overload.strBufferOverloads": [(), ('sample.Str', 'int'), ('sample.Str', 'str', 'bool'), ('str', 'int')],
-    "sample.Overload.wrapperIntIntOverloads": [('sample.Polygon', 'int', 'int'), ('typing.Tuple[float, float]', 'int', 'int')],
-# class sample.Overload2:
-    "sample.Overload2.__init__": (),
-    "sample.Overload2.doNothingInPublic": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic2": [(), ('int',)],
-    "sample.Overload2.doNothingInPublic3": [(), ('int',)],
-# class sample.OverloadedFuncEnum:
-# class sample.PairUser:
-    "sample.PairUser.__init__": [(), ('sample.PairUser',)],
-    "sample.PairUser.__copy__": (),
-    "sample.PairUser.callCreatePair": (),
-    "sample.PairUser.createComplexPair": ('complex', 'complex'),
-    "sample.PairUser.createPair": (),
-    "sample.PairUser.getPair": (),
-    "sample.PairUser.setPair": ('typing.Tuple[int, int]',),
-    "sample.PairUser.sumPair": ('typing.Tuple[int, float]',),
-# class sample.Pen:
-    "sample.Pen.__init__": [(), ('sample.Color',), ('sample.Pen',), ('sample.SampleNamespace.Option',)],
-    "sample.Pen.__copy__": (),
-    "sample.Pen.ctorType": (),
-# class sample.PersistentModelIndex:
-    "sample.PersistentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.PersistentModelIndex',)],
-    "sample.PersistentModelIndex.__copy__": (),
-    "sample.PersistentModelIndex.setValue": ('int',),
-    "sample.PersistentModelIndex.value": (),
-# class sample.Photon:
-# class sample.Photon.Base:
-    "sample.Photon.Base.__init__": [('int',), ('sample.Photon.Base',)],
-    "sample.Photon.Base.__copy__": (),
-    "sample.Photon.Base.isType": ('sample.Photon.ClassType',),
-    "sample.Photon.Base.setValue": ('int',),
-    "sample.Photon.Base.type": (),
-    "sample.Photon.Base.value": (),
-# class sample.Photon.ClassType:
-# class sample.Photon.ValueDuplicator:
-    "sample.Photon.ValueDuplicator.__init__": [('int',), ('sample.Photon.ValueDuplicator',)],
-    "sample.Photon.ValueDuplicator.__copy__": (),
-    "sample.Photon.ValueDuplicator.calculate": (),
-    "sample.Photon.ValueDuplicator.classType": (),
-    "sample.Photon.ValueDuplicator.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueDuplicator.multiplicator": (),
-    "sample.Photon.ValueDuplicator.passPointerThrough": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.sumValueUsingReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.ValueDuplicator.type": (),
-# class sample.Photon.ValueIdentity:
-    "sample.Photon.ValueIdentity.__init__": [('int',), ('sample.Photon.ValueIdentity',)],
-    "sample.Photon.ValueIdentity.__copy__": (),
-    "sample.Photon.ValueIdentity.calculate": (),
-    "sample.Photon.ValueIdentity.classType": (),
-    "sample.Photon.ValueIdentity.getListOfThisTemplateBase": (),
-    "sample.Photon.ValueIdentity.multiplicator": (),
-    "sample.Photon.ValueIdentity.passPointerThrough": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingPointer": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.sumValueUsingReference": ('sample.Photon.ValueIdentity',),
-    "sample.Photon.ValueIdentity.type": (),
-    "sample.Photon.callCalculateForValueDuplicatorPointer": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.callCalculateForValueDuplicatorReference": ('sample.Photon.ValueDuplicator',),
-    "sample.Photon.countValueDuplicators": ('typing.List[sample.Photon.ValueDuplicator]',),
-    "sample.Photon.countValueIdentities": ('typing.List[sample.Photon.ValueIdentity]',),
-# class sample.Point:
-    "sample.Point.__init__": [('float', 'float'), ('int', 'int'), ('typing.Tuple[float, float]',)],
-    "sample.Point.__add__": ('typing.Tuple[float, float]',),
-    "sample.Point.__copy__": (),
-    "sample.Point.__iadd__": ('typing.Tuple[float, float]',),
-    "sample.Point.__isub__": ('typing.Tuple[float, float]',),
-    "sample.Point.__mul__": [('float',), ('int',)],
-    "sample.Point.__neg__": (),
-    "sample.Point.__reduce__": (),
-    "sample.Point.__repr__": (),
-    "sample.Point.__str__": (),
-    "sample.Point.__sub__": [('typing.Tuple[float, float]',), ('unicode',)],
-    "sample.Point.copy": (),
-    "sample.Point.getConstReferenceToSelf": (),
-    "sample.Point.getSelf": (),
-    "sample.Point.midpoint": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.Point.setX": ('float',),
-    "sample.Point.setXAsUint": ('int',),
-    "sample.Point.setY": ('float',),
-    "sample.Point.setYAsUint": ('int',),
-    "sample.Point.show": (),
-    "sample.Point.x": (),
-    "sample.Point.y": (),
-# class sample.PointF:
-    "sample.PointF.__init__": [('float', 'float'), ('sample.PointF',), ('typing.Tuple[float, float]',)],
-    "sample.PointF.__add__": ('sample.PointF',),
-    "sample.PointF.__copy__": (),
-    "sample.PointF.__iadd__": ('sample.PointF',),
-    "sample.PointF.__isub__": ('sample.PointF',),
-    "sample.PointF.__mul__": [('float',), ('int',)],
-    "sample.PointF.__neg__": (),
-    "sample.PointF.__reduce__": (),
-    "sample.PointF.__repr__": (),
-    "sample.PointF.__str__": (),
-    "sample.PointF.__sub__": ('sample.PointF',),
-    "sample.PointF.midpoint": ('sample.PointF', 'sample.PointF'),
-    "sample.PointF.setX": ('float',),
-    "sample.PointF.setY": ('float',),
-    "sample.PointF.show": (),
-    "sample.PointF.x": (),
-    "sample.PointF.y": (),
-# class sample.PointValueList:
-# class sample.PointValueList.CtorEnum:
-    "sample.PointValueList.__init__": [(), ('sample.PointValueList',), ('typing.Sequence[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.PointValueList.__copy__": (),
-    "sample.PointValueList.append": ('typing.Tuple[float, float]',),
-    "sample.PointValueList.constructorUsed": (),
-# class sample.PointerHolder:
-    "sample.PointerHolder.__init__": [('object',), ('sample.PointerHolder',)],
-    "sample.PointerHolder.__copy__": (),
-    "sample.PointerHolder.pointer": (),
-# class sample.Polygon:
-    "sample.Polygon.__init__": [(), ('float', 'float'), ('sample.Polygon',), ('typing.List[typing.Tuple]',), ('typing.Tuple[float, float]',)],
-    "sample.Polygon.__copy__": (),
-    "sample.Polygon.addPoint": ('typing.Tuple[float, float]',),
-    "sample.Polygon.doublePolygonScale": ('sample.Polygon',),
-    "sample.Polygon.points": (),
-    "sample.Polygon.stealOwnershipFromPython": [('sample.Polygon',), ('typing.Tuple[float, float]',)],
-# class sample.PrimitiveStructPointerHolder:
-    "sample.PrimitiveStructPointerHolder.__init__": [(), ('sample.PrimitiveStructPointerHolder',)],
-    "sample.PrimitiveStructPointerHolder.__copy__": (),
-# class sample.PrivateCtor:
-    "sample.PrivateCtor.instance": (),
-    "sample.PrivateCtor.instanceCalls": (),
-# class sample.PrivateDtor:
-    "sample.PrivateDtor.instance": (),
-    "sample.PrivateDtor.instanceCalls": (),
-    "sample.PrivateDtor.protectedInstanceCalls": (),
-# class sample.ProtectedEnumClass:
-# class sample.ProtectedEnumClass.ProtectedEnum:
-# class sample.ProtectedEnumClass.PublicEnum:
-    "sample.ProtectedEnumClass.__init__": (),
-    "sample.ProtectedEnumClass.callProtectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.callPublicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-    "sample.ProtectedEnumClass.protectedEnumMethod": ('sample.ProtectedEnumClass.ProtectedEnum',),
-    "sample.ProtectedEnumClass.publicEnumMethod": ('sample.ProtectedEnumClass.PublicEnum',),
-# class sample.ProtectedNonPolymorphic:
-    "sample.ProtectedNonPolymorphic.__init__": [('sample.ProtectedNonPolymorphic',), ('str',)],
-    "sample.ProtectedNonPolymorphic.__copy__": (),
-    "sample.ProtectedNonPolymorphic.create": (),
-    "sample.ProtectedNonPolymorphic.dataTypeName": [('int',), ('object',)],
-    "sample.ProtectedNonPolymorphic.modifiedProtectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.protectedName": (),
-    "sample.ProtectedNonPolymorphic.protectedStatic": (),
-    "sample.ProtectedNonPolymorphic.protectedSum": ('int', 'int'),
-    "sample.ProtectedNonPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphic:
-    "sample.ProtectedPolymorphic.__init__": [('sample.ProtectedPolymorphic',), ('str',)],
-    "sample.ProtectedPolymorphic.__copy__": (),
-    "sample.ProtectedPolymorphic.callProtectedName": (),
-    "sample.ProtectedPolymorphic.create": (),
-    "sample.ProtectedPolymorphic.protectedName": (),
-    "sample.ProtectedPolymorphic.publicName": (),
-# class sample.ProtectedPolymorphicDaughter:
-    "sample.ProtectedPolymorphicDaughter.__init__": [('sample.ProtectedPolymorphicDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicDaughter.create": (),
-# class sample.ProtectedPolymorphicGrandDaughter:
-    "sample.ProtectedPolymorphicGrandDaughter.__init__": [('sample.ProtectedPolymorphicGrandDaughter',), ('str',)],
-    "sample.ProtectedPolymorphicGrandDaughter.__copy__": (),
-    "sample.ProtectedPolymorphicGrandDaughter.create": (),
-# class sample.ProtectedProperty:
-    "sample.ProtectedProperty.__init__": [(), ('sample.ProtectedProperty',)],
-    "sample.ProtectedProperty.__copy__": (),
-# class sample.ProtectedVirtualDestructor:
-    "sample.ProtectedVirtualDestructor.__init__": (),
-    "sample.ProtectedVirtualDestructor.create": (),
-    "sample.ProtectedVirtualDestructor.dtorCalled": (),
-    "sample.ProtectedVirtualDestructor.resetDtorCounter": (),
-# class sample.Rect:
-    "sample.Rect.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',)],
-    "sample.Rect.__copy__": (),
-    "sample.Rect.bottom": (),
-    "sample.Rect.left": (),
-    "sample.Rect.right": (),
-    "sample.Rect.top": (),
-# class sample.RectF:
-    "sample.RectF.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Rect',), ('sample.RectF',)],
-    "sample.RectF.__copy__": (),
-    "sample.RectF.bottom": (),
-    "sample.RectF.left": (),
-    "sample.RectF.right": (),
-    "sample.RectF.top": (),
-# class sample.Reference:
-    "sample.Reference.__init__": [('int',), ('sample.Reference',)],
-    "sample.Reference.__copy__": (),
-    "sample.Reference.alterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callAlterReferenceIdVirtual": ('sample.Reference',),
-    "sample.Reference.callUsesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.callUsesReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.multiplier": (),
-    "sample.Reference.objId": (),
-    "sample.Reference.returnMyFirstArg": ('sample.Reference',),
-    "sample.Reference.returnMySecondArg": ('int', 'sample.Reference'),
-    "sample.Reference.setObjId": ('int',),
-    "sample.Reference.show": (),
-    "sample.Reference.usesConstReference": ('sample.Reference',),
-    "sample.Reference.usesConstReferenceVirtual": ('sample.Reference', 'int'),
-    "sample.Reference.usesReference": ('sample.Reference',),
-    "sample.Reference.usesReferenceVirtual": ('sample.Reference', 'int'),
-# class sample.ReferentModelIndex:
-    "sample.ReferentModelIndex.__init__": [(), ('sample.ModelIndex',), ('sample.ReferentModelIndex',)],
-    "sample.ReferentModelIndex.__copy__": (),
-    "sample.ReferentModelIndex.setValue": ('int',),
-    "sample.ReferentModelIndex.value": (),
-# class sample.RemovedNamespace1_Enum:
-# class sample.RemovedNamespace2_Enum:
-# class sample.SampleNamespace:
-# class sample.SampleNamespace.DerivedFromNamespace:
-    "sample.SampleNamespace.DerivedFromNamespace.__init__": (),
-    "sample.SampleNamespace.DerivedFromNamespace.methodReturningTypeFromParentScope": (),
-    "sample.SampleNamespace.DerivedFromNamespace.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.InValue:
-# class sample.SampleNamespace.Option:
-# class sample.SampleNamespace.OutValue:
-# class sample.SampleNamespace.SomeClass:
-# class sample.SampleNamespace.SomeClass.ProtectedEnum:
-# class sample.SampleNamespace.SomeClass.PublicScopedEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum:
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnumClass:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.__init__": (),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass',),
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.someVirtualMethod": ('sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough',),
-# class sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum:
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeInnerClass.__copy__": (),
-# class sample.SampleNamespace.SomeClass.SomeOtherInnerClass:
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__init__": [(), ('sample.SampleNamespace.SomeClass.SomeOtherInnerClass',)],
-    "sample.SampleNamespace.SomeClass.SomeOtherInnerClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.__init__": [(), ('sample.SampleNamespace.SomeClass',)],
-    "sample.SampleNamespace.SomeClass.__copy__": (),
-    "sample.SampleNamespace.SomeClass.protectedMethodReturningPublicScopedEnum": (),
-    "sample.SampleNamespace.ImInsideANamespace": ('int', 'int'),
-    "sample.SampleNamespace.doSomethingWithArray": ('str', 'int', 'str'),
-    "sample.SampleNamespace.enumArgumentWithDefaultValue": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.enumInEnumOut": ('sample.SampleNamespace.InValue',),
-    "sample.SampleNamespace.enumItemAsDefaultValueToIntArgument": ('int',),
-    "sample.SampleNamespace.forceDecisorSideA": [('object',), ('typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.forceDecisorSideB": [('int', 'object'), ('int', 'typing.Tuple[float, float]', 'sample.Str', 'object')],
-    "sample.SampleNamespace.getNumber": ('sample.SampleNamespace.Option',),
-    "sample.SampleNamespace.passReferenceToObjectType": [('object',), ('object', 'int')],
-    "sample.SampleNamespace.passReferenceToValueType": [('typing.Tuple[float, float]',), ('typing.Tuple[float, float]', 'float')],
-    "sample.SampleNamespace.powerOfTwo": ('float',),
-# class sample.SbkDate:
-    "sample.SbkDate.__init__": [('int', 'int', 'int'), ('sample.SbkDate',)],
-    "sample.SbkDate.__copy__": (),
-    "sample.SbkDate.day": (),
-    "sample.SbkDate.month": (),
-    "sample.SbkDate.toPython": (),
-    "sample.SbkDate.year": (),
-# class sample.SimpleFile:
-    "sample.SimpleFile.__init__": [('sample.SimpleFile',), ('str',)],
-    "sample.SimpleFile.__copy__": (),
-    "sample.SimpleFile.close": (),
-    "sample.SimpleFile.exists": [(), ('str',)],
-    "sample.SimpleFile.filename": (),
-    "sample.SimpleFile.open": (),
-    "sample.SimpleFile.size": (),
-# class sample.Size:
-    "sample.Size.__init__": [('float', 'float'), ('sample.Size',), ('str',)],
-    "sample.Size.__add__": ('sample.Size',),
-    "sample.Size.__copy__": (),
-    "sample.Size.__iadd__": ('sample.Size',),
-    "sample.Size.__imul__": ('float',),
-    "sample.Size.__isub__": ('sample.Size',),
-    "sample.Size.__mul__": ('float',),
-    "sample.Size.__sub__": ('sample.Size',),
-    "sample.Size.calculateArea": (),
-    "sample.Size.height": (),
-    "sample.Size.setHeight": ('float',),
-    "sample.Size.setWidth": ('float',),
-    "sample.Size.show": (),
-    "sample.Size.width": (),
-# class sample.SizeF:
-    "sample.SizeF.__init__": [('float', 'float'), ('sample.SizeF',)],
-    "sample.SizeF.__copy__": (),
-    "sample.SizeF.height": (),
-    "sample.SizeF.passTypedefOfUnsignedShort": ('int',),
-    "sample.SizeF.width": (),
-# class sample.SonOfMDerived1:
-    "sample.SonOfMDerived1.__init__": (),
-    "sample.SonOfMDerived1.castToMDerived1": (),
-    "sample.SonOfMDerived1.sonOfMDerived1Method": (),
-# class sample.SortedOverload:
-    "sample.SortedOverload.__init__": [(), ('sample.SortedOverload',)],
-    "sample.SortedOverload.__copy__": (),
-    "sample.SortedOverload.implicit_overload": ('sample.ImplicitBase',),
-    "sample.SortedOverload.overload": [('float',), ('int',), ('object',), ('sample.ImplicitBase',), ('sample.ImplicitTarget',), ('typing.List[sample.ImplicitBase]',)],
-    "sample.SortedOverload.overloadDeep": [('int', 'object'), ('int', 'sample.ImplicitBase')],
-    "sample.SortedOverload.pyObjOverload": [('int', 'int'), ('str', 'int')],
-# class sample.Str:
-    "sample.Str.__init__": [('int',), ('sample.Str',), ('str',)],
-    "sample.Str.__add__": ('int',),
-    "sample.Str.__copy__": (),
-    "sample.Str.__str__": (),
-    "sample.Str.append": ('sample.Str',),
-    "sample.Str.arg": ('sample.Str',),
-    "sample.Str.cstring": (),
-    "sample.Str.get_char": ('int',),
-    "sample.Str.prepend": ('sample.Str',),
-    "sample.Str.set_char": ('int', 'int'),
-    "sample.Str.show": (),
-    "sample.Str.size": (),
-    "sample.Str.toInt": ('int',),
-# class sample.StrList:
-# class sample.StrList.CtorEnum:
-    "sample.StrList.__init__": [(), ('sample.Str',), ('sample.StrList',), ('typing.List[sample.Str]',)],
-    "sample.StrList.__copy__": (),
-    "sample.StrList.append": ('sample.Str',),
-    "sample.StrList.constructorUsed": (),
-    "sample.StrList.join": ('sample.Str',),
-# class sample.TemplatePtr:
-    "sample.TemplatePtr.__init__": (),
-    "sample.TemplatePtr.dummy_method": ('typing.List[typing.Tuple]',),
-# class sample.Time:
-# class sample.Time.NumArgs:
-    "sample.Time.__init__": [(), ('int', 'int', 'int', 'int'), ('sample.Time',)],
-    "sample.Time.__copy__": (),
-    "sample.Time.hour": (),
-    "sample.Time.isNull": (),
-    "sample.Time.minute": (),
-    "sample.Time.msec": (),
-    "sample.Time.second": (),
-    "sample.Time.setTime": [(), ('int', 'int', 'int', 'int')],
-    "sample.Time.somethingCompletelyDifferent": [(), ('int', 'int', 'sample.ImplicitConv', 'object')],
-    "sample.Time.toString": (),
-# class sample.Union:
-    "sample.Union.__init__": [(), ('sample.Data',), ('sample.Intersection',), ('sample.Union',)],
-    "sample.Union.__and__": ('sample.Data',),
-    "sample.Union.__copy__": (),
-    "sample.Union.addFilter": ('sample.Filter',),
-    "sample.Union.filters": (),
-# class sample.UnremovedNamespace:
-# class sample.UnremovedNamespace.RemovedNamespace3_Enum:
-# class sample.ValueAndVirtual:
-    "sample.ValueAndVirtual.__init__": [('int',), ('sample.ValueAndVirtual',)],
-    "sample.ValueAndVirtual.__call__": ('int', 'int'),
-    "sample.ValueAndVirtual.__copy__": (),
-    "sample.ValueAndVirtual.id": (),
-# class sample.VirtualDaughter:
-    "sample.VirtualDaughter.__init__": [(), ('sample.Str',), ('sample.VirtualDaughter',)],
-    "sample.VirtualDaughter.__copy__": (),
-# class sample.VirtualDaughter2:
-    "sample.VirtualDaughter2.__init__": (),
-    "sample.VirtualDaughter2.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualDaughter2.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualDtor:
-    "sample.VirtualDtor.__init__": [(), ('sample.VirtualDtor',)],
-    "sample.VirtualDtor.__copy__": (),
-    "sample.VirtualDtor.create": (),
-    "sample.VirtualDtor.dtorCalled": (),
-    "sample.VirtualDtor.resetDtorCounter": (),
-# class sample.VirtualFinalDaughter:
-    "sample.VirtualFinalDaughter.__init__": (),
-    "sample.VirtualFinalDaughter.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualFinalDaughter.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VirtualMethods:
-    "sample.VirtualMethods.__init__": [('sample.Str',), ('sample.VirtualMethods',)],
-    "sample.VirtualMethods.__copy__": (),
-    "sample.VirtualMethods.callCallMe": (),
-    "sample.VirtualMethods.callCreateStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.callGetMargins": (),
-    "sample.VirtualMethods.callMe": (),
-    "sample.VirtualMethods.callName": (),
-    "sample.VirtualMethods.callRecursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.callStrListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.callSum0": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callSum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.callVirtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-    "sample.VirtualMethods.createStr": ('str', 'sample.Str'),
-    "sample.VirtualMethods.getMargins": (),
-    "sample.VirtualMethods.name": (),
-    "sample.VirtualMethods.recursionOnModifiedVirtual": ('sample.Str',),
-    "sample.VirtualMethods.setMargins": ('int', 'int', 'int', 'int'),
-    "sample.VirtualMethods.strListToStdList": ('sample.StrList',),
-    "sample.VirtualMethods.sum1": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum2": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum3": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sum4": ('int', 'int', 'int'),
-    "sample.VirtualMethods.sumThree": ('int', 'int', 'int'),
-    "sample.VirtualMethods.virtualMethod0": ('typing.Tuple[float, float]', 'int', 'complex', 'bool'),
-# class sample.VoidHolder:
-    "sample.VoidHolder.__init__": [('int',), ('sample.VoidHolder',)],
-    "sample.VoidHolder.__copy__": (),
-    "sample.VoidHolder.gimmeMeSomeVoidPointer": (),
-    "sample.VoidHolder.takeVoidPointer": ('int',),
-    "sample.VoidHolder.voidPointer": (),
-# class sample.sample:
-# class sample.sample.sample:
-    "sample.sample.sample.__init__": [('int',), ('sample.sample.sample',)],
-    "sample.sample.sample.__copy__": (),
-    "sample.sample.sample.value": (),
-    "sample.sample.acceptDouble": ('float',),
-    "sample.sample.acceptInt": ('int',),
-    "sample.sample.acceptIntReference": ('int',),
-    "sample.sample.acceptLong": ('int',),
-    "sample.sample.acceptOddBoolReference": ('bool',),
-    "sample.sample.acceptUInt": ('int',),
-    "sample.sample.acceptULong": ('int',),
-    "sample.sample.applyHomogeneousTransform": ('typing.Tuple[float, float]', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float', 'float'),
-    "sample.sample.cacheSize": (),
-    "sample.sample.changePStr": ('str',),
-    "sample.sample.convertIntegersToCppAndThenToPython": ('int', 'int'),
-    "sample.sample.convertListOfIntegersToCppAndThenToPython": ('typing.List[int]',),
-    "sample.sample.convertObjectTypeToCppAndThenToPython": ('object', 'object'),
-    "sample.sample.convertValueTypeToCppAndThenToPython": ('typing.Tuple[float, float]', 'typing.Tuple[float, float]', 'typing.Tuple[float, float]'),
-    "sample.sample.countCharacters": ('str',),
-    "sample.sample.countVarargs": ('int', 'None'),
-    "sample.sample.cppTypeIsObjectType": ('str',),
-    "sample.sample.cppTypeIsValueType": ('str',),
-    "sample.sample.createListOfPStr": ('str', 'str'),
-    "sample.sample.createPStrList": ('str', 'str'),
-    "sample.sample.createProtectedProperty": (),
-    "sample.sample.doubleLongLong": ('int',),
-    "sample.sample.doubleShort": ('int',),
-    "sample.sample.doubleUnsignedInt": ('int',),
-    "sample.sample.doubleUnsignedLongLong": ('int',),
-    "sample.sample.duplicatePStr": (),
-    "sample.sample.getConversionTypeString": ('str',),
-    "sample.sample.getPythonType": ('str',),
-    "sample.sample.gimmeComplexList": (),
-    "sample.sample.gimmeDouble": (),
-    "sample.sample.gimmeInt": (),
-    "sample.sample.makeCString": (),
-    "sample.sample.multiplyPair": ('typing.Tuple[float, float]',),
-    "sample.sample.multiplyString": ('str', 'int'),
-    "sample.sample.overloadedFunc": [('float',), ('int',)],
-    "sample.sample.returnCString": (),
-    "sample.sample.returnNullObjectTypePointer": (),
-    "sample.sample.returnNullPrimitivePointer": (),
-    "sample.sample.returnNullValueTypePointer": (),
-    "sample.sample.sum2d": ('typing.List[typing.List]',),
-    "sample.sample.sumComplexPair": ('typing.Tuple[complex, complex]',),
-    "sample.sample.sumDoubleArray": ('typing.Tuple[float, float, float, float]',),
-    "sample.sample.sumDoubleMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumIntArray": ('typing.Tuple[int, int, int, int]',),
-    "sample.sample.sumIntMatrix": ('typing.Tuple[typing.Tuple, typing.Tuple, typing.Tuple]',),
-    "sample.sample.sumproduct": ('typing.List[typing.Tuple]',),
-    "sample.sample.transmuteComplexIntoPoint": ('complex',),
-    "sample.sample.transmutePointIntoComplex": ('typing.Tuple[float, float]',),
-    }) if "sample" in sys.modules else None
-# Module other
-sig_dict.update({
-# class other.ExtendsNoImplicitConversion:
-    "other.ExtendsNoImplicitConversion.__init__": [('Missing("other.ExtendsNoImplicitConversion")',), ('int',)],
-    "other.ExtendsNoImplicitConversion.__copy__": (),
-    "other.ExtendsNoImplicitConversion.objId": (),
-# class other.Number:
-    "other.Number.__init__": [('int',), ('numbers.Number',)],
-    "other.Number.__copy__": (),
-    "other.Number.__mul__": ('typing.Tuple[float, float]',),
-    "other.Number.fromComplex": ('complex',),
-    "other.Number.toComplex": (),
-    "other.Number.toStr": (),
-    "other.Number.value": (),
-# class other.OtherDerived:
-    "other.OtherDerived.__init__": ('int',),
-    "other.OtherDerived.className": (),
-    "other.OtherDerived.createObject": (),
-    "other.OtherDerived.getClassName": (),
-    "other.OtherDerived.pureVirtual": (),
-    "other.OtherDerived.pureVirtualReturningVoidPtr": (),
-    "other.OtherDerived.returnAnEnum": (),
-    "other.OtherDerived.unpureVirtual": (),
-    "other.OtherDerived.useEnumTypeFromOtherModule": ('sample.OverloadedFuncEnum',),
-    "other.OtherDerived.useObjectTypeFromOtherModule": ('object',),
-    "other.OtherDerived.useValueTypeFromOtherModule": [('complex',), ('sample.Event',)],
-# class other.OtherMultipleDerived:
-    "other.OtherMultipleDerived.__init__": (),
-    "other.OtherMultipleDerived.createObject": ('str',),
-    "other.OtherMultipleDerived.returnUselessClass": (),
-# class other.OtherObjectType:
-    "other.OtherObjectType.__init__": (),
-    "other.OtherObjectType.__lshift__": ('sample.Collector',),
-    }) if "other" in sys.modules else None
-# Module smart
-sig_dict.update({
-# class smart.Integer:
-    "smart.Integer.__init__": [(), ('smart.Integer',)],
-    "smart.Integer.__copy__": (),
-    "smart.Integer.printInteger": (),
-# class smart.Integer2:
-    "smart.Integer2.__init__": [(), ('int',)],
-    "smart.Integer2.__copy__": (),
-# class smart.Obj:
-    "smart.Obj.__init__": (),
-    "smart.Obj.giveSharedPtrToInteger": (),
-    "smart.Obj.giveSharedPtrToInteger2": (),
-    "smart.Obj.giveSharedPtrToObj": (),
-    "smart.Obj.giveSharedPtrToObjList": ('int',),
-    "smart.Obj.printObj": (),
-    "smart.Obj.takeInteger": ('smart.Integer',),
-    "smart.Obj.takeSharedPtrToInteger": ('smart.SharedPtr',),
-    "smart.Obj.takeSharedPtrToObj": ('smart.SharedPtr',),
-# class smart.Registry:
-    "smart.Registry.__init__": (),
-    "smart.Registry.add": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.countIntegers": (),
-    "smart.Registry.countObjects": (),
-    "smart.Registry.getInstance": (),
-    "smart.Registry.remove": [('smart.Integer',), ('smart.Obj',)],
-    "smart.Registry.setShouldPrint": ('bool',),
-    "smart.Registry.shouldPrint": (),
-# class smart.SharedPtr:
-# class smart.SharedPtr.__next_in_mro__:
-# class smart.SharedPtr<Integer >:
-    "smart.SharedPtr<Integer >.__copy__": (),
-    "smart.SharedPtr<Integer >.data": (),
-    "smart.SharedPtr<Integer >.useCount": (),
-# class smart.SharedPtr<Obj >:
-    "smart.SharedPtr<Obj >.__copy__": (),
-    "smart.SharedPtr<Obj >.data": (),
-    "smart.SharedPtr<Obj >.useCount": (),
-# class smart.SharedPtr<Smart::Integer2 >:
-    "smart.SharedPtr<Smart::Integer2 >.__copy__": (),
-    "smart.SharedPtr<Smart::Integer2 >.data": (),
-    "smart.SharedPtr<Smart::Integer2 >.useCount": (),
-    }) if "smart" in sys.modules else None
-# eof
diff --git a/sources/pyside6/tests/registry/scrape_testresults.py b/sources/pyside6/tests/registry/scrape_testresults.py
index a6e3b048b..b7b6b58aa 100644
--- a/sources/pyside6/tests/registry/scrape_testresults.py
+++ b/sources/pyside6/tests/registry/scrape_testresults.py
@@ -212,7 +212,7 @@ def handle_suburl(idx, n, url, level):
                 print(os.getpid(), test_name)
                 response = read_url(sub_url)
                 txt = response.text if response else ''
-                if "BEGIN_FILE" in txt and not "'BEGIN_FILE'" in txt:
+                if "BEGIN_FILE" in txt and "'BEGIN_FILE'" not in txt:
                     # find the text, but not a traceback with that text
                     print(os.getpid(), test_name, "FOUND!")
                     write_data(test_name, response.text)
diff --git a/sources/pyside6/tests/registry/util.py b/sources/pyside6/tests/registry/util.py
index 0359d28c4..5d81926a1 100644
--- a/sources/pyside6/tests/registry/util.py
+++ b/sources/pyside6/tests/registry/util.py
@@ -26,8 +26,6 @@ def isolate_warnings():
         if mod and hasattr(mod, warn_name):
             save_warnings[name] = mod.__dict__[warn_name]
             delattr(mod, warn_name)
-        else:
-            save_warnings[name] = None
     yield
     for name, warn in save_warnings.items():
         mod = sys.modules[name]
@@ -73,14 +71,8 @@ def linux_distribution():
     # distro package, ASAP! The distro has been extracted from Python,
     # because it changes more often than the Python version.
     distribution = []
-    try:
-        import distro
-        distribution = distro.linux_distribution()
-    except ImportError:
-        # platform.linux_distribution() was removed in 3.8
-        if sys.version_info[:2] < (3, 8):
-            import platform
-            distribution = platform.linux_distribution()
+    import distro
+    distribution = distro.linux_distribution()
     if distribution:
         return "".join(distribution[:2]).lower()
     warnings.warn('Cannot determine Linux distribution, please install distro',
diff --git a/sources/pyside6/tests/signals/CMakeLists.txt b/sources/pyside6/tests/signals/CMakeLists.txt
index 08ca954d3..ff342adc7 100644
--- a/sources/pyside6/tests/signals/CMakeLists.txt
+++ b/sources/pyside6/tests/signals/CMakeLists.txt
@@ -1,3 +1,6 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
 PYSIDE_TEST(args_dont_match_test.py)
 PYSIDE_TEST(bug_79.py)
 PYSIDE_TEST(bug_189.py)
@@ -13,6 +16,7 @@ PYSIDE_TEST(leaking_signal_test.py)
 PYSIDE_TEST(multiple_connections_gui_test.py)
 PYSIDE_TEST(multiple_connections_test.py)
 PYSIDE_TEST(pysignal_test.py)
+PYSIDE_TEST(qobject_callable_connect_test.py)
 PYSIDE_TEST(qobject_destroyed_test.py)
 PYSIDE_TEST(qobject_receivers_test.py)
 PYSIDE_TEST(qobject_sender_test.py)
diff --git a/sources/pyside6/tests/signals/anonymous_slot_leak_test.py b/sources/pyside6/tests/signals/anonymous_slot_leak_test.py
new file mode 100644
index 000000000..560a08659
--- /dev/null
+++ b/sources/pyside6/tests/signals/anonymous_slot_leak_test.py
@@ -0,0 +1,55 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from functools import partial
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtWidgets import QWidget
+from helper.usesqapplication import UsesQApplication
+
+
+have_debug = hasattr(sys, "gettotalrefcount")
+
+
+class LeakerLambda():
+    def __init__(self, widget):
+        widget.windowIconChanged.connect(lambda *args: None)
+
+
+class LeakerFunctoolsPartial():
+    def __init__(self, widget):
+        widget.windowIconChanged.connect(partial(int, 0))
+
+
+class TestBugPYSIDE2299(UsesQApplication):
+    def leak(self, leaker):
+        widget = QWidget()
+
+        # Warm-up
+        leaker(widget)
+
+        refs_before = sys.gettotalrefcount()
+        for _ in range(1000):
+            leaker(widget)
+        refs_after = sys.gettotalrefcount()
+
+        self.assertAlmostEqual(refs_after - refs_before, 0, delta=10)
+
+    @unittest.skipUnless(have_debug, "You need a debug build")
+    def test_lambda(self):
+        self.leak(LeakerLambda)
+
+    @unittest.skipUnless(have_debug, "You need a debug build")
+    def test_functools_partial(self):
+        self.leak(LeakerFunctoolsPartial)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/signals/args_dont_match_test.py b/sources/pyside6/tests/signals/args_dont_match_test.py
index e200cedbc..4f56be348 100644
--- a/sources/pyside6/tests/signals/args_dont_match_test.py
+++ b/sources/pyside6/tests/signals/args_dont_match_test.py
@@ -11,7 +11,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject, Signal
+
+
+class Sender(QObject):
+    the_signal = Signal(int, int, int)
 
 
 class ArgsDontMatch(unittest.TestCase):
@@ -21,9 +25,9 @@ class ArgsDontMatch(unittest.TestCase):
 
     def testConnectSignalToSlotWithLessArgs(self):
         self.ok = False
-        obj1 = QObject()
-        QObject.connect(obj1, SIGNAL('the_signal(int, int, int)'), self.callback)
-        obj1.emit(SIGNAL('the_signal(int, int, int)'), 1, 2, 3)
+        obj1 = Sender()
+        obj1.the_signal.connect(self.callback)
+        obj1.the_signal.emit(1, 2, 3)
 
         self.assertTrue(self.ok)
 
diff --git a/sources/pyside6/tests/signals/bug_311.py b/sources/pyside6/tests/signals/bug_311.py
index 5f8af81c1..e27476172 100644
--- a/sources/pyside6/tests/signals/bug_311.py
+++ b/sources/pyside6/tests/signals/bug_311.py
@@ -12,7 +12,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QDate, QObject, Signal
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class DerivedDate(QDate):
@@ -26,7 +26,7 @@ class Emitter(QObject):
     tupleSignal = Signal(tuple)
 
 
-class SignaltoSignalTest(UsesQCoreApplication):
+class SignaltoSignalTest(UsesQApplication):
     def myCb(self, dt):
         self._dt = dt
 
@@ -52,4 +52,3 @@ class SignaltoSignalTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/bug_312.py b/sources/pyside6/tests/signals/bug_312.py
index de1a2f6a8..80d56a020 100644
--- a/sources/pyside6/tests/signals/bug_312.py
+++ b/sources/pyside6/tests/signals/bug_312.py
@@ -11,44 +11,29 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject, Signal
 
 MAX_LOOPS = 5
 MAX_OBJECTS = 200
 
 
-class Dummy(object):
-    def __init__(self, parent):
-        self._parent = parent
-
-    def callback(self):
-        self._called = True
+class Sender(QObject):
+    fire = Signal()
 
 
 class MultipleSlots(unittest.TestCase):
     def myCB(self):
         self._count += 1
 
-    """
-    def testUnboundSignal(self):
-        o = QObject()
-        self._count  = 0
-        for i in range(MAX_OBJECTS):
-            QObject.connect(o, SIGNAL("fire()"), lambda: self.myCB())
-
-        o.emit(SIGNAL("fire()"))
-        self.assertEqual(self._count, MAX_OBJECTS)
-
-    """
     def testDisconnectCleanup(self):
         for c in range(MAX_LOOPS):
             self._count = 0
             self._senders = []
             for i in range(MAX_OBJECTS):
-                o = QObject()
-                QObject.connect(o, SIGNAL("fire()"), lambda: self.myCB())
+                o = Sender()
+                o.fire.connect(lambda: self.myCB())
                 self._senders.append(o)
-                o.emit(SIGNAL("fire()"))
+                o.fire.emit()
 
             self.assertEqual(self._count, MAX_OBJECTS)
 
@@ -58,5 +43,3 @@ class MultipleSlots(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/pyside6/tests/signals/bug_319.py b/sources/pyside6/tests/signals/bug_319.py
index aaa5ea991..657733afb 100644
--- a/sources/pyside6/tests/signals/bug_319.py
+++ b/sources/pyside6/tests/signals/bug_319.py
@@ -12,7 +12,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, Signal, Slot
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class Listener(QObject):
@@ -31,7 +31,7 @@ class Communicate(QObject):
     speak = Signal(tuple)
 
 
-class SignaltoSignalTest(UsesQCoreApplication):
+class SignaltoSignalTest(UsesQApplication):
     def testBug(self):
         someone = Communicate()
         someone2 = Listener()
@@ -45,4 +45,3 @@ class SignaltoSignalTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/bug_79.py b/sources/pyside6/tests/signals/bug_79.py
index 54bd1f076..77ac621d5 100644
--- a/sources/pyside6/tests/signals/bug_79.py
+++ b/sources/pyside6/tests/signals/bug_79.py
@@ -30,7 +30,7 @@ class ConnectTest(unittest.TestCase):
 
     def testNoLeaks_ConnectAndDisconnect(self):
         self._called = None
-        app = QApplication([])
+        app = QApplication([])  # noqa: F841
         o = QTreeView()
         o.setModel(QStandardItemModel())
         o.selectionModel().destroyed.connect(self.callback)
@@ -38,6 +38,11 @@ class ConnectTest(unittest.TestCase):
         gc.collect()
         # if this is no debug build, then we check at least that
         # we do not crash any longer.
+        for idx in range(200):
+            # PYSIDE-2230: Warm-up is necessary before measuring, because
+            # the code changes the constant parts after some time.
+            o.selectionModel().destroyed.connect(self.callback)
+            o.selectionModel().destroyed.disconnect(self.callback)
         if not skiptest:
             total = gettotalrefcount()
         for idx in range(1000):
diff --git a/sources/pyside6/tests/signals/decorators_test.py b/sources/pyside6/tests/signals/decorators_test.py
index 5b3b54690..b29339ee4 100644
--- a/sources/pyside6/tests/signals/decorators_test.py
+++ b/sources/pyside6/tests/signals/decorators_test.py
@@ -11,7 +11,11 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, Slot, SIGNAL, SLOT
+from PySide6.QtCore import QObject, Slot, Signal
+
+
+class Sender(QObject):
+    mySignal = Signal()
 
 
 class MyObject(QObject):
@@ -57,9 +61,10 @@ class StaticMetaObjectTest(unittest.TestCase):
         self.assertTrue(m.indexOfSlot('mySlot4(QString,int)') > 0)
 
     def testEmission(self):
+        sender = Sender()
         o = MyObject()
-        o.connect(SIGNAL("mySignal()"), o, SLOT("mySlot()"))
-        o.emit(SIGNAL("mySignal()"))
+        sender.mySignal.connect(o.mySlot)
+        sender.mySignal.emit()
         self.assertTrue(o._slotCalledCount == 1)
 
     def testResult(self):
diff --git a/sources/pyside6/tests/signals/invalid_callback_test.py b/sources/pyside6/tests/signals/invalid_callback_test.py
index 0d7e574ef..2788c1d1a 100644
--- a/sources/pyside6/tests/signals/invalid_callback_test.py
+++ b/sources/pyside6/tests/signals/invalid_callback_test.py
@@ -13,7 +13,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject
 
 
 class InvalidCallback(unittest.TestCase):
@@ -34,10 +34,8 @@ class InvalidCallback(unittest.TestCase):
 
     def testIntegerCb(self):
         # Test passing an int as callback to QObject.connect
-        self.assertRaises(TypeError, QObject.connect, self.obj,
-                            SIGNAL('destroyed()'), 42)
+        self.assertRaises(TypeError, self.obj.destroyed.connect, 42)
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/lambda_gui_test.py b/sources/pyside6/tests/signals/lambda_gui_test.py
index 45a6d6acf..2123e7206 100644
--- a/sources/pyside6/tests/signals/lambda_gui_test.py
+++ b/sources/pyside6/tests/signals/lambda_gui_test.py
@@ -12,43 +12,39 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
-
-try:
-    from PySide6.QtWidgets import QSpinBox, QPushButton
-    hasQtGui = True
-except ImportError:
-    hasQtGui = False
+from PySide6.QtWidgets import QSpinBox, QPushButton
 
 from helper.usesqapplication import UsesQApplication
 
-if hasQtGui:
-    class Control:
-        def __init__(self):
-            self.arg = False
-
-    class QtGuiSigLambda(UsesQApplication):
-
-        def testButton(self):
-            # Connecting a lambda to a QPushButton.clicked()
-            obj = QPushButton('label')
-            ctr = Control()
-            func = lambda: setattr(ctr, 'arg', True)
-            obj.clicked.connect(func)
-            obj.click()
-            self.assertTrue(ctr.arg)
-            QObject.disconnect(obj, SIGNAL('clicked()'), func)
-
-        def testSpinButton(self):
-            # Connecting a lambda to a QPushButton.clicked()
-            obj = QSpinBox()
-            ctr = Control()
-            arg = 444
-            func = lambda x: setattr(ctr, 'arg', 444)
-            obj.valueChanged.connect(func)
-            obj.setValue(444)
-            self.assertEqual(ctr.arg, arg)
-            QObject.disconnect(obj, SIGNAL('valueChanged(int)'), func)
+
+class Control:
+    def __init__(self):
+        self.arg = False
+
+
+class QtWidgetsSigLambda(UsesQApplication):
+
+    def testButton(self):
+        # Connecting a lambda to a QPushButton.clicked()
+        obj = QPushButton('label')
+        ctr = Control()
+        func = lambda: setattr(ctr, 'arg', True)  # noqa: E731
+        obj.clicked.connect(func)
+        obj.click()
+        self.assertTrue(ctr.arg)
+        self.assertTrue(obj.clicked.disconnect(func))
+
+    def testSpinButton(self):
+        # Connecting a lambda to a QPushButton.clicked()
+        obj = QSpinBox()
+        ctr = Control()
+        arg = 444
+        func = lambda x: setattr(ctr, 'arg', 444)  # noqa: E731
+        obj.valueChanged.connect(func)
+        obj.setValue(444)
+        self.assertEqual(ctr.arg, arg)
+        self.assertTrue(obj.valueChanged.disconnect(func))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/signals/lambda_test.py b/sources/pyside6/tests/signals/lambda_test.py
index cc4e61ca1..23fcdf5fa 100644
--- a/sources/pyside6/tests/signals/lambda_test.py
+++ b/sources/pyside6/tests/signals/lambda_test.py
@@ -7,18 +7,34 @@
 import os
 import sys
 import unittest
+import weakref
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, QProcess
+from PySide6.QtCore import QCoreApplication, QObject, Signal, SIGNAL, QProcess
 
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class Dummy(QObject):
+class Sender(QObject):
+    void_signal = Signal()
+    int_signal = Signal(int)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._delayed_int = 0
+
+    def emit_void(self):
+        self.void_signal.emit()
+
+    def emit_int(self, v):
+        self.int_signal.emit(v)
+
+
+class Receiver(QObject):
 
     def __init__(self, *args):
         super().__init__(*args)
@@ -28,45 +44,79 @@ class BasicCase(unittest.TestCase):
 
     def testSimplePythonSignalNoArgs(self):
         # Connecting a lambda to a simple python signal without arguments
-        obj = Dummy()
-        QObject.connect(obj, SIGNAL('foo()'),
-                        lambda: setattr(obj, 'called', True))
-        obj.emit(SIGNAL('foo()'))
-        self.assertTrue(obj.called)
+        receiver = Receiver()
+        sender = Sender()
+        sender.void_signal.connect(lambda: setattr(receiver, 'called', True))
+        sender.emit_void()
+        self.assertTrue(receiver.called)
 
     def testSimplePythonSignal(self):
         # Connecting a lambda to a simple python signal witharguments
-        obj = Dummy()
+        receiver = Receiver()
+        sender = Sender()
+        arg = 42
+        sender.int_signal.connect(lambda x: setattr(receiver, 'arg', arg))
+        sender.emit_int(arg)
+        self.assertEqual(receiver.arg, arg)
+
+    def testSimplePythonSignalNoArgsString(self):
+        # Connecting a lambda to a simple python signal without arguments
+        receiver = Receiver()
+        sender = Sender()
+        QObject.connect(sender, SIGNAL('void_signal()'),
+                        lambda: setattr(receiver, 'called', True))
+        sender.emit_void()
+        self.assertTrue(receiver.called)
+
+    def testSimplePythonSignalString(self):
+        # Connecting a lambda to a simple python signal witharguments
+        receiver = Receiver()
+        sender = Sender()
         arg = 42
-        QObject.connect(obj, SIGNAL('foo(int)'),
-                        lambda x: setattr(obj, 'arg', 42))
-        obj.emit(SIGNAL('foo(int)'), arg)
-        self.assertEqual(obj.arg, arg)
+        QObject.connect(sender, SIGNAL('int_signal(int)'),
+                        lambda x: setattr(receiver, 'arg', arg))
+        sender.emit_int(arg)
+        self.assertEqual(receiver.arg, arg)
 
 
-class QtSigLambda(UsesQCoreApplication):
+class QtSigLambda(UsesQApplication):
 
     qapplication = True
 
-    def testNoArgs(self):
-        '''Connecting a lambda to a signal without arguments'''
-        proc = QProcess()
-        dummy = Dummy()
-        QObject.connect(proc, SIGNAL('started()'),
-                        lambda: setattr(dummy, 'called', True))
-        proc.start(sys.executable, ['-c', '""'])
-        proc.waitForFinished()
-        self.assertTrue(dummy.called)
-
     def testWithArgs(self):
-        '''Connecting a lambda to a signal with arguments'''
+        '''Connecting a lambda to a signal with and without arguments'''
         proc = QProcess()
-        dummy = Dummy()
-        QObject.connect(proc, SIGNAL('finished(int)'),
-                        lambda x: setattr(dummy, 'called', x))
+        dummy = Receiver()
+        proc.started.connect(lambda: setattr(dummy, 'called', True))
+        proc.finished.connect(lambda x: setattr(dummy, 'exit_code', x))
+
         proc.start(sys.executable, ['-c', '""'])
-        proc.waitForFinished()
-        self.assertEqual(dummy.called, proc.exitCode())
+        self.assertTrue(proc.waitForStarted())
+        self.assertTrue(proc.waitForFinished())
+
+        self.assertTrue(dummy.called)
+        self.assertEqual(dummy.exit_code, proc.exitCode())
+
+    def testRelease(self):
+        """PYSIDE-2646: Test whether main thread target slot lambda/methods
+           (and their captured objects) are released by the signal manager
+           after a while."""
+
+        def do_connect(sender):
+            receiver = Receiver()
+            sender.void_signal.connect(lambda: setattr(receiver, 'called', True))
+            return receiver
+
+        sender = Sender()
+        receiver = weakref.ref(do_connect(sender))
+        sender.emit_void()
+        self.assertTrue(receiver().called)
+        del sender
+        for i in range(3):
+            if not receiver():
+                break
+            QCoreApplication.processEvents()
+        self.assertFalse(receiver())
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/leaking_signal_test.py b/sources/pyside6/tests/signals/leaking_signal_test.py
index e7aff9628..666ae7a13 100644
--- a/sources/pyside6/tests/signals/leaking_signal_test.py
+++ b/sources/pyside6/tests/signals/leaking_signal_test.py
@@ -4,7 +4,6 @@
 import os
 import sys
 import unittest
-import weakref
 
 from pathlib import Path
 sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
@@ -21,7 +20,7 @@ class LeakingSignal(unittest.TestCase):
         class Emitter(QObject):
             my_signal = Signal(object)
 
-        emitter = Emitter()
+        emitter = Emitter()  # noqa: F841
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/multiple_connections_gui_test.py b/sources/pyside6/tests/signals/multiple_connections_gui_test.py
index 097811750..295369b7d 100644
--- a/sources/pyside6/tests/signals/multiple_connections_gui_test.py
+++ b/sources/pyside6/tests/signals/multiple_connections_gui_test.py
@@ -1,9 +1,7 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-from functools import partial
 import os
-import random
 import sys
 import unittest
 
@@ -12,22 +10,16 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
-
-try:
-    from PySide6.QtWidgets import QPushButton, QSpinBox
-    hasQtGui = True
-except ImportError:
-    hasQtGui = False
+from PySide6.QtWidgets import QPushButton, QSpinBox
 
 from helper.basicpyslotcase import BasicPySlotCase
 from helper.usesqapplication import UsesQApplication
 
 
-class MultipleSignalConnections(unittest.TestCase):
-    '''Base class for multiple signal connection testing'''
+class QtGuiMultipleSlots(UsesQApplication):
+    '''Multiple connections to QtGui signals'''
 
-    def run_many(self, sender, signal, emitter, receivers, args=None):
+    def run_many(self, signal, emitter, receivers, args=None):
         """Utility method to connect a list of receivers to a signal.
         sender - QObject that will emit the signal
         signal - string with the signal signature
@@ -41,7 +33,7 @@ class MultipleSignalConnections(unittest.TestCase):
 
         for rec in receivers:
             rec.setUp()
-            QObject.connect(sender, SIGNAL(signal), rec.cb)
+            signal.connect(rec.cb)
             rec.args = tuple(args)
 
         emitter(*args)
@@ -49,24 +41,20 @@ class MultipleSignalConnections(unittest.TestCase):
         for rec in receivers:
             self.assertTrue(rec.called)
 
+    def testButtonClick(self):
+        """Multiple connections to QPushButton.clicked()"""
+        sender = QPushButton('button')
+        receivers = [BasicPySlotCase() for x in range(30)]
+        self.run_many(sender.clicked, sender.click, receivers)
 
-if hasQtGui:
-    class QtGuiMultipleSlots(UsesQApplication, MultipleSignalConnections):
-        '''Multiple connections to QtGui signals'''
-
-        def testButtonClick(self):
-            """Multiple connections to QPushButton.clicked()"""
-            sender = QPushButton('button')
-            receivers = [BasicPySlotCase() for x in range(30)]
-            self.run_many(sender, 'clicked()', sender.click, receivers)
+    def testSpinBoxValueChanged(self):
+        """Multiple connections to QSpinBox.valueChanged(int)"""
+        sender = QSpinBox()
+        # FIXME if number of receivers if higher than 50, segfaults
+        receivers = [BasicPySlotCase() for x in range(10)]
+        self.run_many(sender.valueChanged, sender.setValue,
+                      receivers, (1,))
 
-        def testSpinBoxValueChanged(self):
-            """Multiple connections to QSpinBox.valueChanged(int)"""
-            sender = QSpinBox()
-            # FIXME if number of receivers if higher than 50, segfaults
-            receivers = [BasicPySlotCase() for x in range(10)]
-            self.run_many(sender, 'valueChanged(int)', sender.setValue,
-                          receivers, (1,))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/signals/multiple_connections_test.py b/sources/pyside6/tests/signals/multiple_connections_test.py
index 783c9414b..233851797 100644
--- a/sources/pyside6/tests/signals/multiple_connections_test.py
+++ b/sources/pyside6/tests/signals/multiple_connections_test.py
@@ -11,16 +11,16 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, QProcess
+from PySide6.QtCore import QObject, Signal, QProcess
 
 from helper.basicpyslotcase import BasicPySlotCase
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class MultipleSignalConnections(unittest.TestCase):
     '''Base class for multiple signal connection testing'''
 
-    def run_many(self, sender, signal, emitter, receivers, args=None):
+    def run_many(self, signal, emitter, receivers, args=None):
         """Utility method to connect a list of receivers to a signal.
         sender - QObject that will emit the signal
         signal - string with the signal signature
@@ -33,7 +33,7 @@ class MultipleSignalConnections(unittest.TestCase):
             args = tuple()
         for rec in receivers:
             rec.setUp()
-            self.assertTrue(QObject.connect(sender, SIGNAL(signal), rec.cb))
+            self.assertTrue(signal.connect(rec.cb))
             rec.args = tuple(args)
 
         emitter(*args)
@@ -42,22 +42,23 @@ class MultipleSignalConnections(unittest.TestCase):
             self.assertTrue(rec.called)
 
 
-class PythonMultipleSlots(UsesQCoreApplication, MultipleSignalConnections):
+class PythonMultipleSlots(UsesQApplication, MultipleSignalConnections):
     '''Multiple connections to python signals'''
 
     def testPythonSignal(self):
         """Multiple connections to a python signal (short-circuit)"""
 
-        class Dummy(QObject):
-            pass
+        class Sender(QObject):
 
-        sender = Dummy()
+            foobar = Signal(int)
+
+        sender = Sender()
         receivers = [BasicPySlotCase() for x in range(10)]
-        self.run_many(sender, 'foobar(int)', partial(sender.emit,
-                      SIGNAL('foobar(int)')), receivers, (0, ))
+        self.run_many(sender.foobar, partial(sender.foobar.emit),
+                      receivers, (0, ))
 
 
-class QProcessMultipleSlots(UsesQCoreApplication, MultipleSignalConnections):
+class QProcessMultipleSlots(UsesQApplication, MultipleSignalConnections):
     '''Multiple connections to QProcess signals'''
 
     def testQProcessStarted(self):
@@ -67,9 +68,10 @@ class QProcessMultipleSlots(UsesQCoreApplication, MultipleSignalConnections):
 
         def start_proc(*args):
             sender.start(sys.executable, ['-c', '""'])
-            sender.waitForFinished()
+            self.assertTrue(sender.waitForStarted())
+            self.assertTrue(sender.waitForFinished())
 
-        self.run_many(sender, 'started()', start_proc, receivers)
+        self.run_many(sender.started, start_proc, receivers)
 
     def testQProcessFinished(self):
         '''Multiple connections to QProcess.finished(int)'''
@@ -78,9 +80,10 @@ class QProcessMultipleSlots(UsesQCoreApplication, MultipleSignalConnections):
 
         def start_proc(*args):
             sender.start(sys.executable, ['-c', '""'])
-            sender.waitForFinished()
+            self.assertTrue(sender.waitForStarted())
+            self.assertTrue(sender.waitForFinished())
 
-        self.run_many(sender, 'finished(int)', start_proc, receivers, (0,))
+        self.run_many(sender.finished, start_proc, receivers, (0, QProcess.ExitStatus.NormalExit))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/pysignal_test.py b/sources/pyside6/tests/signals/pysignal_test.py
index e3d6a55da..d6f44edf8 100644
--- a/sources/pyside6/tests/signals/pysignal_test.py
+++ b/sources/pyside6/tests/signals/pysignal_test.py
@@ -11,31 +11,31 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT, Qt
-
-try:
-    from PySide6.QtWidgets import QSpinBox, QApplication, QWidget
-    hasQtGui = True
-except ImportError:
-    hasQtGui = False
+from PySide6.QtCore import QObject, Signal, Qt
+from PySide6.QtWidgets import QSpinBox, QApplication, QWidget  # noqa: F401
 
 from helper.usesqapplication import UsesQApplication
 
 
-class Dummy(QObject):
-    """Dummy class used in this test."""
+TEST_LIST = ["item1", "item2", "item3"]
+
+
+class Sender(QObject):
+    """Sender class used in this test."""
+
+    foo = Signal()
+    foo_int = Signal(int)
+    dummy = Signal(str)
+    dummy2 = Signal(str, list)
+
     def __init__(self, parent=None):
-        QObject.__init__(self, parent)
+        super().__init__(parent)
 
     def callDummy(self):
-        self.emit(SIGNAL("dummy(PyObject)"), "PyObject")
+        self.dummy.emit("PyObject")
 
     def callDummy2(self):
-        lst = []
-        lst.append("item1")
-        lst.append("item2")
-        lst.append("item3")
-        self.emit(SIGNAL("dummy2(PyObject, PyObject)"), "PyObject0", lst)
+        self.dummy2.emit("PyObject0", TEST_LIST)
 
 
 class PyObjectType(UsesQApplication):
@@ -46,35 +46,33 @@ class PyObjectType(UsesQApplication):
 
     def mySlot2(self, arg0, arg1):
         self.assertEqual(arg0, "PyObject0")
-        self.assertEqual(arg1[0], "item1")
-        self.assertEqual(arg1[1], "item2")
-        self.assertEqual(arg1[2], "item3")
+        self.assertEqual(arg1, TEST_LIST)
         self.callCount += 1
         if self.running:
             self.app.quit()
 
     def setUp(self):
-        super(PyObjectType, self).setUp()
+        super().setUp()
         self.callCount = 0
         self.running = False
 
     def testWithOneArg(self):
-        o = Dummy()
-        o.connect(SIGNAL("dummy(PyObject)"), self.mySlot)
+        o = Sender()
+        o.dummy.connect(self.mySlot)
         o.callDummy()
         self.assertEqual(self.callCount, 1)
 
     def testWithTwoArg(self):
-        o = Dummy()
-        o.connect(SIGNAL("dummy2(PyObject,PyObject)"), self.mySlot2)
+        o = Sender()
+        o.dummy2.connect(self.mySlot2)
         o.callDummy2()
         self.assertEqual(self.callCount, 1)
 
     def testAsyncSignal(self):
         self.called = False
         self.running = True
-        o = Dummy()
-        o.connect(SIGNAL("dummy2(PyObject,PyObject)"), self.mySlot2, Qt.QueuedConnection)
+        o = Sender()
+        o.dummy2.connect(self.mySlot2, Qt.QueuedConnection)
         o.callDummy2()
         self.app.exec()
         self.assertEqual(self.callCount, 1)
@@ -82,8 +80,8 @@ class PyObjectType(UsesQApplication):
     def testTwice(self):
         self.called = False
         self.running = True
-        o = Dummy()
-        o.connect(SIGNAL("dummy2(PyObject,PyObject)"), self.mySlot2, Qt.QueuedConnection)
+        o = Sender()
+        o.dummy2.connect(self.mySlot2, Qt.QueuedConnection)
         o.callDummy2()
         o.callDummy2()
         self.app.exec()
@@ -97,7 +95,7 @@ class PythonSigSlot(unittest.TestCase):
     def tearDown(self):
         try:
             del self.args
-        except:
+        except:  # noqa: E722
             pass
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
@@ -108,98 +106,98 @@ class PythonSigSlot(unittest.TestCase):
 
     def testNoArgs(self):
         """Python signal and slots without arguments"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo()'), self.callback)
+        obj1.foo.connect(self.callback)
         self.args = tuple()
-        obj1.emit(SIGNAL('foo()'), *self.args)
+        obj1.foo.emit(*self.args)
 
         self.assertTrue(self.called)
 
     def testWithArgs(self):
         """Python signal and slots with integer arguments"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo(int)'), self.callback)
+        obj1.foo_int.connect(self.callback)
         self.args = (42,)
-        obj1.emit(SIGNAL('foo(int)'), *self.args)
+        obj1.foo_int.emit(*self.args)
 
         self.assertTrue(self.called)
 
     def testDisconnect(self):
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo(int)'), self.callback)
-        QObject.disconnect(obj1, SIGNAL('foo(int)'), self.callback)
+        obj1.foo_int.connect(self.callback)
+        self.assertTrue(obj1.foo_int.disconnect(self.callback))
 
         self.args = (42, )
-        obj1.emit(SIGNAL('foo(int)'), *self.args)
+        obj1.foo_int.emit(*self.args)
 
         self.assertTrue(not self.called)
 
 
-if hasQtGui:
-    class SpinBoxPySignal(UsesQApplication):
-        """Tests the connection of python signals to QSpinBox qt slots."""
+class SpinBoxPySignal(UsesQApplication):
+    """Tests the connection of python signals to QSpinBox qt slots."""
 
-        def setUp(self):
-            super(SpinBoxPySignal, self).setUp()
-            self.obj = Dummy()
-            self.spin = QSpinBox()
-            self.spin.setValue(0)
+    def setUp(self):
+        super().setUp()
+        self.obj = Sender()
+        self.spin = QSpinBox()
+        self.spin.setValue(0)
 
-        def tearDown(self):
-            super(SpinBoxPySignal, self).tearDown()
-            del self.obj
-            del self.spin
-            # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
-            gc.collect()
+    def tearDown(self):
+        super().tearDown()
+        del self.obj
+        del self.spin
+        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
+        gc.collect()
+
+    def testValueChanged(self):
+        """Emission of a python signal to QSpinBox setValue(int)"""
 
-        def testValueChanged(self):
-            """Emission of a python signal to QSpinBox setValue(int)"""
-            QObject.connect(self.obj, SIGNAL('dummy(int)'), self.spin, SLOT('setValue(int)'))
-            self.assertEqual(self.spin.value(), 0)
+        self.obj.foo_int.connect(self.spin.setValue)
+        self.assertEqual(self.spin.value(), 0)
 
-            self.obj.emit(SIGNAL('dummy(int)'), 4)
-            self.assertEqual(self.spin.value(), 4)
+        self.obj.foo_int.emit(4)
+        self.assertEqual(self.spin.value(), 4)
 
-        def testValueChangedMultiple(self):
-            """Multiple emissions of a python signal to QSpinBox setValue(int)"""
-            QObject.connect(self.obj, SIGNAL('dummy(int)'), self.spin, SLOT('setValue(int)'))
-            self.assertEqual(self.spin.value(), 0)
+    def testValueChangedMultiple(self):
+        """Multiple emissions of a python signal to QSpinBox setValue(int)"""
+        self.obj.foo_int.connect(self.spin.setValue)
+        self.assertEqual(self.spin.value(), 0)
 
-            self.obj.emit(SIGNAL('dummy(int)'), 4)
-            self.assertEqual(self.spin.value(), 4)
+        self.obj.foo_int.emit(4)
+        self.assertEqual(self.spin.value(), 4)
 
-            self.obj.emit(SIGNAL('dummy(int)'), 77)
-            self.assertEqual(self.spin.value(), 77)
+        self.obj.foo_int.emit(77)
+        self.assertEqual(self.spin.value(), 77)
 
 
-if hasQtGui:
-    class WidgetPySignal(UsesQApplication):
-        """Tests the connection of python signals to QWidget qt slots."""
+class WidgetPySignal(UsesQApplication):
+    """Tests the connection of python signals to QWidget qt slots."""
+
+    def setUp(self):
+        super(WidgetPySignal, self).setUp()
+        self.obj = Sender()
+        self.widget = QWidget()
 
-        def setUp(self):
-            super(WidgetPySignal, self).setUp()
-            self.obj = Dummy()
-            self.widget = QWidget()
+    def tearDown(self):
+        super(WidgetPySignal, self).tearDown()
+        del self.obj
+        del self.widget
+        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
+        gc.collect()
 
-        def tearDown(self):
-            super(WidgetPySignal, self).tearDown()
-            del self.obj
-            del self.widget
-            # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
-            gc.collect()
+    def testShow(self):
+        """Emission of a python signal to QWidget slot show()"""
+        self.widget.hide()
 
-        def testShow(self):
-            """Emission of a python signal to QWidget slot show()"""
-            self.widget.hide()
+        self.obj.foo.connect(self.widget.show)
+        self.assertTrue(not self.widget.isVisible())
 
-            QObject.connect(self.obj, SIGNAL('dummy()'), self.widget, SLOT('show()'))
-            self.assertTrue(not self.widget.isVisible())
+        self.obj.foo.emit()
+        self.assertTrue(self.widget.isVisible())
 
-            self.obj.emit(SIGNAL('dummy()'))
-            self.assertTrue(self.widget.isVisible())
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/signals/qobject_callable_connect_test.py b/sources/pyside6/tests/signals/qobject_callable_connect_test.py
new file mode 100644
index 000000000..a7a26d6f5
--- /dev/null
+++ b/sources/pyside6/tests/signals/qobject_callable_connect_test.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import sys
+import unittest
+
+from pathlib import Path
+sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
+from init_paths import init_test_paths
+init_test_paths(False)
+
+from PySide6.QtCore import QObject, Signal
+
+
+class Emitter(QObject):
+    sig = Signal(int)
+
+
+class CallableObject(QObject):
+    called = False
+    x = 0
+
+    def __call__(self, x: int):
+        self.called = True
+        self.x = x
+
+
+class QObjectCallableConnectTest(unittest.TestCase):
+    '''Test case for QObject.connect() when the callable is also a QObject.'''
+
+    def testCallableConnect(self):
+        emitter = Emitter()
+        obj = CallableObject()
+        x = 1
+
+        emitter.sig.connect(obj)
+        emitter.sig.emit(x)
+
+        self.assertTrue(obj.called)
+        self.assertEqual(obj.x, x)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sources/pyside6/tests/signals/qobject_destroyed_test.py b/sources/pyside6/tests/signals/qobject_destroyed_test.py
index 08807e78e..a21762b41 100644
--- a/sources/pyside6/tests/signals/qobject_destroyed_test.py
+++ b/sources/pyside6/tests/signals/qobject_destroyed_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject
 
 
 class QObjectDestroyed(unittest.TestCase):
diff --git a/sources/pyside6/tests/signals/qobject_sender_test.py b/sources/pyside6/tests/signals/qobject_sender_test.py
index 1f01b57e5..9c1121eb8 100644
--- a/sources/pyside6/tests/signals/qobject_sender_test.py
+++ b/sources/pyside6/tests/signals/qobject_sender_test.py
@@ -13,8 +13,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QCoreApplication, QObject, QTimer, SIGNAL
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QCoreApplication, QObject, QTimer, Signal
+from helper.usesqapplication import UsesQApplication
 
 
 class ExtQTimer(QTimer):
@@ -22,6 +22,10 @@ class ExtQTimer(QTimer):
         super().__init__()
 
 
+class Sender(QObject):
+    foo = Signal()
+
+
 class Receiver(QObject):
     def __init__(self):
         super().__init__()
@@ -37,10 +41,10 @@ class ObjectSenderTest(unittest.TestCase):
     '''Test case for QObject.sender() method.'''
 
     def testSenderPythonSignal(self):
-        sender = QObject()
+        sender = Sender()
         recv = Receiver()
-        QObject.connect(sender, SIGNAL('foo()'), recv.callback)
-        sender.emit(SIGNAL('foo()'))
+        sender.foo.connect(recv.callback)
+        sender.foo.emit()
         self.assertEqual(sender, recv.the_sender)
 
 
@@ -48,14 +52,14 @@ class ObjectSenderCheckOnReceiverTest(unittest.TestCase):
     '''Test case for QObject.sender() method, this one tests the equality on the Receiver object.'''
 
     def testSenderPythonSignal(self):
-        sender = QObject()
+        sender = Sender()
         recv = Receiver()
-        QObject.connect(sender, SIGNAL('foo()'), recv.callback)
-        sender.emit(SIGNAL('foo()'))
+        sender.foo.connect(recv.callback)
+        sender.foo.emit()
         self.assertEqual(sender, recv.the_sender)
 
 
-class ObjectSenderWithQAppTest(UsesQCoreApplication):
+class ObjectSenderWithQAppTest(UsesQApplication):
     '''Test case for QObject.sender() method with QApplication.'''
 
     def testSenderCppSignal(self):
@@ -73,6 +77,12 @@ class ObjectSenderWithQAppTest(UsesQCoreApplication):
         self.app.exec()
         self.assertTrue(isinstance(recv.the_sender, QObject))
 
+    def testSenderCppSignalSingleShotTimerWithContext(self):
+        recv = Receiver()
+        QTimer.singleShot(10, recv, recv.callback)
+        self.app.exec()
+        self.assertTrue(isinstance(recv.the_sender, QObject))
+
     def testSenderCppSignalWithPythonExtendedClass(self):
         sender = ExtQTimer()
         recv = Receiver()
@@ -82,7 +92,7 @@ class ObjectSenderWithQAppTest(UsesQCoreApplication):
         self.assertEqual(sender, recv.the_sender)
 
 
-class ObjectSenderWithQAppCheckOnReceiverTest(UsesQCoreApplication):
+class ObjectSenderWithQAppCheckOnReceiverTest(UsesQApplication):
     '''Test case for QObject.sender() method with QApplication.'''
 
     def testSenderCppSignal(self):
@@ -105,4 +115,3 @@ class ObjectSenderWithQAppCheckOnReceiverTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/ref01_test.py b/sources/pyside6/tests/signals/ref01_test.py
index a830b55dd..1a62b2218 100644
--- a/sources/pyside6/tests/signals/ref01_test.py
+++ b/sources/pyside6/tests/signals/ref01_test.py
@@ -37,5 +37,3 @@ class BoundAndUnboundSignalsTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/pyside6/tests/signals/ref02_test.py b/sources/pyside6/tests/signals/ref02_test.py
index db456b35b..54b6f4a52 100644
--- a/sources/pyside6/tests/signals/ref02_test.py
+++ b/sources/pyside6/tests/signals/ref02_test.py
@@ -12,14 +12,14 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QCoreApplication, QTimeLine
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QTimeLine
+from helper.usesqapplication import UsesQApplication
 
 
-class NativeSignalsTest(UsesQCoreApplication):
+class NativeSignalsTest(UsesQApplication):
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.called = False
         self.timeline = QTimeLine(100)
 
@@ -28,7 +28,7 @@ class NativeSignalsTest(UsesQCoreApplication):
         del self.timeline
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testSignalWithIntArgument(self):
 
@@ -58,4 +58,3 @@ class NativeSignalsTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/ref03_test.py b/sources/pyside6/tests/signals/ref03_test.py
index 2df2d7cef..c43c2e549 100644
--- a/sources/pyside6/tests/signals/ref03_test.py
+++ b/sources/pyside6/tests/signals/ref03_test.py
@@ -40,4 +40,3 @@ class DisconnectSignalsTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/ref04_test.py b/sources/pyside6/tests/signals/ref04_test.py
index b478aff2a..fce801456 100644
--- a/sources/pyside6/tests/signals/ref04_test.py
+++ b/sources/pyside6/tests/signals/ref04_test.py
@@ -53,17 +53,6 @@ class UserSignalTest(unittest.TestCase):
         self.emitter.mySignal.emit()
         self.assertEqual(self.counter, 2)
 
-#    def testConnectWithConfigureMethod(self):
-#
-#        def slot():
-#            self.counter += 1
-#
-#        self.emitter.pyqtConfigure(mySignal=slot)
-#        self.assertEqual(self.counter, 0)
-#        self.emitter.mySignal.emit()
-#        self.assertEqual(self.counter, 1)
-
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/ref05_test.py b/sources/pyside6/tests/signals/ref05_test.py
index 13ab1ff65..fb9debf39 100644
--- a/sources/pyside6/tests/signals/ref05_test.py
+++ b/sources/pyside6/tests/signals/ref05_test.py
@@ -12,8 +12,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, QCoreApplication, QTimeLine, Slot
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QObject, QTimeLine, Slot
+from helper.usesqapplication import UsesQApplication
 
 
 class ExtQObject(QObject):
@@ -27,10 +27,10 @@ class ExtQObject(QObject):
         self.counter += 1
 
 
-class UserSlotTest(UsesQCoreApplication):
+class UserSlotTest(UsesQApplication):
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.receiver = ExtQObject()
         self.timeline = QTimeLine(100)
 
@@ -39,7 +39,7 @@ class UserSlotTest(UsesQCoreApplication):
         del self.receiver
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testUserSlot(self):
         self.timeline.setUpdateInterval(10)
@@ -56,4 +56,3 @@ class UserSlotTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/ref06_test.py b/sources/pyside6/tests/signals/ref06_test.py
index 56d54c1af..a827131db 100644
--- a/sources/pyside6/tests/signals/ref06_test.py
+++ b/sources/pyside6/tests/signals/ref06_test.py
@@ -12,8 +12,8 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, QCoreApplication, QTimeLine, Signal, Slot
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QObject, QTimeLine, Signal, Slot
+from helper.usesqapplication import UsesQApplication
 
 
 class ExtQObject(QObject):
@@ -28,10 +28,10 @@ class ExtQObject(QObject):
         self.counter += 1
 
 
-class SignaltoSignalTest(UsesQCoreApplication):
+class SignaltoSignalTest(UsesQApplication):
 
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self.receiver = ExtQObject()
         self.timeline = QTimeLine(100)
 
@@ -40,7 +40,7 @@ class SignaltoSignalTest(UsesQCoreApplication):
         del self.receiver
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     def testSignaltoSignal(self):
         self.timeline.setUpdateInterval(10)
@@ -59,4 +59,3 @@ class SignaltoSignalTest(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/segfault_proxyparent_test.py b/sources/pyside6/tests/signals/segfault_proxyparent_test.py
index c85ab10c0..cb0df0978 100644
--- a/sources/pyside6/tests/signals/segfault_proxyparent_test.py
+++ b/sources/pyside6/tests/signals/segfault_proxyparent_test.py
@@ -11,7 +11,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject, Signal
 
 # Description of the problem
 # After creating an PyObject that inherits from QObject, connecting it,
@@ -20,16 +20,19 @@ from PySide6.QtCore import QObject, SIGNAL
 
 # Somehow the underlying QObject also points to the same position.
 
-# In PyQt4, the connection works fine with the same memory behavior,
-# so it looks like specific to SIP.
 
+class Sender(QObject):
+
+    bar = Signal(int)
 
-class Dummy(QObject):
     def __init__(self, parent=None):
         QObject.__init__(self, parent)
 
 
 class Joe(QObject):
+
+    bar = Signal(int)
+
     def __init__(self, parent=None):
         QObject.__init__(self, parent)
 
@@ -44,7 +47,7 @@ class SegfaultCase(unittest.TestCase):
     def tearDown(self):
         try:
             del self.args
-        except:
+        except:  # noqa: E722
             pass
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
@@ -55,22 +58,21 @@ class SegfaultCase(unittest.TestCase):
 
     def testSegfault(self):
         """Regression: Segfault for qobjects in the same memory position."""
-        obj = Dummy()
-        QObject.connect(obj, SIGNAL('bar(int)'), self.callback)
+        obj = Sender()
+        obj.bar.connect(self.callback)
         self.args = (33,)
-        obj.emit(SIGNAL('bar(int)'), self.args[0])
+        obj.bar.emit(self.args[0])
         self.assertTrue(self.called)
         del obj
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
         obj = Joe()
-        QObject.connect(obj, SIGNAL('bar(int)'), self.callback)
+        obj.bar.connect(self.callback)
         self.args = (33,)
-        obj.emit(SIGNAL('bar(int)'), self.args[0])
+        obj.bar.emit(self.args[0])
         self.assertTrue(self.called)
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/self_connect_test.py b/sources/pyside6/tests/signals/self_connect_test.py
index d6c03db18..08ca725f8 100644
--- a/sources/pyside6/tests/signals/self_connect_test.py
+++ b/sources/pyside6/tests/signals/self_connect_test.py
@@ -13,17 +13,27 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT
+from PySide6.QtCore import QObject, Slot
 from PySide6.QtWidgets import QPushButton, QWidget
 
 from helper.usesqapplication import UsesQApplication
 
 
+class Receiver(QObject):
+    def __init__(self, p=None):
+        super().__init__(p)
+        self.triggered = False
+
+    @Slot(bool, int)
+    def default_parameter_slot(self, bool_value, int_value=0):
+        self.triggered = True
+
+
 class SelfConnect(UsesQApplication):
 
     def testButtonClickClose(self):
         button = QPushButton()
-        button.connect(button, SIGNAL('clicked()'), SLOT('close()'))
+        button.clicked.connect(button.close)
 
         button.show()
         self.assertTrue(button.isVisible())
@@ -33,13 +43,22 @@ class SelfConnect(UsesQApplication):
     def testWindowButtonClickClose(self):
         button = QPushButton()
         window = QWidget()
-        window.connect(button, SIGNAL('clicked()'), SLOT('close()'))
+        button.clicked.connect(window.close)
 
         window.show()
         self.assertTrue(window.isVisible())
         button.click()
         self.assertTrue(not window.isVisible())
 
+    def testDefaultParameters(self):
+        button = QPushButton()
+        receiver = Receiver(button)
+        button.clicked.connect(receiver.default_parameter_slot)
+        button.clicked.connect(button.close)
+        button.show()
+        button.click()
+        self.assertTrue(receiver.triggered)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside6/tests/signals/short_circuit_test.py b/sources/pyside6/tests/signals/short_circuit_test.py
index 434518336..1ad4bc24c 100644
--- a/sources/pyside6/tests/signals/short_circuit_test.py
+++ b/sources/pyside6/tests/signals/short_circuit_test.py
@@ -11,11 +11,17 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT
+from PySide6.QtCore import QObject, Signal
 
 
-class Dummy(QObject):
-    """Dummy class used in this test."""
+class Sender(QObject):
+    """Sender class used in this test."""
+
+    foo = Signal()
+    foo_int = Signal(int)
+    foo_int_int_string = Signal(int, int, str)
+    foo_int_qobject = Signal(int, QObject)
+
     def __init__(self, parent=None):
         QObject.__init__(self, parent)
 
@@ -27,7 +33,7 @@ class ShortCircuitSignals(unittest.TestCase):
     def tearDown(self):
         try:
             del self.args
-        except:
+        except:  # noqa: E722
             pass
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
@@ -38,40 +44,40 @@ class ShortCircuitSignals(unittest.TestCase):
 
     def testNoArgs(self):
         """Short circuit signal without arguments"""
-        obj1 = Dummy()
-        QObject.connect(obj1, SIGNAL('foo()'), self.callback)
+        obj1 = Sender()
+        obj1.foo.connect(self.callback)
         self.args = tuple()
-        obj1.emit(SIGNAL('foo()'), *self.args)
+        obj1.foo.emit(*self.args)
         self.assertTrue(self.called)
 
     def testWithArgs(self):
         """Short circuit signal with integer arguments"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo(int)'), self.callback)
+        obj1.foo_int.connect(self.callback)
         self.args = (42,)
-        obj1.emit(SIGNAL('foo(int)'), *self.args)
+        obj1.foo_int.emit(*self.args)
 
         self.assertTrue(self.called)
 
     def testMultipleArgs(self):
         """Short circuit signal with multiple arguments"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo(int,int,QString)'), self.callback)
+        obj1.foo_int_int_string.connect(self.callback)
         self.args = (42, 33, 'char')
-        obj1.emit(SIGNAL('foo(int,int,QString)'), *self.args)
+        obj1.foo_int_int_string.emit(*self.args)
 
         self.assertTrue(self.called)
 
     def testComplexArgs(self):
         """Short circuit signal with complex arguments"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo(int,QObject*)'), self.callback)
+        obj1.foo_int_qobject.connect(self.callback)
         self.args = (42, obj1)
-        obj1.emit(SIGNAL('foo(int,QObject*)'), *self.args)
 
+        obj1.foo_int_qobject.emit(*self.args)
         self.assertTrue(self.called)
 
 
diff --git a/sources/pyside6/tests/signals/signal2signal_connect_test.py b/sources/pyside6/tests/signals/signal2signal_connect_test.py
index c755a9dca..31129f7a1 100644
--- a/sources/pyside6/tests/signals/signal2signal_connect_test.py
+++ b/sources/pyside6/tests/signals/signal2signal_connect_test.py
@@ -13,7 +13,20 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject, Signal
+
+
+class Sender(QObject):
+
+    mysignal_int = Signal(int)
+    mysignal_int_int = Signal(int, int)
+    mysignal_string = Signal(str)
+
+
+class Forwarder(Sender):
+
+    forward = Signal()
+    forward_qobject = Signal(QObject)
 
 
 def cute_slot():
@@ -25,8 +38,8 @@ class TestSignal2SignalConnect(unittest.TestCase):
 
     def setUp(self):
         # Set up the basic resources needed
-        self.sender = QObject()
-        self.forwarder = QObject()
+        self.sender = Sender()
+        self.forwarder = Forwarder()
         self.args = None
         self.called = False
 
@@ -34,11 +47,11 @@ class TestSignal2SignalConnect(unittest.TestCase):
         # Delete used resources
         try:
             del self.sender
-        except:
+        except:  # noqa: E722
             pass
         try:
             del self.forwarder
-        except:
+        except:  # noqa: E722
             pass
         del self.args
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
@@ -63,47 +76,37 @@ class TestSignal2SignalConnect(unittest.TestCase):
             raise TypeError("Invalid arguments")
 
     def testSignalWithoutArguments(self):
-        QObject.connect(self.sender, SIGNAL("destroyed()"),
-                        self.forwarder, SIGNAL("forward()"))
-        QObject.connect(self.forwarder, SIGNAL("forward()"),
-                        self.callback_noargs)
+        self.sender.destroyed.connect(self.forwarder.forward)
+        self.forwarder.forward.connect(self.callback_noargs)
         del self.sender
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
         self.assertTrue(self.called)
 
     def testSignalWithOnePrimitiveTypeArgument(self):
-        QObject.connect(self.sender, SIGNAL("mysignal(int)"),
-                        self.forwarder, SIGNAL("mysignal(int)"))
-        QObject.connect(self.forwarder, SIGNAL("mysignal(int)"),
-                        self.callback_args)
+        self.sender.mysignal_int.connect(self.forwarder.mysignal_int)
+        self.forwarder.mysignal_int.connect(self.callback_args)
         self.args = (19,)
-        self.sender.emit(SIGNAL('mysignal(int)'), *self.args)
+        self.sender.mysignal_int.emit(*self.args)
         self.assertTrue(self.called)
 
     def testSignalWithMultiplePrimitiveTypeArguments(self):
-        QObject.connect(self.sender, SIGNAL("mysignal(int,int)"),
-                        self.forwarder, SIGNAL("mysignal(int,int)"))
-        QObject.connect(self.forwarder, SIGNAL("mysignal(int,int)"),
-                        self.callback_args)
+        self.sender.mysignal_int_int.connect(self.forwarder.mysignal_int_int)
+        self.forwarder.mysignal_int_int.connect(self.callback_args)
         self.args = (23, 29)
-        self.sender.emit(SIGNAL('mysignal(int,int)'), *self.args)
+        self.sender.mysignal_int_int.emit(*self.args)
         self.assertTrue(self.called)
 
     def testSignalWithOneStringArgument(self):
-        QObject.connect(self.sender, SIGNAL("mysignal(QString)"),
-                        self.forwarder, SIGNAL("mysignal(QString)"))
-        QObject.connect(self.forwarder, SIGNAL("mysignal(QString)"),
-                        self.callback_args)
+        self.sender.mysignal_string.connect(self.forwarder.mysignal_string)
+        self.forwarder.mysignal_string.connect(self.callback_args)
         self.args = ('myargument',)
-        self.sender.emit(SIGNAL('mysignal(QString)'), *self.args)
+        self.sender.mysignal_string.emit(*self.args)
         self.assertTrue(self.called)
 
     def testSignalWithOneQObjectArgument(self):
-        QObject.connect(self.sender, SIGNAL('destroyed(QObject*)'),
-                        self.forwarder, SIGNAL('forward(QObject*)'))
-        QObject.connect(self.forwarder, SIGNAL('forward(QObject*)'),
-                        self.callback_qobject)
+        self.sender.destroyed.connect(self.forwarder.forward_qobject)
+        self.forwarder.forward_qobject.connect(self.callback_qobject)
 
         obj_name = 'sender'
         self.sender.setObjectName(obj_name)
@@ -116,5 +119,3 @@ class TestSignal2SignalConnect(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/pyside6/tests/signals/signal_across_threads.py b/sources/pyside6/tests/signals/signal_across_threads.py
index ad4b806ed..91b1ca986 100644
--- a/sources/pyside6/tests/signals/signal_across_threads.py
+++ b/sources/pyside6/tests/signals/signal_across_threads.py
@@ -14,7 +14,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, QThread, QTimer, Slot
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class ReceiverBase(QObject):
@@ -39,9 +39,9 @@ class TestThread(QThread):
         pass
 
 
-class SignalAcrossThreads(UsesQCoreApplication):
+class SignalAcrossThreads(UsesQApplication):
     def setUp(self):
-        UsesQCoreApplication.setUp(self)
+        UsesQApplication.setUp(self)
         self._timer_tick = 0
         self._timer = QTimer()
         self._timer.setInterval(20)
@@ -49,7 +49,7 @@ class SignalAcrossThreads(UsesQCoreApplication):
         self._worker_thread = TestThread()
 
     def tearDown(self):
-        UsesQCoreApplication.tearDown(self)
+        UsesQApplication.tearDown(self)
 
     @Slot()
     def _control_test(self):
diff --git a/sources/pyside6/tests/signals/signal_autoconnect_test.py b/sources/pyside6/tests/signals/signal_autoconnect_test.py
index 820a77444..51d1cea3a 100644
--- a/sources/pyside6/tests/signals/signal_autoconnect_test.py
+++ b/sources/pyside6/tests/signals/signal_autoconnect_test.py
@@ -27,7 +27,7 @@ class MyObject(QWidget):
 class AutoConnectionTest(unittest.TestCase):
 
     def testConnection(self):
-        app = QApplication([])
+        app = QApplication([])  # noqa: F841
 
         win = MyObject()
         btn = QPushButton("click", win)
diff --git a/sources/pyside6/tests/signals/signal_connectiontype_support_test.py b/sources/pyside6/tests/signals/signal_connectiontype_support_test.py
index 95ce1fa4f..0a69c1e02 100644
--- a/sources/pyside6/tests/signals/signal_connectiontype_support_test.py
+++ b/sources/pyside6/tests/signals/signal_connectiontype_support_test.py
@@ -10,13 +10,16 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, Qt
+from PySide6.QtCore import QObject, Signal, Qt
 
 
-class Dummy(QObject):
+class Sender(QObject):
     """Dummy class used in this test."""
+
+    foo = Signal()
+
     def __init__(self, parent=None):
-        QObject.__init__(self, parent)
+        super().__init__(parent)
 
 
 class TestConnectionTypeSupport(unittest.TestCase):
@@ -26,11 +29,11 @@ class TestConnectionTypeSupport(unittest.TestCase):
 
     def testNoArgs(self):
         """Connect signal using a Qt.ConnectionType as argument"""
-        obj1 = Dummy()
+        obj1 = Sender()
 
-        QObject.connect(obj1, SIGNAL('foo()'), self.callback, Qt.DirectConnection)
+        obj1.foo.connect(self.callback, Qt.DirectConnection)
         self.args = tuple()
-        obj1.emit(SIGNAL('foo()'), *self.args)
+        obj1.foo.emit(*self.args)
 
         self.assertTrue(self.called)
 
diff --git a/sources/pyside6/tests/signals/signal_emission_gui_test.py b/sources/pyside6/tests/signals/signal_emission_gui_test.py
index aae96f236..5a49b9d12 100644
--- a/sources/pyside6/tests/signals/signal_emission_gui_test.py
+++ b/sources/pyside6/tests/signals/signal_emission_gui_test.py
@@ -14,112 +14,104 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT
-
-try:
-    from PySide6.QtWidgets import QSpinBox, QPushButton
-    hasQtGui = True
-except ImportError:
-    hasQtGui = False
+from PySide6.QtWidgets import QSpinBox, QPushButton
 
 from helper.basicpyslotcase import BasicPySlotCase
 from helper.usesqapplication import UsesQApplication
 
-if hasQtGui:
-    class ButtonPySlot(UsesQApplication, BasicPySlotCase):
-        """Tests the connection of python slots to QPushButton signals"""
-
-        def testButtonClicked(self):
-            """Connection of a python slot to QPushButton.clicked()"""
-            button = QPushButton('Mylabel')
-            button.clicked.connect(self.cb)
-            self.args = tuple()
-            button.emit(SIGNAL('clicked(bool)'), False)
-            self.assertTrue(self.called)
-
-        def testButtonClick(self):
-            """Indirect qt signal emission using the QPushButton.click() method """
-            button = QPushButton('label')
-            button.clicked.connect(self.cb)
-            self.args = tuple()
-            button.click()
-            self.assertTrue(self.called)
-
-
-if hasQtGui:
-    class SpinBoxPySlot(UsesQApplication, BasicPySlotCase):
-        """Tests the connection of python slots to QSpinBox signals"""
-
-        def setUp(self):
-            super(SpinBoxPySlot, self).setUp()
-            self.spin = QSpinBox()
-
-        def tearDown(self):
-            del self.spin
-            # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
-            gc.collect()
-            super(SpinBoxPySlot, self).tearDown()
-
-        def testSpinBoxValueChanged(self):
-            """Connection of a python slot to QSpinBox.valueChanged(int)"""
-            self.spin.valueChanged.connect(self.cb)
-            self.args = [3]
-            self.spin.emit(SIGNAL('valueChanged(int)'), *self.args)
-            self.assertTrue(self.called)
-
-        def testSpinBoxValueChangedImplicit(self):
-            """Indirect qt signal emission using QSpinBox.setValue(int)"""
-            self.spin.valueChanged.connect(self.cb)
-            self.args = [42]
-            self.spin.setValue(self.args[0])
-            self.assertTrue(self.called)
-
-        def atestSpinBoxValueChangedFewArgs(self):
-            """Emission of signals with fewer arguments than needed"""
-            # XXX: PyQt4 crashes on the assertRaises
-            self.spin.valueChanged.connect(self.cb)
-            self.args = (554,)
-            self.assertRaises(TypeError, self.spin.emit, SIGNAL('valueChanged(int)'))
-
-if hasQtGui:
-    class QSpinBoxQtSlots(UsesQApplication):
-        """Tests the connection to QSpinBox qt slots"""
-
-        qapplication = True
-
-        def testSetValueIndirect(self):
-            """Indirect signal emission: QSpinBox using valueChanged(int)/setValue(int)"""
-            spinSend = QSpinBox()
-            spinRec = QSpinBox()
-
-            spinRec.setValue(5)
-
-            spinSend.valueChanged.connect(spinRec.setValue)
-            self.assertEqual(spinRec.value(), 5)
-            spinSend.setValue(3)
-            self.assertEqual(spinRec.value(), 3)
-            self.assertEqual(spinSend.value(), 3)
-
-        def testSetValue(self):
-            """Direct signal emission: QSpinBox using valueChanged(int)/setValue(int)"""
-            spinSend = QSpinBox()
-            spinRec = QSpinBox()
-
-            spinRec.setValue(5)
-            spinSend.setValue(42)
-
-            spinSend.valueChanged.connect(spinRec.setValue)
-            self.assertEqual(spinRec.value(), 5)
-            self.assertEqual(spinSend.value(), 42)
-            spinSend.emit(SIGNAL('valueChanged(int)'), 3)
-
-            self.assertEqual(spinRec.value(), 3)
-            # Direct emission shouldn't change the value of the emitter
-            self.assertEqual(spinSend.value(), 42)
-
-            spinSend.emit(SIGNAL('valueChanged(int)'), 66)
-            self.assertEqual(spinRec.value(), 66)
-            self.assertEqual(spinSend.value(), 42)
+
+class ButtonPySlot(UsesQApplication, BasicPySlotCase):
+    """Tests the connection of python slots to QPushButton signals"""
+
+    def testButtonClicked(self):
+        """Connection of a python slot to QPushButton.clicked()"""
+        button = QPushButton('Mylabel')
+        button.clicked.connect(self.cb)
+        self.args = tuple()
+        button.clicked.emit()
+        self.assertTrue(self.called)
+
+    def testButtonClick(self):
+        """Indirect qt signal emission using the QPushButton.click() method """
+        button = QPushButton('label')
+        button.clicked.connect(self.cb)
+        self.args = tuple()
+        button.click()
+        self.assertTrue(self.called)
+
+
+class SpinBoxPySlot(UsesQApplication, BasicPySlotCase):
+    """Tests the connection of python slots to QSpinBox signals"""
+
+    def setUp(self):
+        super(SpinBoxPySlot, self).setUp()
+        self.spin = QSpinBox()
+
+    def tearDown(self):
+        del self.spin
+        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
+        gc.collect()
+        super(SpinBoxPySlot, self).tearDown()
+
+    def testSpinBoxValueChanged(self):
+        """Connection of a python slot to QSpinBox.valueChanged(int)"""
+        self.spin.valueChanged.connect(self.cb)
+        self.args = [3]
+        self.spin.valueChanged.emit(*self.args)
+        self.assertTrue(self.called)
+
+    def testSpinBoxValueChangedImplicit(self):
+        """Indirect qt signal emission using QSpinBox.setValue(int)"""
+        self.spin.valueChanged.connect(self.cb)
+        self.args = [42]
+        self.spin.setValue(self.args[0])
+        self.assertTrue(self.called)
+
+    def atestSpinBoxValueChangedFewArgs(self):
+        """Emission of signals with fewer arguments than needed"""
+        self.spin.valueChanged.connect(self.cb)
+        self.args = (554,)
+        self.assertRaises(TypeError, self.spin.valueChanged.emit)
+
+
+class QSpinBoxQtSlots(UsesQApplication):
+    """Tests the connection to QSpinBox qt slots"""
+
+    qapplication = True
+
+    def testSetValueIndirect(self):
+        """Indirect signal emission: QSpinBox using valueChanged(int)/setValue(int)"""
+        spinSend = QSpinBox()
+        spinRec = QSpinBox()
+
+        spinRec.setValue(5)
+
+        spinSend.valueChanged.connect(spinRec.setValue)
+        self.assertEqual(spinRec.value(), 5)
+        spinSend.setValue(3)
+        self.assertEqual(spinRec.value(), 3)
+        self.assertEqual(spinSend.value(), 3)
+
+    def testSetValue(self):
+        """Direct signal emission: QSpinBox using valueChanged(int)/setValue(int)"""
+        spinSend = QSpinBox()
+        spinRec = QSpinBox()
+
+        spinRec.setValue(5)
+        spinSend.setValue(42)
+
+        spinSend.valueChanged.connect(spinRec.setValue)
+        self.assertEqual(spinRec.value(), 5)
+        self.assertEqual(spinSend.value(), 42)
+        spinSend.valueChanged.emit(3)
+
+        self.assertEqual(spinRec.value(), 3)
+        # Direct emission shouldn't change the value of the emitter
+        self.assertEqual(spinSend.value(), 42)
+
+        spinSend.valueChanged.emit(66)
+        self.assertEqual(spinRec.value(), 66)
+        self.assertEqual(spinSend.value(), 42)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/signal_emission_test.py b/sources/pyside6/tests/signals/signal_emission_test.py
index 862a03faa..b31d89c2f 100644
--- a/sources/pyside6/tests/signals/signal_emission_test.py
+++ b/sources/pyside6/tests/signals/signal_emission_test.py
@@ -14,47 +14,47 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT, QProcess, QTimeLine
+from PySide6.QtCore import QObject, Signal, SIGNAL, QProcess, QTimeLine
 
-from helper.basicpyslotcase import BasicPySlotCase
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
-class ArgsOnEmptySignal(UsesQCoreApplication):
+class ArgsOnEmptySignal(UsesQApplication):
     '''Trying to emit a signal without arguments passing some arguments'''
 
     def testArgsToNoArgsSignal(self):
         '''Passing arguments to a signal without arguments'''
         process = QProcess()
-        self.assertRaises(TypeError, process.emit, SIGNAL('started()'), 42)
+        self.assertRaises(TypeError, process.started.emit, 42)
 
 
-class MoreArgsOnEmit(UsesQCoreApplication):
+class MoreArgsOnEmit(UsesQApplication):
     '''Trying to pass more args than needed to emit (signals with args)'''
 
     def testMoreArgs(self):
         '''Passing more arguments than needed'''
         process = QProcess()
-        self.assertRaises(TypeError, process.emit, SIGNAL('finished(int)'), 55, 55)
+        self.assertRaises(TypeError, process.finished.emit, 55, QProcess.ExitStatus.NormalExit, 42)
 
 
-class Dummy(QObject):
-    '''Dummy class'''
-    pass
+class Sender(QObject):
+    '''Sender class'''
 
+    dummy = Signal()
+    dummy_int = Signal(int)
 
-class PythonSignalToCppSlots(UsesQCoreApplication):
+
+class PythonSignalToCppSlots(UsesQApplication):
     '''Connect python signals to C++ slots'''
 
     def testWithoutArgs(self):
         '''Connect python signal to QTimeLine.toggleDirection()'''
         timeline = QTimeLine()
-        dummy = Dummy()
-        QObject.connect(dummy, SIGNAL('dummy()'),
-                        timeline, SLOT('toggleDirection()'))
+        sender = Sender()
+        sender.dummy.connect(timeline.toggleDirection)
 
         orig_dir = timeline.direction()
-        dummy.emit(SIGNAL('dummy()'))
+        sender.dummy.emit()
         new_dir = timeline.direction()
 
         if orig_dir == QTimeLine.Forward:
@@ -65,17 +65,16 @@ class PythonSignalToCppSlots(UsesQCoreApplication):
     def testWithArgs(self):
         '''Connect python signals to QTimeLine.setCurrentTime(int)'''
         timeline = QTimeLine()
-        dummy = Dummy()
+        sender = Sender()
 
-        QObject.connect(dummy, SIGNAL('dummy(int)'),
-                        timeline, SLOT('setCurrentTime(int)'))
+        sender.dummy_int.connect(timeline.setCurrentTime)
 
         current = timeline.currentTime()
-        dummy.emit(SIGNAL('dummy(int)'), current + 42)
+        sender.dummy_int.emit(current + 42)
         self.assertEqual(timeline.currentTime(), current + 42)
 
 
-class CppSignalsToCppSlots(UsesQCoreApplication):
+class CppSignalsToCppSlots(UsesQApplication):
     '''Connection between C++ slots and signals'''
 
     def testWithoutArgs(self):
@@ -83,13 +82,13 @@ class CppSignalsToCppSlots(UsesQCoreApplication):
         process = QProcess()
         timeline = QTimeLine()
 
-        QObject.connect(process, SIGNAL('finished(int, QProcess::ExitStatus)'),
-                        timeline, SLOT('toggleDirection()'))
+        process.finished.connect(timeline.toggleDirection)
 
         orig_dir = timeline.direction()
 
         process.start(sys.executable, ['-c', '"print 42"'])
-        process.waitForFinished()
+        self.assertTrue(process.waitForStarted())
+        self.assertTrue(process.waitForFinished())
 
         new_dir = timeline.direction()
 
@@ -107,25 +106,25 @@ def someSlot(args=None):
     called = True
 
 
-class DynamicSignalsToFuncPartial(UsesQCoreApplication):
+class DynamicSignalsToFuncPartial(UsesQApplication):
 
     def testIt(self):
         global called
         called = False
-        o = QObject()
-        o.connect(o, SIGNAL("ASignal()"), functools.partial(someSlot, "partial .."))
-        o.emit(SIGNAL("ASignal()"))
+        o = Sender()
+        o.dummy.connect(functools.partial(someSlot, "partial .."))
+        o.dummy.emit()
         self.assertTrue(called)
 
 
-class EmitUnknownType(UsesQCoreApplication):
+class EmitUnknownType(UsesQApplication):
     def testIt(self):
         a = QObject()
         a.connect(SIGNAL('foobar(Dummy)'), lambda x: 42)  # Just connect with an unknown type
         self.assertRaises(TypeError, a.emit, SIGNAL('foobar(Dummy)'), 22)
 
 
-class EmitEnum(UsesQCoreApplication):
+class EmitEnum(UsesQApplication):
     """Test emission of enum arguments"""
 
     def slot(self, arg):
diff --git a/sources/pyside6/tests/signals/signal_manager_refcount_test.py b/sources/pyside6/tests/signals/signal_manager_refcount_test.py
index 31d3bc85e..955d5b65b 100644
--- a/sources/pyside6/tests/signals/signal_manager_refcount_test.py
+++ b/sources/pyside6/tests/signals/signal_manager_refcount_test.py
@@ -12,11 +12,12 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL
+from PySide6.QtCore import QObject
 
 
 class SignalManagerRefCount(unittest.TestCase):
-    """Simple test case to check if the signal_manager is erroneously incrementing the object refcounter"""
+    """Simple test case to check if the signal_manager is erroneously incrementing the
+       object refcounter."""
 
     @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testObjectRefcount(self):
@@ -27,10 +28,9 @@ class SignalManagerRefCount(unittest.TestCase):
         refcount = sys.getrefcount(obj)
         obj.destroyed.connect(callback)
         self.assertEqual(refcount, sys.getrefcount(obj))
-        QObject.disconnect(obj, SIGNAL('destroyed()'), callback)
+        obj.destroyed.disconnect(callback)
         self.assertEqual(refcount, sys.getrefcount(obj))
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/signal_object_test.py b/sources/pyside6/tests/signals/signal_object_test.py
index 1f60b4c3a..607f51813 100644
--- a/sources/pyside6/tests/signals/signal_object_test.py
+++ b/sources/pyside6/tests/signals/signal_object_test.py
@@ -12,7 +12,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QTimer, Signal, QObject, Slot, Qt
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 class MyObject(QTimer):
@@ -37,7 +37,7 @@ class MyObject(QTimer):
         self._o = o
 
 
-class SignalObjectTest(UsesQCoreApplication):
+class SignalObjectTest(UsesQApplication):
     def cb(self):
         self._cb_called = True
         self.app.exit()
diff --git a/sources/pyside6/tests/signals/signal_signature_test.py b/sources/pyside6/tests/signals/signal_signature_test.py
index 7477f6243..e8f08b2d9 100644
--- a/sources/pyside6/tests/signals/signal_signature_test.py
+++ b/sources/pyside6/tests/signals/signal_signature_test.py
@@ -13,13 +13,17 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide6.QtCore import QObject, Signal, SIGNAL, SLOT
-from helper.usesqcoreapplication import UsesQCoreApplication
+from helper.usesqapplication import UsesQApplication
 
 
 called = False
 name = "Old"
 
 
+class Sender(QObject):
+    dummySignal = Signal()
+
+
 class Obj(QObject):
     dummySignalArgs = Signal(str)
     numberSignal = Signal(int)
@@ -50,7 +54,7 @@ def callback_empty():
     pass
 
 
-class TestConnectNotifyWithNewStyleSignals(UsesQCoreApplication):
+class TestConnectNotifyWithNewStyleSignals(UsesQApplication):
     '''Test case for signal signature received by QObject::connectNotify().'''
 
     def testOldStyle(self):
@@ -78,9 +82,9 @@ class TestConnectNotifyWithNewStyleSignals(UsesQCoreApplication):
 
     def testStaticSlot(self):
         global called
-        sender = Obj()
-        sender.connect(sender, SIGNAL("dummySignal()"), Obj.static_method)
-        sender.emit(SIGNAL("dummySignal()"))
+        sender = Sender()
+        sender.dummySignal.connect(Obj.static_method)
+        sender.dummySignal.emit()
         self.assertTrue(called)
 
     def testStaticSlotArgs(self):
@@ -99,4 +103,3 @@ class TestConnectNotifyWithNewStyleSignals(UsesQCoreApplication):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/sources/pyside6/tests/signals/signal_with_primitive_type_test.py b/sources/pyside6/tests/signals/signal_with_primitive_type_test.py
index a4d5f33a7..01492b333 100644
--- a/sources/pyside6/tests/signals/signal_with_primitive_type_test.py
+++ b/sources/pyside6/tests/signals/signal_with_primitive_type_test.py
@@ -10,7 +10,7 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QCoreApplication, QObject, QTimeLine, SIGNAL
+from PySide6.QtCore import QCoreApplication, QTimeLine
 
 
 class SignalPrimitiveTypeTest(unittest.TestCase):
@@ -36,5 +36,3 @@ class SignalPrimitiveTypeTest(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
-
-
diff --git a/sources/pyside6/tests/signals/signals.pyproject b/sources/pyside6/tests/signals/signals.pyproject
new file mode 100644
index 000000000..b63724eaf
--- /dev/null
+++ b/sources/pyside6/tests/signals/signals.pyproject
@@ -0,0 +1,19 @@
+{
+    "files": ["anonymous_slot_leak_test.py", "args_dont_match_test.py",
+              "bug_189.py", "bug_311.py", "bug_312.py", "bug_319.py", "bug_79.py",
+              "decorators_test.py", "disconnect_test.py", "invalid_callback_test.py",
+              "lambda_gui_test.py", "lambda_test.py", "leaking_signal_test.py",
+              "multiple_connections_gui_test.py", "multiple_connections_test.py",
+              "pysignal_test.py", "qobject_callable_connect_test.py", "qobject_destroyed_test.py",
+              "qobject_receivers_test.py", "qobject_sender_test.py", "ref01_test.py",
+              "ref02_test.py", "ref03_test.py", "ref04_test.py", "ref05_test.py",
+              "ref06_test.py", "segfault_proxyparent_test.py",
+              "self_connect_test.py", "short_circuit_test.py",
+              "signal2signal_connect_test.py", "signal_across_threads.py",
+              "signal_autoconnect_test.py", "signal_connectiontype_support_test.py",
+              "signal_emission_gui_test.py", "signal_emission_test.py",
+              "signal_enum_test.py", "signal_func_test.py", "signal_manager_refcount_test.py",
+              "signal_newenum_test.py", "signal_number_limit_test.py",
+              "signal_object_test.py", "signal_signature_test.py", "signal_with_primitive_type_test.py",
+              "slot_reference_count_test.py", "static_metaobject_test.py"]
+}
diff --git a/sources/pyside6/tests/signals/slot_reference_count_test.py b/sources/pyside6/tests/signals/slot_reference_count_test.py
index 10a40597e..9d5c73652 100644
--- a/sources/pyside6/tests/signals/slot_reference_count_test.py
+++ b/sources/pyside6/tests/signals/slot_reference_count_test.py
@@ -12,12 +12,14 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, SLOT
+from PySide6.QtCore import QObject, Signal
 
 
 class Dummy(QObject):
+    foo = Signal()
+
     def dispatch(self):
-        self.emit(SIGNAL('foo()'))
+        self.foo.emit()
 
 
 class PythonSignalRefCount(unittest.TestCase):
@@ -35,10 +37,10 @@ class PythonSignalRefCount(unittest.TestCase):
 
         self.assertEqual(sys.getrefcount(cb), 2)
 
-        QObject.connect(self.emitter, SIGNAL('foo()'), cb)
+        self.emitter.foo.connect(cb)
         self.assertEqual(sys.getrefcount(cb), 3)
 
-        QObject.disconnect(self.emitter, SIGNAL('foo()'), cb)
+        self.emitter.foo.disconnect(cb)
         self.assertEqual(sys.getrefcount(cb), 2)
 
 
@@ -60,7 +62,7 @@ class CppSignalRefCount(unittest.TestCase):
         self.emitter.destroyed.connect(cb)
         self.assertEqual(sys.getrefcount(cb), 3)
 
-        QObject.disconnect(self.emitter, SIGNAL('destroyed()'), cb)
+        self.emitter.destroyed.disconnect(cb)
         self.assertEqual(sys.getrefcount(cb), 2)
 
 
diff --git a/sources/pyside6/tests/signals/static_metaobject_test.py b/sources/pyside6/tests/signals/static_metaobject_test.py
index 44d10cd7d..d7bf73e44 100644
--- a/sources/pyside6/tests/signals/static_metaobject_test.py
+++ b/sources/pyside6/tests/signals/static_metaobject_test.py
@@ -14,13 +14,22 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from PySide6.QtCore import QObject, SIGNAL, Slot
-from helper.usesqcoreapplication import UsesQCoreApplication
+from PySide6.QtCore import QObject, Signal, Slot, SIGNAL
+from helper.usesqapplication import UsesQApplication
+
+
+class Sender(QObject):
+
+    foo = Signal()
+    foo2 = Signal()
 
 
 class MyObject(QObject):
+
+    foo2 = Signal()
+
     def __init__(self, parent=None):
-        QObject.__init__(self, parent)
+        super().__init__(parent)
         self._slotCalledCount = 0
 
     # this '@Slot()' is needed to get the right sort order in testSharedSignalEmission.
@@ -30,10 +39,11 @@ class MyObject(QObject):
         self._slotCalledCount = self._slotCalledCount + 1
 
 
-class StaticMetaObjectTest(UsesQCoreApplication):
+class StaticMetaObjectTest(UsesQApplication):
 
     def testSignalPropagation(self):
-        o = MyObject()
+        """Old style, dynamic signal creation."""
+        o = QObject()
         o2 = MyObject()
 
         # SIGNAL foo not created yet
@@ -55,17 +65,17 @@ class StaticMetaObjectTest(UsesQCoreApplication):
         self.assertEqual(o.metaObject().indexOfSignal("foo()"), -1)
 
     def testSharedSignalEmission(self):
-        o = QObject()
+        o = Sender()
         m = MyObject()
 
-        o.connect(SIGNAL("foo2()"), m.mySlot)
-        m.connect(SIGNAL("foo2()"), m.mySlot)
-        o.emit(SIGNAL("foo2()"))
+        o.foo2.connect(m.mySlot)
+        m.foo2.connect(m.mySlot)
+        o.foo2.emit()
         self.assertEqual(m._slotCalledCount, 1)
         del o
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        m.emit(SIGNAL("foo2()"))
+        m.foo2.emit()
         self.assertEqual(m._slotCalledCount, 2)
 
 
diff --git a/sources/pyside6/tests/tools/list-class-hierarchy.py b/sources/pyside6/tests/tools/list-class-hierarchy.py
index f6c20ee2e..b773b7c58 100644
--- a/sources/pyside6/tests/tools/list-class-hierarchy.py
+++ b/sources/pyside6/tests/tools/list-class-hierarchy.py
@@ -19,8 +19,7 @@ from inspect import isclass
 ignore = ["staticMetaObject",
           "pyqtConfigure",
           "registerUserData",
-          "thread",
-         ]
+          "thread"]
 
 
 def recurse_into(el, obj):
@@ -47,7 +46,7 @@ def recurse_into(el, obj):
     return symbols
 
 
-if __name__=='__main__':
+if __name__ == '__main__':
     modules = [ 'QtCore',
                 'QtGui',
                 'QtHelp',
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_birthdayparty.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_birthdayparty.json
deleted file mode 100644
index ceddbab32..000000000
--- a/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_birthdayparty.json
+++ /dev/null
@@ -1 +0,0 @@
-[{"classes": [{"className": "BirthdayParty", "qualifiedClassName": "BirthdayParty", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}], "properties": [{"name": "host", "type": "Person", "index": 0, "read": "host", "write": "host"}, {"name": "guests", "type": "QQmlListProperty<Person>", "index": 1}]}], "outputRevision": 68, "QML_IMPORT_NAME": "examples.coercion.people", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_person.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_person.json
deleted file mode 100644
index 8b414b5a2..000000000
--- a/sources/pyside6/tests/tools/metaobjectdump/baseline_coercion_person.json
+++ /dev/null
@@ -1 +0,0 @@
-[{"classes": [{"className": "Person", "qualifiedClassName": "Person", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}, {"name": "QML.Creatable", "value": "false"}, {"name": "QML.UncreatableReason", "value": "Person is an abstract base class."}], "properties": [{"name": "name", "type": "QString", "index": 0, "read": "name", "write": "name"}, {"name": "shoe_size", "type": "int", "index": 1, "read": "shoe_size", "write": "shoe_size"}]}, {"className": "Boy", "qualifiedClassName": "Boy", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}, {"className": "Girl", "qualifiedClassName": "Girl", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "examples.coercion.people", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_default_birthdayparty.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_default_birthdayparty.json
index 96335feb9..6a695dd5c 100644
--- a/sources/pyside6/tests/tools/metaobjectdump/baseline_default_birthdayparty.json
+++ b/sources/pyside6/tests/tools/metaobjectdump/baseline_default_birthdayparty.json
@@ -1 +1 @@
-[{"classes": [{"className": "BirthdayParty", "qualifiedClassName": "BirthdayParty", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}, {"name": "DefaultProperty", "value": "guests"}], "properties": [{"name": "host", "type": "Person", "index": 0, "read": "host", "write": "host"}, {"name": "guests", "type": "QQmlListProperty<Person>", "index": 1}]}], "outputRevision": 68, "QML_IMPORT_NAME": "examples.default.people", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
+[{"classes": [{"className": "BirthdayParty", "qualifiedClassName": "BirthdayParty", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}, {"name": "DefaultProperty", "value": "guests"}], "properties": [{"name": "host", "type": "Person", "index": 0, "read": "host", "notify": "host_changed", "write": "host"}, {"name": "guests", "type": "QQmlListProperty<Person>", "index": 1}], "signals": [{"access": "public", "name": "host_changed", "arguments": [], "returnType": "void"}, {"access": "public", "name": "guests_changed", "arguments": [], "returnType": "void"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "People", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_default_person.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_default_person.json
index 1b3a15275..571056c2a 100644
--- a/sources/pyside6/tests/tools/metaobjectdump/baseline_default_person.json
+++ b/sources/pyside6/tests/tools/metaobjectdump/baseline_default_person.json
@@ -1 +1 @@
-[{"classes": [{"className": "Person", "qualifiedClassName": "Person", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "anonymous"}], "properties": [{"name": "name", "type": "QString", "index": 0, "read": "name", "write": "name"}, {"name": "shoe_size", "type": "int", "index": 1, "read": "shoe_size", "write": "shoe_size"}]}, {"className": "Boy", "qualifiedClassName": "Boy", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}, {"className": "Girl", "qualifiedClassName": "Girl", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "examples.default.people", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
+[{"classes": [{"className": "Person", "qualifiedClassName": "Person", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "anonymous"}], "properties": [{"name": "name", "type": "QString", "index": 0, "read": "name", "notify": "name_changed", "write": "name"}, {"name": "shoe_size", "type": "int", "index": 1, "read": "shoe_size", "notify": "shoe_size_changed", "write": "shoe_size"}], "signals": [{"access": "public", "name": "name_changed", "arguments": [], "returnType": "void"}, {"access": "public", "name": "shoe_size_changed", "arguments": [], "returnType": "void"}]}, {"className": "Boy", "qualifiedClassName": "Boy", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}, {"className": "Girl", "qualifiedClassName": "Girl", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "People", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_birthdayparty.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_birthdayparty.json
new file mode 100644
index 000000000..0491e41cc
--- /dev/null
+++ b/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_birthdayparty.json
@@ -0,0 +1 @@
+[{"classes": [{"className": "BirthdayParty", "qualifiedClassName": "BirthdayParty", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}], "properties": [{"name": "host", "type": "Person", "index": 0, "read": "host", "notify": "host_changed", "write": "host"}, {"name": "guests", "type": "QQmlListProperty<Person>", "index": 1}], "signals": [{"access": "public", "name": "host_changed", "arguments": [], "returnType": "void"}, {"access": "public", "name": "guests_changed", "arguments": [], "returnType": "void"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "People", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_person.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_person.json
new file mode 100644
index 000000000..82021ee0a
--- /dev/null
+++ b/sources/pyside6/tests/tools/metaobjectdump/baseline_inheritance_person.json
@@ -0,0 +1 @@
+[{"classes": [{"className": "Person", "qualifiedClassName": "Person", "object": true, "superClasses": [{"access": "public", "name": "QObject"}], "classInfos": [{"name": "QML.Element", "value": "auto"}, {"name": "QML.Creatable", "value": "false"}, {"name": "QML.UncreatableReason", "value": "Person is an abstract base class."}], "properties": [{"name": "name", "type": "QString", "index": 0, "read": "name", "notify": "name_changed", "write": "name"}, {"name": "shoe_size", "type": "int", "index": 1, "read": "shoe_size", "notify": "shoe_size_changed", "write": "shoe_size"}], "signals": [{"access": "public", "name": "name_changed", "arguments": [], "returnType": "void"}, {"access": "public", "name": "shoe_size_changed", "arguments": [], "returnType": "void"}]}, {"className": "Boy", "qualifiedClassName": "Boy", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}, {"className": "Girl", "qualifiedClassName": "Girl", "object": true, "superClasses": [{"access": "public", "name": "Person"}], "classInfos": [{"name": "QML.Element", "value": "auto"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "People", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/baseline_property_happybirthdaysong.json b/sources/pyside6/tests/tools/metaobjectdump/baseline_property_happybirthdaysong.json
new file mode 100644
index 000000000..c009111b7
--- /dev/null
+++ b/sources/pyside6/tests/tools/metaobjectdump/baseline_property_happybirthdaysong.json
@@ -0,0 +1 @@
+[{"classes": [{"className": "HappyBirthdaySong", "qualifiedClassName": "HappyBirthdaySong", "object": false, "superClasses": [{"access": "public", "name": "QPyQmlPropertyValueSource"}], "classInfos": [{"name": "QML.Element", "value": "auto"}], "properties": [{"name": "name", "type": "QString", "index": 0, "read": "name", "notify": "name_changed", "write": "name"}], "signals": [{"access": "public", "name": "name_changed", "arguments": [], "returnType": "void"}], "slots": [{"access": "public", "name": "advance", "arguments": [], "returnType": "void"}]}], "outputRevision": 68, "QML_IMPORT_NAME": "People", "QML_IMPORT_MAJOR_VERSION": 1, "QML_IMPORT_MINOR_VERSION": 0, "QT_MODULES": ["QtCore", "QtQml"]}]
\ No newline at end of file
diff --git a/sources/pyside6/tests/tools/metaobjectdump/test_metaobjectdump.py b/sources/pyside6/tests/tools/metaobjectdump/test_metaobjectdump.py
index 64aa05c8a..5e7412bf5 100644
--- a/sources/pyside6/tests/tools/metaobjectdump/test_metaobjectdump.py
+++ b/sources/pyside6/tests/tools/metaobjectdump/test_metaobjectdump.py
@@ -30,20 +30,25 @@ class TestMetaObjectDump(unittest.TestCase):
         pyside_root = self._dir.parents[4]
         self._metaobjectdump_tool = pyside_root / "sources" / "pyside-tools" / "metaobjectdump.py"
         self._examples_dir = (pyside_root / "examples" /
-                              "qml" / "referenceexamples")
+                              "qml" / "tutorials" / "extending-qml-advanced")
 
         # Compile a list of examples (tuple [file, base line, command])
         examples = []
-        for d in ["coercion", "default"]:
+        for d in ["advanced2-Inheritance-and-coercion", "advanced3-Default-properties"]:
             example_dir = self._examples_dir / d
             examples.append(example_dir / "birthdayparty.py")
             examples.append(example_dir / "person.py")
+        # Example with slot
+        examples.append(self._examples_dir / "advanced6-Property-value-source"
+                        / "happybirthdaysong.py")
 
         metaobjectdump_cmd_root = [sys.executable, os.fspath(self._metaobjectdump_tool), "-c", "-s"]
         self._examples = []
         for example in examples:
             name = example.parent.name
-            baseline_name = f"baseline_{name}_{example.stem}.json"
+            # Simplify "advanced2-Inheritance-and-coercion" -> "inheritance"
+            short_name = name.split("-")[1].lower()
+            baseline_name = f"baseline_{short_name}_{example.stem}.json"
             baseline_path = self._dir / baseline_name
             cmd = metaobjectdump_cmd_root + [os.fspath(example)]
             self._examples.append((example, baseline_path, cmd))
diff --git a/sources/pyside6/tests/tools/pyside6-android-deploy/CMakeLists.txt b/sources/pyside6/tests/tools/pyside6-android-deploy/CMakeLists.txt
new file mode 100644
index 000000000..c32d636ed
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-android-deploy/CMakeLists.txt
@@ -0,0 +1,3 @@
+if(CMAKE_HOST_UNIX)
+    PYSIDE_TEST(test_pyside6_android_deploy.py)
+endif()
diff --git a/sources/pyside6/tests/tools/pyside6-android-deploy/extensive_android_deploy_test.py b/sources/pyside6/tests/tools/pyside6-android-deploy/extensive_android_deploy_test.py
new file mode 100644
index 000000000..271f8eebd
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-android-deploy/extensive_android_deploy_test.py
@@ -0,0 +1,88 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+"""
+    Extensive manual test of pyside6-android-deploy
+
+    Note: Not to be added into the CI
+"""
+
+import logging
+import unittest
+import tempfile
+import shutil
+import sys
+import os
+import importlib
+from pathlib import Path
+
+
+class TestPySide6Deploy(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.pyside_root = Path(__file__).parents[5].resolve()
+        example_root = cls.pyside_root / "examples"
+        example_application = example_root / "gui" / "analogclock"
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.temp_example = Path(
+            shutil.copytree(example_application, Path(cls.temp_dir) / "analogclock")
+        ).resolve()
+        cls.current_dir = Path.cwd()
+
+        sys.path.append(str(cls.pyside_root / "sources" / "pyside-tools"))
+        cls.deploy_lib = importlib.import_module("deploy_lib")
+        cls.android_deploy = importlib.import_module("android_deploy")
+        sys.modules["android_deploy"] = cls.android_deploy
+
+        if os.environ.get("WHEEL_PYSIDE") is not None:
+            cls.pyside_wheel = Path(os.environ.get("WHEEL_PYSIDE")).resolve()
+        else:
+            raise Exception("Environment variable WHEEL_PYSIDE does not exist")
+
+        if os.environ.get("WHEEL_SHIBOKEN") is not None:
+            cls.shiboken_wheel = Path(os.environ.get("WHEEL_SHIBOKEN")).resolve()
+        else:
+            raise Exception("Environment variable WHEEL_SHIBOKEN does not exist")
+
+    def setUp(self):
+        os.chdir(self.temp_example)
+        self.config_file = self.temp_example / "pysidedeploy.spec"
+
+    def testDeployment(self):
+        self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                 pyside_wheel=self.pyside_wheel, keep_deployment_files=True,
+                                 loglevel=logging.INFO, force=True)
+
+        print("Testing with config file")
+        self.android_deploy.main(name="android_app", config_file=self.config_file,
+                                 loglevel=logging.INFO, force=True)
+
+    def testWithNdkSdk(self):
+        if os.environ.get("ANDROID_SDK_ROOT") is not None:
+            android_sdk_root = Path(os.environ.get("ANDROID_SDK_ROOT")).resolve()
+        else:
+            raise Exception("Environment variable ANDROID_SDK_ROOT does not exist")
+
+        if os.environ.get("ANDROID_NDK_ROOT") is not None:
+            android_ndk_root = Path(os.environ.get("ANDROID_NDK_ROOT")).resolve()
+        else:
+            raise Exception("Environment variable ANDROID_NDK_ROOT does not exist")
+
+        self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                 pyside_wheel=self.pyside_wheel,
+                                 ndk_path=android_ndk_root,
+                                 sdk_path=android_sdk_root,
+                                 keep_deployment_files=True,
+                                 loglevel=logging.INFO, force=True)
+
+    def tearDown(self) -> None:
+        super().tearDown()
+        os.chdir(self.current_dir)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        shutil.rmtree(Path(cls.temp_dir))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/tools/pyside6-android-deploy/test_pyside6_android_deploy.py b/sources/pyside6/tests/tools/pyside6-android-deploy/test_pyside6_android_deploy.py
new file mode 100644
index 000000000..ec575e923
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-android-deploy/test_pyside6_android_deploy.py
@@ -0,0 +1,274 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+import importlib
+import os
+import re
+import shutil
+import sys
+import tempfile
+import unittest
+import subprocess
+from pathlib import Path
+from unittest import mock
+from unittest.mock import patch
+
+sys.path.append(os.fspath(Path(__file__).resolve().parents[2]))
+from init_paths import init_test_paths  # noqa: E402
+init_test_paths(False)
+
+
+class DeployTestBase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.pyside_root = Path(__file__).parents[5].resolve()
+        cls.example_root = cls.pyside_root / "examples"
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.current_dir = Path.cwd()
+        cls.pyside_wheel = Path("/tmp/PySide6-6.5.0a1-6.5.0-cp37-abi3-android_x86_64.whl")
+        cls.shiboken_wheel = Path("/tmp/shiboken6-6.5.0a1-6.5.0-cp37-abi3-android_x86_64.whl")
+        cls.ndk_path = Path("/tmp/android_sdk/ndk/25.2.9519653")
+        cls.sdk_path = Path("/tmp/android_sdk")
+        pyside_tools = cls.pyside_root / "sources" / "pyside-tools"
+
+        # install extra python dependencies
+        android_requirements_file = pyside_tools / "requirements-android.txt"
+        with open(android_requirements_file, 'r', encoding='UTF-8') as file:
+            while line := file.readline():
+                dependent_package = line.rstrip()
+                if not bool(importlib.util.find_spec(dependent_package)):
+                    command = [sys.executable, "-m", "pip", "install", dependent_package]
+                    subprocess.run(command)
+
+        sys.path.append(str(pyside_tools))
+        cls.deploy_lib = importlib.import_module("deploy_lib")
+        cls.android_deploy = importlib.import_module("android_deploy")
+        sys.modules["android_deploy"] = cls.android_deploy
+
+        # required for comparing long strings
+        cls.maxDiff = None
+
+        # print no outputs to stdout
+        sys.stdout = mock.MagicMock()
+
+    def tearDown(self) -> None:
+        super().tearDown()
+        os.chdir(self.current_dir)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        shutil.rmtree(Path(cls.temp_dir))
+
+
+@patch("deploy_lib.android.android_config.extract_and_copy_jar")
+class TestPySide6AndroidDeployWidgets(DeployTestBase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        example_widget_application = cls.example_root / "gui" / "analogclock"
+        cls.temp_example = Path(
+            shutil.copytree(example_widget_application, Path(cls.temp_dir) / "analogclock")
+        ).resolve()
+
+    def setUp(self):
+        os.chdir(self.temp_example)
+        self.config_file = self.temp_example / "pysidedeploy.spec"
+        self.buildozer_config = self.temp_example / "buildozer.spec"
+
+    @patch("deploy_lib.android.android_config.AndroidConfig._find_local_libs")
+    @patch("deploy_lib.android.android_config.AndroidConfig._find_dependent_qt_modules")
+    @patch("deploy_lib.android.android_config.find_qtlibs_in_wheel")
+    def test_dry_run(self, mock_qtlibs, mock_extraqtmodules, mock_local_libs, mock_extract_jar):
+        mock_qtlibs.return_value = self.pyside_wheel / "PySide6/Qt/lib"
+        mock_extraqtmodules.return_value = []
+        dependent_plugins = ["platforms_qtforandroid",
+                             "platforminputcontexts_qtvirtualkeyboardplugin",
+                             "iconengines_qsvgicon"]
+        mock_local_libs.return_value = [], dependent_plugins
+        self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                 pyside_wheel=self.pyside_wheel, ndk_path=self.ndk_path,
+                                 dry_run=True, force=True)
+
+        self.assertEqual(mock_extract_jar.call_count, 0)
+        self.assertEqual(mock_qtlibs.call_count, 1)
+        self.assertEqual(mock_extraqtmodules.call_count, 1)
+        self.assertEqual(mock_local_libs.call_count, 1)
+
+    @patch("deploy_lib.android.buildozer.BuildozerConfig._BuildozerConfig__find_jars")
+    @patch("deploy_lib.android.android_config.AndroidConfig.recipes_exist")
+    @patch("deploy_lib.android.android_config.AndroidConfig._find_dependent_qt_modules")
+    @patch("deploy_lib.android.android_config.find_qtlibs_in_wheel")
+    def test_config(self, mock_qtlibs, mock_extraqtmodules, mock_recipes_exist, mock_find_jars,
+                    mock_extract_jar):
+        jar_dir = "tmp/jar/PySide6/jar"
+        mock_extract_jar.return_value = Path(jar_dir)
+        mock_qtlibs.return_value = self.pyside_wheel / "PySide6/Qt/lib"
+        mock_extraqtmodules.return_value = []
+        mock_recipes_exist.return_value = True
+        jars, init_classes = ["/tmp/jar/PySide6/jar/Qt6Android.jar",
+                              "/tmp/jar/PySide6/jar/Qt6AndroidBindings.jar"], []
+        mock_find_jars.return_value = jars, init_classes
+
+        self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                 pyside_wheel=self.pyside_wheel, ndk_path=self.ndk_path,
+                                 init=True, force=True, keep_deployment_files=True)
+
+        self.assertEqual(mock_extract_jar.call_count, 1)
+        self.assertEqual(mock_qtlibs.call_count, 1)
+        self.assertEqual(mock_extraqtmodules.call_count, 1)
+        self.assertEqual(mock_recipes_exist.call_count, 1)
+        self.assertEqual(mock_find_jars.call_count, 1)
+        self.assertTrue(self.config_file.exists())
+        self.assertTrue(self.buildozer_config.exists())
+
+        # test config file contents
+        config_obj = self.deploy_lib.BaseConfig(config_file=self.config_file)
+        self.assertEqual(config_obj.get_value("app", "input_file"), "main.py")
+        self.assertEqual(config_obj.get_value("python", "android_packages"),
+                         "buildozer==1.5.0,cython==0.29.33")
+        self.assertEqual(config_obj.get_value("android", "wheel_pyside"),
+                         str(self.pyside_wheel.resolve()))
+        self.assertEqual(config_obj.get_value("android", "wheel_shiboken"),
+                         str(self.shiboken_wheel.resolve()))
+        self.assertEqual(config_obj.get_value("buildozer", "mode"), "debug")
+        self.assertEqual(config_obj.get_value("buildozer", "recipe_dir"),
+                         '')
+        self.assertEqual(config_obj.get_value("buildozer", "jars_dir"),
+                         str(self.temp_example / jar_dir))
+        self.assertIn(str(self.ndk_path), config_obj.get_value("buildozer", "ndk_path"))
+        self.assertEqual(config_obj.get_value("buildozer", "sdk_path"), '')
+        expected_modules = {"Core", "Gui"}
+        obtained_modules = set(config_obj.get_value("qt", "modules").split(","))
+        self.assertEqual(obtained_modules, expected_modules)
+        expected_local_libs = ""
+        self.assertEqual(config_obj.get_value("buildozer", "local_libs"),
+                         expected_local_libs)
+        self.assertEqual(config_obj.get_value("buildozer", "arch"), "x86_64")
+
+        # test buildozer config file contents
+        buildozer_config_obj = self.deploy_lib.BaseConfig(config_file=self.buildozer_config)
+        obtained_jars = set(buildozer_config_obj.get_value("app", "android.add_jars").split(','))
+        expected_jars = set(jars)
+        self.assertEqual(obtained_jars, expected_jars)
+        obtained_extra_args = buildozer_config_obj.get_value("app", "p4a.extra_args")
+        extra_args_patrn = re.compile("--qt-libs=(?P<modules>.*) --load-local-libs="
+                                      "(?P<local_libs>.*) --init-classes=(?P<init_classes>.*)")
+        match = extra_args_patrn.search(obtained_extra_args)
+        obtained_modules = match.group("modules").split(',')
+        obtained_local_libs = match.group("local_libs")
+        obtained_init_classes = match.group("init_classes")
+        self.assertEqual(set(obtained_modules), expected_modules)
+        self.assertEqual(obtained_local_libs, expected_local_libs)
+        self.assertEqual(obtained_init_classes, '')
+        expected_include_exts = "py,png,jpg,kv,atlas,qml,js"
+        obtained_include_exts = buildozer_config_obj.get_value("app", "source.include_exts")
+        self.assertEqual(expected_include_exts, obtained_include_exts)
+
+        self.config_file.unlink()
+        self.buildozer_config.unlink()
+
+    def test_errors(self, mock_extract_jar):
+        # test if error raises for non existing NDK
+        with self.assertRaises(FileNotFoundError) as context:
+            self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                     pyside_wheel=self.pyside_wheel, force=True)
+        self.assertTrue("Unable to find Android NDK" in str(context.exception))
+
+        # test when cwd() is not project_dir
+        os.chdir(self.current_dir)
+        with self.assertRaises(RuntimeError) as context:
+            self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                     pyside_wheel=self.pyside_wheel, init=True, force=True)
+        self.assertTrue("For Android deployment to work" in str(context.exception))
+
+
+@patch("deploy_lib.config.run_qmlimportscanner")
+@patch("deploy_lib.android.android_config.extract_and_copy_jar")
+class TestPySide6AndroidDeployQml(DeployTestBase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # setting up example
+        example_qml_application = cls.example_root / "quick" / "models" / "stringlistmodel"
+        cls.temp_qml_example = Path(
+            shutil.copytree(example_qml_application, Path(cls.temp_dir) / "stringlistmodel")
+        ).resolve()
+
+    def setUp(self):
+        os.chdir(self.temp_qml_example)
+        self.config_file = self.temp_qml_example / "pysidedeploy.spec"
+        self.buildozer_config_file = self.temp_qml_example / "buildozer.spec"
+        (self.temp_qml_example / "stringlistmodel.py").rename(self.temp_qml_example / "main.py")
+        (self.temp_qml_example / "stringlistmodel.pyproject").unlink()
+
+    @patch("deploy_lib.android.android_config.AndroidConfig._find_local_libs")
+    @patch("deploy_lib.android.buildozer.BuildozerConfig._BuildozerConfig__find_jars")
+    @patch("deploy_lib.android.android_config.AndroidConfig.recipes_exist")
+    @patch("deploy_lib.android.android_config.AndroidConfig._find_dependent_qt_modules")
+    @patch("deploy_lib.android.android_config.find_qtlibs_in_wheel")
+    def test_config_with_Qml(self, mock_qtlibs, mock_extraqtmodules, mock_recipes_exist,
+                             mock_find_jars, mock_local_libs, mock_extract_jar,
+                             mock_qmlimportscanner):
+        # setting up mocks
+        jar_dir = "tmp/jar/PySide6/jar"
+        mock_extract_jar.return_value = Path(jar_dir)
+        mock_qtlibs.return_value = self.pyside_wheel / "PySide6/Qt/lib"
+        mock_extraqtmodules.return_value = ['Qml', 'Network', 'QmlModels', 'OpenGL']
+        mock_recipes_exist.return_value = True
+        jars, init_classes = ["/tmp/jar/PySide6/jar/Qt6Android.jar",
+                              "/tmp/jar/PySide6/jar/Qt6AndroidBindings.jar",
+                              "/tmp/jar/PySide6/jar/Qt6AndroidNetworkInformationBackend.jar",
+                              "/tmp/jar/PySide6/jar/Qt6AndroidNetwork.jar"], []
+        mock_find_jars.return_value = jars, init_classes
+        dependent_plugins = ["platforms_qtforandroid",
+                             "platforminputcontexts_qtvirtualkeyboardplugin",
+                             "iconengines_qsvgicon"]
+        mock_local_libs.return_value = [], dependent_plugins
+        mock_qmlimportscanner.return_value = ["QtQuick"]
+
+        self.android_deploy.main(name="android_app", shiboken_wheel=self.shiboken_wheel,
+                                 pyside_wheel=self.pyside_wheel, ndk_path=self.ndk_path,
+                                 init=True, force=True, keep_deployment_files=True)
+
+        self.assertEqual(mock_extract_jar.call_count, 1)
+        self.assertEqual(mock_qtlibs.call_count, 1)
+        self.assertEqual(mock_extraqtmodules.call_count, 1)
+        self.assertEqual(mock_recipes_exist.call_count, 1)
+        self.assertEqual(mock_find_jars.call_count, 1)
+        self.assertEqual(mock_qmlimportscanner.call_count, 1)
+        self.assertTrue(self.config_file.exists())
+        self.assertTrue(self.buildozer_config_file.exists())
+
+        config_obj = self.deploy_lib.BaseConfig(config_file=self.config_file)
+        expected_modules = {"Quick", "Core", "Gui", "Network", "Qml", "QmlModels", "OpenGL"}
+        obtained_modules = set(config_obj.get_value("qt", "modules").split(","))
+        self.assertEqual(obtained_modules, expected_modules)
+        expected_local_libs = ""
+        self.assertEqual(config_obj.get_value("buildozer", "local_libs"),
+                         expected_local_libs)
+        expected_qt_plugins = set(dependent_plugins)
+        obtained_qt_plugins = set(config_obj.get_value("android", "plugins").split(","))
+        self.assertEqual(expected_qt_plugins, obtained_qt_plugins)
+
+        # test buildozer config file contents
+        buildozer_config_obj = self.deploy_lib.BaseConfig(config_file=self.buildozer_config_file)
+        obtained_jars = set(buildozer_config_obj.get_value("app", "android.add_jars").split(','))
+        expected_jars = set(jars)
+        self.assertEqual(obtained_jars, expected_jars)
+        obtained_extra_args = buildozer_config_obj.get_value("app", "p4a.extra_args")
+        extra_args_patrn = re.compile("--qt-libs=(?P<modules>.*) --load-local-libs="
+                                      "(?P<local_libs>.*) --init-classes=(?P<init_classes>.*)")
+        match = extra_args_patrn.search(obtained_extra_args)
+        obtained_modules = match.group("modules").split(',')
+        obtained_local_libs = match.group("local_libs")
+        obtained_init_classes = match.group("init_classes")
+        self.assertEqual(set(obtained_modules), expected_modules)
+        self.assertEqual(obtained_local_libs, expected_local_libs)
+        self.assertEqual(obtained_init_classes, '')
+
+        self.config_file.unlink()
+        self.buildozer_config_file.unlink()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/tools/pyside6-deploy/CMakeLists.txt b/sources/pyside6/tests/tools/pyside6-deploy/CMakeLists.txt
new file mode 100644
index 000000000..7f010fbd6
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-deploy/CMakeLists.txt
@@ -0,0 +1 @@
+PYSIDE_TEST(test_pyside6_deploy.py)
diff --git a/sources/pyside6/tests/tools/pyside6-deploy/extensive_deploy_test.py b/sources/pyside6/tests/tools/pyside6-deploy/extensive_deploy_test.py
new file mode 100644
index 000000000..40afc7f5c
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-deploy/extensive_deploy_test.py
@@ -0,0 +1,88 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+"""
+    Extensive manual test of pyside6-deploy
+
+    Note: Not to be added into the CI
+"""
+
+import logging
+import unittest
+import tempfile
+import shutil
+import sys
+import os
+import importlib
+from pathlib import Path
+
+
+class TestPySide6Deploy(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.pyside_root = Path(__file__).parents[5].resolve()
+        example_root = cls.pyside_root / "examples"
+        example_widgets = example_root / "widgets" / "widgets" / "tetrix"
+        example_qml = example_root / "qml" / "editingmodel"
+        example_webenginequick = example_root / "webenginequick" / "nanobrowser"
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.temp_example_widgets = Path(
+            shutil.copytree(example_widgets, Path(cls.temp_dir) / "tetrix")
+        ).resolve()
+        cls.temp_example_qml = Path(
+            shutil.copytree(example_qml, Path(cls.temp_dir) / "editingmodel")
+        ).resolve()
+        cls.temp_example_webenginequick = Path(
+            shutil.copytree(example_webenginequick, Path(cls.temp_dir) / "nanobrowser")
+        ).resolve()
+        cls.current_dir = Path.cwd()
+        cls.linux_onefile_icon = (
+            cls.pyside_root / "sources" / "pyside-tools" / "deploy_lib" / "pyside_icon.jpg"
+        )
+
+        sys.path.append(str(cls.pyside_root / "sources" / "pyside-tools"))
+        cls.deploy_lib = importlib.import_module("deploy_lib")
+        cls.deploy = importlib.import_module("deploy")
+        sys.modules["deploy"] = cls.deploy
+
+    def setUpWidgets(self):
+        os.chdir(self.temp_example_widgets)
+        self.main_file = self.temp_example_widgets / "tetrix.py"
+        self.config_file = self.temp_example_widgets / "pysidedeploy.spec"
+
+    def testWidget(self):
+        self.setUpWidgets()
+        self.deploy.main(self.main_file, name="widget_app", loglevel=logging.INFO,
+                         keep_deployment_files=True, force=True)
+
+        print("Now testing Widget with config file")
+        self.deploy.main(self.main_file, config_file=self.config_file, loglevel=logging.INFO,
+                         force=True)
+
+    def setUpQml(self):
+        os.chdir(self.temp_example_qml)
+        self.main_file = self.temp_example_qml / "main.py"
+        self.config_file = self.temp_example_qml / "pysidedeploy.spec"
+
+    def testQml(self):
+        self.setUpQml()
+        self.deploy.main(self.main_file, name="qml_app", loglevel=logging.INFO,
+                         keep_deployment_files=True, force=True)
+
+    def testWebEngineQuickDryRun(self):
+        os.chdir(self.temp_example_webenginequick)
+        main_file = self.temp_example_webenginequick / "quicknanobrowser.py"
+        self.deploy.main(main_file, name="qml_app", keep_deployment_files=True,
+                         loglevel=logging.INFO, force=True)
+
+    def tearDown(self) -> None:
+        super().tearDown()
+        os.chdir(self.current_dir)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        shutil.rmtree(Path(cls.temp_dir))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/tools/pyside6-deploy/test_pyside6_deploy.py b/sources/pyside6/tests/tools/pyside6-deploy/test_pyside6_deploy.py
new file mode 100644
index 000000000..db60c8c3f
--- /dev/null
+++ b/sources/pyside6/tests/tools/pyside6-deploy/test_pyside6_deploy.py
@@ -0,0 +1,400 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+import unittest
+import tempfile
+import shutil
+import sys
+import os
+import importlib
+import platform
+from pathlib import Path
+from unittest.mock import patch
+from unittest import mock
+
+sys.path.append(os.fspath(Path(__file__).resolve().parents[2]))
+from init_paths import init_test_paths, _get_qt_lib_dir  # noqa: E402
+init_test_paths(False)
+
+
+def is_pyenv_python():
+    pyenv_root = os.environ.get("PYENV_ROOT")
+
+    if pyenv_root and (resolved_exe := str(Path(sys.executable).resolve())):
+        return resolved_exe.startswith(pyenv_root)
+    return False
+
+
+class LongSortedOptionTest(unittest.TestCase):
+    @staticmethod
+    def _option_prepare(s):
+        """
+        Take a string and return a list obtained by text.split().
+        Options starting with "--" are also sorted."
+        """
+        items = s.split()
+        for idx in range(len(items)):
+            if items[idx].startswith("--"):
+                return items[:idx] + sorted(items[idx:])
+        return items
+
+    def assertEqual(self, text_a, text_b):
+        if (not isinstance(text_a, str) or not isinstance(text_b, str)
+                or (len(text_a) < 50 and len(text_b) < 50)):
+            return super().assertEqual(text_a, text_b)
+        sort_a = self._option_prepare(text_a)
+        sort_b = self._option_prepare(text_b)
+        return super().assertEqual(sort_a, sort_b)
+
+
+class DeployTestBase(LongSortedOptionTest):
+    @classmethod
+    def setUpClass(cls):
+        cls.pyside_root = Path(__file__).parents[5].resolve()
+        cls.example_root = cls.pyside_root / "examples"
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.current_dir = Path.cwd()
+        tools_path = cls.pyside_root / "sources" / "pyside-tools"
+        cls.win_icon = tools_path / "deploy_lib" / "pyside_icon.ico"
+        cls.linux_icon = tools_path / "deploy_lib" / "pyside_icon.jpg"
+        cls.macos_icon = tools_path / "deploy_lib" / "pyside_icon.icns"
+        if tools_path not in sys.path:
+            sys.path.append(str(cls.pyside_root / "sources" / "pyside-tools"))
+        cls.deploy_lib = importlib.import_module("deploy_lib")
+        cls.deploy = importlib.import_module("deploy")
+        sys.modules["deploy"] = cls.deploy
+        files_to_ignore = [".cpp.o", ".qsb", ".webp"]
+        cls.dlls_ignore_nuitka = " ".join([f"--noinclude-dlls=*{file}"
+                                           for file in files_to_ignore])
+
+        # required for comparing long strings
+        cls.maxDiff = None
+
+        # print no outputs to stdout
+        sys.stdout = mock.MagicMock()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        shutil.rmtree(Path(cls.temp_dir))
+
+    def tearDown(self) -> None:
+        super().tearDown()
+        os.chdir(self.current_dir)
+
+
+@unittest.skipIf(sys.platform == "darwin" and int(platform.mac_ver()[0].split('.')[0]) <= 11,
+                 "Test only works on macOS version 12+")
+@patch("deploy_lib.config.QtDependencyReader.find_plugin_dependencies")
+class TestPySide6DeployWidgets(DeployTestBase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        example_widgets = cls.example_root / "widgets" / "widgets" / "tetrix"
+        cls.temp_example_widgets = Path(
+            shutil.copytree(example_widgets, Path(cls.temp_dir) / "tetrix")
+        ).resolve()
+
+    def setUp(self):
+        os.chdir(self.temp_example_widgets)
+        self.main_file = self.temp_example_widgets / "tetrix.py"
+        self.deployment_files = self.temp_example_widgets / "deployment"
+        # All the plugins included. This is different from plugins_nuitka, because Nuitka bundles
+        # some plugins by default
+        self.all_plugins = ["accessiblebridge", "egldeviceintegrations", "generic", "iconengines",
+                            "imageformats", "platforminputcontexts", "platforms",
+                            "platforms/darwin", "platformthemes", "styles", "xcbglintegrations"]
+        # Plugins that needs to be passed to Nuitka
+        plugins_nuitka = ("accessiblebridge,platforminputcontexts,platforms/darwin")
+        self.expected_run_cmd = (
+            f"{sys.executable} -m nuitka {str(self.main_file)} --follow-imports"
+            f" --enable-plugin=pyside6 --output-dir={str(self.deployment_files)} --quiet"
+            f" --noinclude-qt-translations"
+            f" --include-qt-plugins={plugins_nuitka}"
+            f" {self.dlls_ignore_nuitka}"
+        )
+        if sys.platform.startswith("linux"):
+            self.expected_run_cmd += f" --linux-icon={str(self.linux_icon)} --onefile"
+        elif sys.platform == "darwin":
+            self.expected_run_cmd += (f" --macos-app-icon={str(self.macos_icon)}"
+                                      " --macos-create-app-bundle --standalone")
+        elif sys.platform == "win32":
+            self.expected_run_cmd += f" --windows-icon-from-ico={str(self.win_icon)} --onefile"
+
+        if is_pyenv_python():
+            self.expected_run_cmd += " --static-libpython=no"
+        self.config_file = self.temp_example_widgets / "pysidedeploy.spec"
+
+    def testWidgetDryRun(self, mock_plugins):
+        mock_plugins.return_value = self.all_plugins
+        # Checking for dry run commands is equivalent to mocking the
+        # subprocess.check_call() in commands.py as the the dry run command
+        # is the command being run.
+        original_output = self.deploy.main(self.main_file, dry_run=True, force=True)
+        self.assertEqual(original_output, self.expected_run_cmd)
+
+    @patch("deploy_lib.dependency_util.QtDependencyReader.get_qt_libs_dir")
+    def testWidgetConfigFile(self, mock_sitepackages, mock_plugins):
+        mock_sitepackages.return_value = Path(_get_qt_lib_dir())
+        mock_plugins.return_value = self.all_plugins
+        # includes both dry run and config_file tests
+        # init
+        init_result = self.deploy.main(self.main_file, init=True, force=True)
+        self.assertEqual(init_result, None)
+
+        # test with config
+        original_output = self.deploy.main(config_file=self.config_file, dry_run=True, force=True)
+        self.assertEqual(original_output, self.expected_run_cmd)
+
+        # # test config file contents
+        config_obj = self.deploy_lib.BaseConfig(config_file=self.config_file)
+        self.assertEqual(config_obj.get_value("app", "input_file"), "tetrix.py")
+        self.assertEqual(config_obj.get_value("app", "project_dir"), ".")
+        self.assertEqual(config_obj.get_value("app", "exec_directory"), ".")
+        self.assertEqual(config_obj.get_value("python", "packages"),
+                         "Nuitka==2.1")
+        self.assertEqual(config_obj.get_value("qt", "qml_files"), "")
+        equ_base = "--quiet --noinclude-qt-translations"
+        equ_value = equ_base + " --static-libpython=no" if is_pyenv_python() else equ_base
+        self.assertEqual(config_obj.get_value("nuitka", "extra_args"), equ_value)
+        self.assertEqual(config_obj.get_value("qt", "excluded_qml_plugins"), "")
+        expected_modules = {"Core", "Gui", "Widgets"}
+        if sys.platform != "win32":
+            expected_modules.add("DBus")
+        obtained_modules = set(config_obj.get_value("qt", "modules").split(","))
+        self.assertEqual(obtained_modules, expected_modules)
+        obtained_qt_plugins = config_obj.get_value("qt", "plugins").split(",")
+        self.assertEqual(obtained_qt_plugins.sort(), self.all_plugins.sort())
+        self.config_file.unlink()
+
+    def testErrorReturns(self, mock_plugins):
+        mock_plugins.return_value = self.all_plugins
+        # main file and config file does not exists
+        fake_main_file = self.main_file.parent / "main.py"
+        with self.assertRaises(RuntimeError) as context:
+            self.deploy.main(main_file=fake_main_file, config_file=self.config_file)
+        self.assertTrue("Directory does not contain main.py file." in str(context.exception))
+
+
+@unittest.skipIf(sys.platform == "darwin" and int(platform.mac_ver()[0].split('.')[0]) <= 11,
+                 "Test only works on macOS version 12+")
+@patch("deploy_lib.config.QtDependencyReader.find_plugin_dependencies")
+class TestPySide6DeployQml(DeployTestBase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        example_qml = cls.example_root / "qml" / "editingmodel"
+        cls.temp_example_qml = Path(
+            shutil.copytree(example_qml, Path(cls.temp_dir) / "editingmodel")
+        ).resolve()
+
+    def setUp(self):
+        os.chdir(self.temp_example_qml)
+        self.main_file = self.temp_example_qml / "main.py"
+        self.deployment_files = self.temp_example_qml / "deployment"
+        self.first_qml_file = "main.qml"
+        self.second_qml_file = "MovingRectangle.qml"
+
+        # All the plugins included. This is different from plugins_nuitka, because Nuitka bundles
+        # some plugins by default
+        self.all_plugins = ["accessiblebridge", "egldeviceintegrations", "generic", "iconengines",
+                            "imageformats", "networkaccess", "networkinformation",
+                            "platforminputcontexts", "platforms", "platforms/darwin",
+                            "platformthemes", "qmltooling", "scenegraph", "tls",
+                            "xcbglintegrations"]
+        # Plugins that needs to be passed to Nuitka
+        plugins_nuitka = ("accessiblebridge,networkaccess,networkinformation,platforminputcontexts,"
+                          "platforms/darwin,qml,qmltooling,scenegraph")
+        self.expected_run_cmd = (
+            f"{sys.executable} -m nuitka {str(self.main_file)} --follow-imports"
+            f" --enable-plugin=pyside6 --output-dir={str(self.deployment_files)} --quiet"
+            f" --noinclude-qt-translations"
+            f" {self.dlls_ignore_nuitka}"
+            " --noinclude-dlls=*/qml/QtQuickEffectMaker/*"
+            f" --include-qt-plugins={plugins_nuitka}"
+            f" --include-data-files={str(self.temp_example_qml / self.first_qml_file)}="
+            f"./main.qml --include-data-files="
+            f"{str(self.temp_example_qml / self.second_qml_file)}=./MovingRectangle.qml"
+        )
+
+        if sys.platform != "win32":
+            self.expected_run_cmd += (
+                " --noinclude-dlls=libQt6Charts*"
+                " --noinclude-dlls=libQt6Quick3D* --noinclude-dlls=libQt6Sensors*"
+                " --noinclude-dlls=libQt6Test* --noinclude-dlls=libQt6WebEngine*"
+            )
+        else:
+            self.expected_run_cmd += (
+                " --noinclude-dlls=Qt6Charts*"
+                " --noinclude-dlls=Qt6Quick3D* --noinclude-dlls=Qt6Sensors*"
+                " --noinclude-dlls=Qt6Test* --noinclude-dlls=Qt6WebEngine*"
+            )
+
+        if sys.platform.startswith("linux"):
+            self.expected_run_cmd += f" --linux-icon={str(self.linux_icon)} --onefile"
+        elif sys.platform == "darwin":
+            self.expected_run_cmd += (f" --macos-app-icon={str(self.macos_icon)}"
+                                      " --macos-create-app-bundle --standalone")
+        elif sys.platform == "win32":
+            self.expected_run_cmd += f" --windows-icon-from-ico={str(self.win_icon)} --onefile"
+
+        if is_pyenv_python():
+            self.expected_run_cmd += " --static-libpython=no"
+        self.config_file = self.temp_example_qml / "pysidedeploy.spec"
+
+    @patch("deploy_lib.dependency_util.QtDependencyReader.get_qt_libs_dir")
+    def testQmlConfigFile(self, mock_sitepackages, mock_plugins):
+        mock_sitepackages.return_value = Path(_get_qt_lib_dir())
+        mock_plugins.return_value = self.all_plugins
+        # create config file
+        with patch("deploy_lib.config.run_qmlimportscanner") as mock_qmlimportscanner:
+            mock_qmlimportscanner.return_value = ["QtQuick"]
+            init_result = self.deploy.main(self.main_file, init=True, force=True)
+            self.assertEqual(init_result, None)
+
+        # test config file contents
+        config_obj = self.deploy_lib.BaseConfig(config_file=self.config_file)
+        self.assertEqual(config_obj.get_value("app", "input_file"), "main.py")
+        self.assertEqual(config_obj.get_value("app", "project_dir"), ".")
+        self.assertEqual(config_obj.get_value("app", "exec_directory"), ".")
+        self.assertEqual(config_obj.get_value("python", "packages"),
+                         "Nuitka==2.1")
+        self.assertEqual(config_obj.get_value("qt", "qml_files"), "main.qml,MovingRectangle.qml")
+        equ_base = "--quiet --noinclude-qt-translations"
+        equ_value = equ_base + " --static-libpython=no" if is_pyenv_python() else equ_base
+        self.assertEqual(config_obj.get_value("nuitka", "extra_args"), equ_value)
+        self.assertEqual(
+            config_obj.get_value("qt", "excluded_qml_plugins"),
+            "QtCharts,QtQuick3D,QtSensors,QtTest,QtWebEngine",
+        )
+        expected_modules = {"Core", "Gui", "Qml", "Quick", "Network", "OpenGL", "QmlModels"}
+        if sys.platform != "win32":
+            expected_modules.add("DBus")
+        obtained_modules = set(config_obj.get_value("qt", "modules").split(","))
+        self.assertEqual(obtained_modules, expected_modules)
+        obtained_qt_plugins = config_obj.get_value("qt", "plugins").split(",")
+        self.assertEqual(obtained_qt_plugins.sort(), self.all_plugins.sort())
+        self.config_file.unlink()
+
+    def testQmlDryRun(self, mock_plugins):
+        mock_plugins.return_value = self.all_plugins
+        with patch("deploy_lib.config.run_qmlimportscanner") as mock_qmlimportscanner:
+            mock_qmlimportscanner.return_value = ["QtQuick"]
+            original_output = self.deploy.main(self.main_file, dry_run=True, force=True)
+            self.assertEqual(original_output, self.expected_run_cmd)
+            self.assertEqual(mock_qmlimportscanner.call_count, 1)
+
+    def testMainFileDryRun(self, mock_plugins):
+        mock_plugins.return_value = self.all_plugins
+        with patch("deploy_lib.config.run_qmlimportscanner") as mock_qmlimportscanner:
+            mock_qmlimportscanner.return_value = ["QtQuick"]
+            original_output = self.deploy.main(Path.cwd() / "main.py", dry_run=True, force=True)
+            self.assertEqual(original_output, self.expected_run_cmd)
+            self.assertEqual(mock_qmlimportscanner.call_count, 1)
+
+
+@unittest.skipIf(sys.platform == "darwin" and int(platform.mac_ver()[0].split('.')[0]) <= 11,
+                 "Test only works on macOS version 12+")
+class TestPySide6DeployWebEngine(DeployTestBase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        example_webenginequick = cls.example_root / "webenginequick" / "nanobrowser"
+        cls.temp_example_webenginequick = Path(
+            shutil.copytree(example_webenginequick, Path(cls.temp_dir) / "nanobrowser")
+        ).resolve()
+
+    @patch("deploy_lib.config.QtDependencyReader.find_plugin_dependencies")
+    @patch("deploy_lib.dependency_util.QtDependencyReader.get_qt_libs_dir")
+    def testWebEngineQuickDryRun(self, mock_sitepackages, mock_plugins):
+        mock_sitepackages.return_value = Path(_get_qt_lib_dir())
+        all_plugins = ["accessiblebridge", "egldeviceintegrations", "generic", "iconengines",
+                       "imageformats", "networkaccess", "networkinformation",
+                       "platforminputcontexts", "platforms", "platforms/darwin",
+                       "platformthemes", "qmltooling", "scenegraph", "tls",
+                       "xcbglintegrations"]
+        mock_plugins.return_value = all_plugins
+        # this test case retains the QtWebEngine dlls
+        # setup
+        os.chdir(self.temp_example_webenginequick)
+        main_file = self.temp_example_webenginequick / "quicknanobrowser.py"
+        deployment_files = self.temp_example_webenginequick / "deployment"
+        # Plugins that needs to be passed to Nuitka
+        plugins_nuitka = ("accessiblebridge,networkaccess,networkinformation,platforminputcontexts,"
+                          "platforms/darwin,qml,qmltooling,scenegraph")
+        qml_files = [
+            "ApplicationRoot.qml",
+            "BrowserDialog.qml",
+            "BrowserWindow.qml",
+            "DownloadView.qml",
+            "FindBar.qml",
+            "FullScreenNotification.qml",
+        ]
+        data_files_cmd = " ".join(
+            [
+                f"--include-data-files={str(self.temp_example_webenginequick / file)}=./{file}"
+                for file in qml_files
+            ]
+        )
+        expected_run_cmd = (
+            f"{sys.executable} -m nuitka {str(main_file)} --follow-imports"
+            f" --enable-plugin=pyside6 --output-dir={str(deployment_files)} --quiet"
+            f" --noinclude-qt-translations --include-qt-plugins=all"
+            f" {data_files_cmd}"
+            f" --include-qt-plugins={plugins_nuitka}"
+            f" {self.dlls_ignore_nuitka}"
+            " --noinclude-dlls=*/qml/QtQuickEffectMaker/*"
+        )
+
+        if sys.platform != "win32":
+            expected_run_cmd += (
+                " --noinclude-dlls=libQt6Charts*"
+                " --noinclude-dlls=libQt6Quick3D* --noinclude-dlls=libQt6Sensors*"
+                " --noinclude-dlls=libQt6Test*"
+            )
+        else:
+            expected_run_cmd += (
+                " --noinclude-dlls=Qt6Charts*"
+                " --noinclude-dlls=Qt6Quick3D* --noinclude-dlls=Qt6Sensors*"
+                " --noinclude-dlls=Qt6Test*"
+            )
+
+        if sys.platform.startswith("linux"):
+            expected_run_cmd += f" --linux-icon={str(self.linux_icon)} --onefile"
+        elif sys.platform == "darwin":
+            expected_run_cmd += (f" --macos-app-icon={str(self.macos_icon)}"
+                                 " --macos-create-app-bundle --standalone")
+        elif sys.platform == "win32":
+            expected_run_cmd += f" --windows-icon-from-ico={str(self.win_icon)} --onefile"
+
+        config_file = self.temp_example_webenginequick / "pysidedeploy.spec"
+
+        # create config file
+        with patch("deploy_lib.config.run_qmlimportscanner") as mock_qmlimportscanner:
+            mock_qmlimportscanner.return_value = ["QtQuick", "QtWebEngine"]
+            init_result = self.deploy.main(main_file, init=True, force=True)
+            self.assertEqual(init_result, None)
+
+            # run dry_run
+            original_output = self.deploy.main(main_file, dry_run=True, force=True)
+            self.assertTrue(original_output, expected_run_cmd)
+            self.assertEqual(mock_qmlimportscanner.call_count, 2)
+
+        # test config file contents
+        config_obj = self.deploy_lib.BaseConfig(config_file=config_file)
+        self.assertEqual(config_obj.get_value("app", "input_file"), "quicknanobrowser.py")
+        self.assertEqual(config_obj.get_value("qt", "qml_files"), ",".join(qml_files))
+        self.assertEqual(
+            config_obj.get_value("qt", "excluded_qml_plugins"),
+            "QtCharts,QtQuick3D,QtSensors,QtTest",
+        )
+        expected_modules = {"Core", "Gui", "Quick", "Qml", "WebEngineQuick", "Network", "OpenGL",
+                            "Positioning", "WebEngineCore", "WebChannel", "WebChannelQuick",
+                            "QmlModels"}
+        if sys.platform != "win32":
+            expected_modules.add("DBus")
+        obtained_modules = set(config_obj.get_value("qt", "modules").split(","))
+        self.assertEqual(obtained_modules, expected_modules)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/sources/pyside6/tests/tools/pyside6-qml/test_pyside6_qml.py b/sources/pyside6/tests/tools/pyside6-qml/test_pyside6_qml.py
index beedd4ae8..fdaf3d471 100644
--- a/sources/pyside6/tests/tools/pyside6-qml/test_pyside6_qml.py
+++ b/sources/pyside6/tests/tools/pyside6-qml/test_pyside6_qml.py
@@ -25,8 +25,8 @@ class TestPySide6QmlUnit(unittest.TestCase):
         self.pyside_root = self._dir.parents[4]
 
         self.pyqml_path = self.pyside_root / "sources" / "pyside-tools" / "qml.py"
-        self.core_qml_path = (self.pyside_root / "examples" / "qml" / "referenceexamples"
-                              / "adding")
+        self.core_qml_path = (self.pyside_root / "examples" / "qml" /
+                              "tutorials" / "extending-qml-advanced" / "adding")
 
         self.pyqml_run_cmd = [sys.executable, os.fspath(self.pyqml_path)]
 
@@ -63,7 +63,7 @@ class TestPySide6QmlUnit(unittest.TestCase):
 
     def testCoreApplication(self):
         self.pyqml_run_cmd.extend(["--apptype", "core"])
-        self.pyqml_run_cmd.append(str(self.core_qml_path / "example.qml"))
+        self.pyqml_run_cmd.append(str(self.core_qml_path / "People" / "Main.qml"))
         self.pyqml_run_cmd.extend(["-I", str(self.core_qml_path / "person.py")])
 
         result = subprocess.run(self.pyqml_run_cmd, stdout=PIPE, env=self.test_env)
diff --git a/sources/pyside6/tests/util/helper/docmodifier.py b/sources/pyside6/tests/util/helper/docmodifier.py
index 5a2421609..cfb665640 100644
--- a/sources/pyside6/tests/util/helper/docmodifier.py
+++ b/sources/pyside6/tests/util/helper/docmodifier.py
@@ -83,9 +83,9 @@ if __name__ == '__main__':
         doc_filter = lambda x: x.startswith('test')
         doc_suffix = 'suffix'
 
-    assert(Implementing.testBase.__doc__ == 'prefixbasesuffix')
-    assert(Implementing.testWithoutDoc.__doc__ == None)
-    assert(OnlySuffix.testBase.__doc__ == 'basesuffix')
-    assert(OnlySuffix.testWithoutDoc.__doc__ == None)
-    assert(OnlyPrefix.testBase.__doc__ == 'prefixbase')
-    assert(OnlyPrefix.testWithoutDoc.__doc__ == None)
+    assert (Implementing.testBase.__doc__ == 'prefixbasesuffix')
+    assert (Implementing.testWithoutDoc.__doc__ == None)
+    assert (OnlySuffix.testBase.__doc__ == 'basesuffix')
+    assert (OnlySuffix.testWithoutDoc.__doc__ == None)
+    assert (OnlyPrefix.testBase.__doc__ == 'prefixbase')
+    assert (OnlyPrefix.testWithoutDoc.__doc__ == None)
diff --git a/sources/pyside6/tests/util/helper/usesqapplication.py b/sources/pyside6/tests/util/helper/usesqapplication.py
index d09d1eb7a..f62e320f4 100644
--- a/sources/pyside6/tests/util/helper/usesqapplication.py
+++ b/sources/pyside6/tests/util/helper/usesqapplication.py
@@ -4,26 +4,40 @@
 '''Helper classes and functions'''
 
 import gc
+import sys
 import unittest
 
-from PySide6.QtWidgets import QApplication
+# This version avoids explicit import in order to adapt to the
+# import decision of the main module.
+# This should work with every compatible library.
+# Replaces the QtGui and QtCore versions as well.
 
 
 class UsesQApplication(unittest.TestCase):
-    '''Helper class to provide QApplication instances'''
-
-    qapplication = True
+    '''Helper class to provide Q(Core|Gui|)Application instances
+    Just connect or call self.exit_app_cb. When called, will ask
+    self.app to exit.
+    '''
 
     def setUp(self):
         '''Creates the QApplication instance'''
-
+        module = sys.modules[sorted(_ for _ in sys.modules
+                                    if _.endswith((".QtCore", ".QtGui", ".QtWidgets")))[-1]]
+        found = module.__name__.rsplit(".")[-1]
+        cls = getattr(module, {"QtWidgets": "QApplication",
+                               "QtGui":     "QGuiApplication",
+                               "QtCore":    "QCoreApplication"}[found])
         # Simple way of making instance a singleton
-        super(UsesQApplication, self).setUp()
-        self.app = QApplication.instance() or QApplication([])
+        super().setUp()
+        self.app = cls.instance() or cls([])
 
     def tearDown(self):
         '''Deletes the reference owned by self'''
         del self.app
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
-        super(UsesQApplication, self).tearDown()
+        super().tearDown()
+
+    def exit_app_cb(self):
+        '''Quits the application'''
+        self.app.exit(0)
diff --git a/sources/pyside6/tests/util/helper/usesqcoreapplication.py b/sources/pyside6/tests/util/helper/usesqcoreapplication.py
deleted file mode 100644
index 85f78d066..000000000
--- a/sources/pyside6/tests/util/helper/usesqcoreapplication.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-'''Helper classes and functions'''
-
-import gc
-import unittest
-
-from PySide6.QtCore import QCoreApplication
-
-_core_instance = None
-
-
-class UsesQCoreApplication(unittest.TestCase):
-    '''Helper class for test cases that require an QCoreApplication
-    Just connect or call self.exit_app_cb. When called, will ask
-    self.app to exit.
-    '''
-
-    def setUp(self):
-        '''Set up resources'''
-
-        global _core_instance
-        if _core_instance is None:
-            _core_instance = QCoreApplication([])
-
-        self.app = _core_instance
-
-    def tearDown(self):
-        '''Release resources'''
-        del self.app
-        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
-        gc.collect()
-
-    def exit_app_cb(self):
-        '''Quits the application'''
-        self.app.exit(0)
diff --git a/sources/pyside6/tests/util/helper/usesqguiapplication.py b/sources/pyside6/tests/util/helper/usesqguiapplication.py
deleted file mode 100644
index e02b57476..000000000
--- a/sources/pyside6/tests/util/helper/usesqguiapplication.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-'''Helper classes and functions'''
-
-import gc
-import unittest
-
-from PySide6.QtGui import QGuiApplication
-
-
-class UsesQGuiApplication(unittest.TestCase):
-    '''Helper class to provide QGuiApplication instances'''
-
-    def setUp(self):
-        '''Creates the QGuiApplication instance'''
-
-        # Simple way of making instance a singleton
-        super(UsesQGuiApplication, self).setUp()
-        self.app = QGuiApplication.instance() or QGuiApplication([])
-
-    def tearDown(self):
-        '''Deletes the reference owned by self'''
-        del self.app
-        # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
-        gc.collect()
-        super(UsesQGuiApplication, self).tearDown()
diff --git a/sources/pyside6/tests/util/processtimer.py b/sources/pyside6/tests/util/processtimer.py
index fb38943c8..e471cf167 100644
--- a/sources/pyside6/tests/util/processtimer.py
+++ b/sources/pyside6/tests/util/processtimer.py
@@ -27,7 +27,7 @@ class ProcessTimer(object):
 
     def waitfor(self):
         time_passed = 0
-        while(self.proc.poll() is None and time_passed < self.timeout):
+        while (self.proc.poll() is None and time_passed < self.timeout):
             time_passed = time_passed + 1
             time.sleep(1)
 
diff --git a/sources/pyside6/tests/util/pyqt_diff.py b/sources/pyside6/tests/util/pyqt_diff.py
deleted file mode 100644
index ac3d949d5..000000000
--- a/sources/pyside6/tests/util/pyqt_diff.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-'''Script to show the difference between PyQt5 and ours'''
-
-import sys
-
-from color import print_colored
-
-
-def check_module_diff(module_name):
-    '''Difference between PySide6 and PyQt5 versions of qt bindings.
-    Returns a tuple with the members present only on PySide6 and only on PyQt5'''
-    shiboken_module = getattr(__import__('PySide6.' + module_name), module_name)
-    orig_module = getattr(__import__('PyQt5.' + module_name), module_name)
-
-    shiboken_set = set(dir(shiboken_module))
-    orig_set = set(dir(orig_module))
-
-    return sorted(shiboken_set - orig_set), sorted(orig_set - shiboken_set)
-
-
-def main(argv=None):
-    if argv is None:
-        argv = sys.argv
-
-    module_name = argv[1] if len(argv) >= 2 else 'QtCore'
-
-    only_shiboken, only_orig = check_module_diff(module_name)
-
-    print_colored('Only on Shiboken version')
-    print(only_shiboken)
-
-    print_colored('Only on SIP version')
-    print(only_orig)
-
-
-if __name__ == '__main__':
-    main()